- renamed uniontype DAELow to BackendDAE

- renamed record DAELOW to DAE git-svn-id: https://openmodelica.org/svn/OpenModelica/branches/sjoelund-functiontree@6687 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
OpenModelica · Oct 28, 2010 · 67e5538 · 67e5538
1 parent 8ebd87b
commit 67e5538
Show file tree

Hide file tree

Showing 25 changed files with 704 additions and 754 deletions.
diff --git a/Compiler/Algorithm.mo b/Compiler/Algorithm.mo
@@ -254,7 +254,7 @@ algorithm
         t = getPropExpType(lhprop);
       then
         DAE.STMT_ASSIGN(t,DAE.CREF(c,crt),rhs_1,source);
-        /* TODO: Use this when we have fixed states in DAELow .lower(...)
+        /* TODO: Use this when we have fixed states in BackendDAE .lower(...)
         case (e1 as DAE.CALL(Absyn.IDENT("der"),{DAE.CREF(_,_)},_,_,_),lhprop,rhs,rhprop)
       equation
         (rhs_1,_) = Types.matchProp(rhs, rhprop, lhprop);

diff --git a/Compiler/BackendDAE.mo b/Compiler/BackendDAE.mo
@@ -34,7 +34,7 @@ package BackendDAE
   package:     BackendDAE
   description: BackendDAE contains the datatypes used by the backend.
 
-  RCS: $Id: DAELow.mo 6540 2010-10-22 21:07:52Z sjoelund.se $
+  RCS: $Id: BackendDAE.mo 6540 2010-10-22 21:07:52Z sjoelund.se $
 "
 
 public import Absyn;
@@ -47,7 +47,7 @@ public constant String derivativeNamePrefix="$DER";
 public constant String partialDerivativeNamePrefix="$pDER";
 
 public uniontype Type "
-Once we are in DAELow, the Type can be only basic types or enumeration.
+Once we are in BackendDAE, the Type can be only basic types or enumeration.
 We cannot do this in DAE because functions may contain many more types."
   record REAL end REAL;
   record INT end INT;
@@ -211,14 +211,14 @@ uniontype EventInfo "- EventInfo"
 end EventInfo;
 
 public
-uniontype DAELow "THE LOWERED DAE consist of variables and equations. The variables are split into
+uniontype BackendDAE "THE LOWERED DAE consist of variables and equations. The variables are split into
   two lists, one for unknown variables states and algebraic and one for known variables
   constants and parameters.
   The equations are also split into two lists, one with simple equations, a=b, a-b=0, etc., that
    are removed from  the set of equations to speed up calculations.
 
-  - DAELow"
-  record DAELOW
+  - BackendDAE"
+  record DAE
     Variables orderedVars "orderedVars ; ordered Variables, only states and alg. vars" ;
     Variables knownVars "knownVars ; Known variables, i.e. constants and parameters" ;
     Variables externalObjects "External object variables";
@@ -230,9 +230,9 @@ uniontype DAELow "THE LOWERED DAE consist of variables and equations. The variab
     array<DAE.Algorithm> algorithms "algorithms ; Algorithms" ;
     EventInfo eventInfo "eventInfo" ;
     ExternalObjectClasses extObjClasses "classes of external objects, contains constructor & destructor";
-  end DAELOW;
+  end DAE;
 
-end DAELow;
+end BackendDAE;
 
 type ExternalObjectClasses = list<ExternalObjectClass> "classes of external objects stored in list";
 

diff --git a/Compiler/BackendDAECreate.mo b/Compiler/BackendDAECreate.mo
@@ -67,24 +67,24 @@ protected import Values;
 public function lower
 "function: lower
   This function translates a DAE, which is the result from instantiating a
-  class, into a more precise form, called BackendDAE.DAELow defined in this module.
-  The BackendDAE.DAELow representation splits the DAE into equations and variables
+  class, into a more precise form, called BackendDAE.BackendDAE defined in this module.
+  The BackendDAE.BackendDAE representation splits the DAE into equations and variables
   and further divides variables into known and unknown variables and the
   equations into simple and nonsimple equations.
   The variables are inserted into a hash table. This gives a lookup cost of
   O(1) for finding a variable. The equations are put in an expandable
   array. Where adding a new equation can be done in O(1) time if space
   is available.
   inputs:  daeList: DAE.DAElist, simplify: bool)
-  outputs: BackendDAE.DAELow"
+  outputs: BackendDAE.BackendDAE"
   input DAE.DAElist lst;
   input DAE.FunctionTree functionTree;
   input Boolean addDummyDerivativeIfNeeded;
   input Boolean simplify;
 //  input Boolean removeTrivEqs "temporal input, for legacy purposes; doesn't add trivial equations to removed equations";
-  output BackendDAE.DAELow outDAELow;
+  output BackendDAE.BackendDAE outBackendDAE;
 algorithm
-  outDAELow := matchcontinue(lst, functionTree, addDummyDerivativeIfNeeded, simplify)
+  outBackendDAE := matchcontinue(lst, functionTree, addDummyDerivativeIfNeeded, simplify)
     local
       BackendDAE.BinTree s;
       BackendDAE.Variables vars,knvars,vars_1,extVars;
@@ -136,8 +136,8 @@ algorithm
         arr_md_eqns = listArray(aeqns1);
         algarr = listArray(algs);
         einfo = Inline.inlineEventInfo(BackendDAE.EVENT_INFO(whenclauses_1,zero_crossings),(SOME(functionTree),{DAE.NORM_INLINE()}));
-        BackendDAEUtil.checkBackendDAEWithErrorMsg(BackendDAE.DAELOW(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls));
-      then BackendDAE.DAELOW(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls);
+        BackendDAEUtil.checkBackendDAEWithErrorMsg(BackendDAE.DAE(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls));
+      then BackendDAE.DAE(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls);
 
     case(lst, functionTree, addDummyDerivativeIfNeeded, false) // do not simplify
       equation
@@ -172,8 +172,8 @@ algorithm
         arr_md_eqns = listArray(aeqns);
         algarr = listArray(algs);
         einfo = Inline.inlineEventInfo(BackendDAE.EVENT_INFO(whenclauses_1,zero_crossings),(SOME(functionTree),{DAE.NORM_INLINE()}));        
-        BackendDAEUtil.checkBackendDAEWithErrorMsg(BackendDAE.DAELOW(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls));        
-      then BackendDAE.DAELOW(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls);
+        BackendDAEUtil.checkBackendDAEWithErrorMsg(BackendDAE.DAE(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls));        
+      then BackendDAE.DAE(vars_1,knvars,extVars,aliasVars,eqnarr,reqnarr,ieqnarr,arr_md_eqns,algarr,einfo,extObjCls);
   end matchcontinue;
 end lower;
 
@@ -634,7 +634,7 @@ end lower2;
 
 protected function lowerVar
 "function: lowerVar
-  Transforms a DAE variable to DAELOW variable.
+  Transforms a DAE variable to DAE variable.
   Includes changing the ComponentRef name to a simpler form
   \'a\'.\'b\'{2}\'c\'{5} becomes
   \'a.b{2}.c\' (as CREF_IDENT(\"a.b.c\",{2}) )
@@ -2230,7 +2230,7 @@ protected function expandDerOperator
 "function expandDerOperator
   expands der(expr) using Derive.differentiteExpTime.
   This can not be done in Static, since we need all time-
-  dependent variables, which is only available in DAELow."
+  dependent variables, which is only available in BackendDAE."
   input BackendDAE.Variables vars;
   input list<BackendDAE.Equation> eqns;
   input list<BackendDAE.Equation> ieqns;
@@ -2839,11 +2839,11 @@ end findZeroCrossings3;
 public function zeroCrossingsEquations
 "Returns a list of all equations (by their index) that contain a zero crossing
  Used e.g. to find out which discrete equations are not part of a zero crossing"
-  input BackendDAE.DAELow dae;
+  input BackendDAE.BackendDAE dae;
   output list<Integer> eqns;
 algorithm
   eqns := matchcontinue(dae)
-    case (BackendDAE.DAELOW(eventInfo=BackendDAE.EVENT_INFO(zeroCrossingLst = zcLst),orderedEqs=eqnArr)) local
+    case (BackendDAE.DAE(eventInfo=BackendDAE.EVENT_INFO(zeroCrossingLst = zcLst),orderedEqs=eqnArr)) local
       list<BackendDAE.ZeroCrossing> zcLst;
       list<list<Integer>> zcEqns;
       list<Integer> wcEqns;

diff --git a/Compiler/BackendDAEOptimize.mo b/Compiler/BackendDAEOptimize.mo
@@ -74,7 +74,7 @@ protected import VarTransform;
 public function removeSimpleEquations
 "function: removeSimpleEquations
   This function moves simple equations on the form a=b from equations 2nd
-  in BackendDAE.DAELow to simple equations 3rd in BackendDAE.DAELow to speed up assignment alg.
+  in BackendDAE.BackendDAE to simple equations 3rd in BackendDAE.BackendDAE to speed up assignment alg.
   inputs:  (vars: Variables,
               knownVars: Variables,
               eqns: BackendDAE.Equation list,
@@ -613,13 +613,13 @@ public function tearingSystem
   Pervormes tearing method on a system.
   This is just a funktion to check the flack tearing.
   All other will be done at tearingSystem1."
-  input BackendDAE.DAELow inDlow;
+  input BackendDAE.BackendDAE inDlow;
   input BackendDAE.IncidenceMatrix inM;
   input BackendDAE.IncidenceMatrixT inMT;
   input array<Integer> inV1;
   input array<Integer> inV2;
   input list<list<Integer>> inComps;
-  output BackendDAE.DAELow outDlow;
+  output BackendDAE.BackendDAE outDlow;
   output BackendDAE.IncidenceMatrix outM;
   output BackendDAE.IncidenceMatrixT outMT;
   output array<Integer> outV1;
@@ -631,7 +631,7 @@ algorithm
   (outDlow,outM,outMT,outV1,outV2,outComps,outResEqn,outTearVar):=
   matchcontinue (inDlow,inM,inMT,inV1,inV2,inComps)
     local
-      BackendDAE.DAELow dlow,dlow_1,dlow1;
+      BackendDAE.BackendDAE dlow,dlow_1,dlow1;
       BackendDAE.IncidenceMatrix m,m_1;
       BackendDAE.IncidenceMatrixT mT,mT_1;
       array<Integer> v1,v2,v1_1,v2_1;
@@ -667,8 +667,8 @@ protected function copyDaeLowforTearing
   autor: Frenkel TUD
   Copy the dae to avoid changes in
   vectors."
-  input BackendDAE.DAELow inDlow;
-  output BackendDAE.DAELow outDlow;
+  input BackendDAE.BackendDAE inDlow;
+  output BackendDAE.BackendDAE outDlow;
 algorithm
   outDlow:=
   matchcontinue (inDlow)
@@ -688,7 +688,7 @@ algorithm
       Integer bucketSize;
       Integer numberOfVars;
       array<Option<BackendDAE.Var>> varOptArr,varOptArr1;
-    case (BackendDAE.DAELOW(ordvars,knvars,exobj,av,eqns,remeqns,inieqns,arreqns,algorithms,einfo,eoc))
+    case (BackendDAE.DAE(ordvars,knvars,exobj,av,eqns,remeqns,inieqns,arreqns,algorithms,einfo,eoc))
       equation
         BackendDAE.VARIABLES(crefIdxLstArr,strIdxLstArr,varArr,bucketSize,numberOfVars) = ordvars;
         BackendDAE.VARIABLE_ARRAY(n1,size1,varOptArr) = varArr;
@@ -704,7 +704,7 @@ algorithm
         arr_1 = Util.arrayCopy(arr, arr_1);
         eqns1 = BackendDAE.EQUATION_ARRAY(n,size,arr_1);
       then
-        BackendDAE.DAELOW(ordvars1,knvars,exobj,av,eqns1,remeqns,inieqns,arreqns,algorithms,einfo,eoc);
+        BackendDAE.DAE(ordvars1,knvars,exobj,av,eqns1,remeqns,inieqns,arreqns,algorithms,einfo,eoc);
   end matchcontinue;
 end copyDaeLowforTearing;
 
@@ -713,17 +713,17 @@ protected function tearingSystem1
   autor: Frenkel TUD
   Main loop. Check all Comps and start tearing if
   strong connected components there"
-  input BackendDAE.DAELow inDlow;
-  input BackendDAE.DAELow inDlow1;
+  input BackendDAE.BackendDAE inDlow;
+  input BackendDAE.BackendDAE inDlow1;
   input BackendDAE.IncidenceMatrix inM;
   input BackendDAE.IncidenceMatrixT inMT;
   input array<Integer> inV1;
   input array<Integer> inV2;
   input list<list<Integer>> inComps;
   output list<list<Integer>> outResEqn;
   output list<list<Integer>> outTearVar;
-  output BackendDAE.DAELow outDlow;
-  output BackendDAE.DAELow outDlow1;
+  output BackendDAE.BackendDAE outDlow;
+  output BackendDAE.BackendDAE outDlow1;
   output BackendDAE.IncidenceMatrix outM;
   output BackendDAE.IncidenceMatrixT outMT;
   output array<Integer> outV1;
@@ -733,7 +733,7 @@ algorithm
   (outResEqn,outTearVar,outDlow,outDlow1,outM,outMT,outV1,outV2,outComps):=
   matchcontinue (inDlow,inDlow1,inM,inMT,inV1,inV2,inComps)
     local
-      BackendDAE.DAELow dlow,dlow_1,dlow_2,dlow1,dlow1_1,dlow1_2;
+      BackendDAE.BackendDAE dlow,dlow_1,dlow_2,dlow1,dlow1_1,dlow1_2;
       BackendDAE.IncidenceMatrix m,m_1,m_2,m_3,m_4;
       BackendDAE.IncidenceMatrixT mT,mT_1,mT_2,mT_3,mT_4;
       array<Integer> v1,v2,v1_1,v2_1,v1_2,v2_2,v1_3,v2_3;
@@ -813,7 +813,7 @@ protected function getTearingVars
   input array<BackendDAE.Value> inV1;
   input array<BackendDAE.Value> inV2;
   input list<BackendDAE.Value> inComp;
-  input BackendDAE.DAELow inDlow;
+  input BackendDAE.BackendDAE inDlow;
   output list<BackendDAE.Value> outVarLst;
   output list<DAE.ComponentRef> outCrLst;
 algorithm
@@ -824,13 +824,13 @@ algorithm
       array<BackendDAE.Value> v1,v2;
       BackendDAE.Value c,v;
       list<BackendDAE.Value> comp,varlst;
-      BackendDAE.DAELow dlow;
+      BackendDAE.BackendDAE dlow;
       DAE.ComponentRef cr;
       list<DAE.ComponentRef> crlst;
       BackendDAE.Variables ordvars;
       BackendDAE.VariableArray varr;
     case (m,v1,v2,{},dlow) then ({},{});
-    case (m,v1,v2,c::comp,dlow as BackendDAE.DAELOW(orderedVars = ordvars as BackendDAE.VARIABLES(varArr=varr)))
+    case (m,v1,v2,c::comp,dlow as BackendDAE.DAE(orderedVars = ordvars as BackendDAE.VARIABLES(varArr=varr)))
       equation
         v = v2[c];
         BackendDAE.VAR(varName = cr) = BackendVariable.vararrayNth(varr, v-1);
@@ -846,8 +846,8 @@ protected function tearingSystem2
   select a residual equation.
   The equation with most connections to
   variables will be selected."
-  input BackendDAE.DAELow inDlow;
-  input BackendDAE.DAELow inDlow1;
+  input BackendDAE.BackendDAE inDlow;
+  input BackendDAE.BackendDAE inDlow1;
   input BackendDAE.IncidenceMatrix inM;
   input BackendDAE.IncidenceMatrixT inMT;
   input array<Integer> inV1;
@@ -862,8 +862,8 @@ protected function tearingSystem2
   output list<Integer> outResEqns;
   output list<Integer> outTearVars;
   output list<Integer> outTearEqns;
-  output BackendDAE.DAELow outDlow;
-  output BackendDAE.DAELow outDlow1;
+  output BackendDAE.BackendDAE outDlow;
+  output BackendDAE.BackendDAE outDlow1;
   output BackendDAE.IncidenceMatrix outM;
   output BackendDAE.IncidenceMatrixT outMT;
   output array<Integer> outV1;
@@ -873,7 +873,7 @@ algorithm
   (outResEqns,outTearVars,outTearEqns,outDlow,outDlow1,outM,outMT,outV1,outV2,outComp):=
   matchcontinue (inDlow,inDlow1,inM,inMT,inV1,inV2,inComp,inTVars,inExclude,inResEqns,inTearVars,inTearEqns,inCrlst)
     local
-      BackendDAE.DAELow dlow,dlow_1,dlow1,dlow1_1;
+      BackendDAE.BackendDAE dlow,dlow_1,dlow1,dlow1_1;
       BackendDAE.IncidenceMatrix m,m_1;
       BackendDAE.IncidenceMatrixT mT,mT_1;
       array<Integer> v1,v2,v1_1,v2_1;
@@ -924,8 +924,8 @@ protected function tearingSystem3
   a tearing variable. The variable with
   most connections to equations will be
   selected."
-  input BackendDAE.DAELow inDlow;
-  input BackendDAE.DAELow inDlow1;
+  input BackendDAE.BackendDAE inDlow;
+  input BackendDAE.BackendDAE inDlow1;
   input BackendDAE.IncidenceMatrix inM;
   input BackendDAE.IncidenceMatrixT inMT;
   input array<Integer> inV1;
@@ -941,8 +941,8 @@ protected function tearingSystem3
   output list<Integer> outResEqns;
   output list<Integer> outTearVars;
   output list<Integer> outTearEqns;
-  output BackendDAE.DAELow outDlow;
-  output BackendDAE.DAELow outDlow1;
+  output BackendDAE.BackendDAE outDlow;
+  output BackendDAE.BackendDAE outDlow1;
   output BackendDAE.IncidenceMatrix outM;
   output BackendDAE.IncidenceMatrixT outMT;
   output array<Integer> outV1;
@@ -952,7 +952,7 @@ algorithm
   (outResEqns,outTearVars,outTearEqns,outDlow,outDlow1,outM,outMT,outV1,outV2,outComp):=
   matchcontinue (inDlow,inDlow1,inM,inMT,inV1,inV2,inComp,inTVars,inExclude,inResEqn,inResEqns,inTearVars,inTearEqns,inCrlst)
     local
-      BackendDAE.DAELow dlow,dlow_1,dlow_2,dlow_3,dlow1,dlow1_1,dlow1,dlow1_1,dlow1_2,dlowc,dlowc1;
+      BackendDAE.BackendDAE dlow,dlow_1,dlow_2,dlow_3,dlow1,dlow1_1,dlow1,dlow1_1,dlow1_2,dlowc,dlowc1;
       BackendDAE.IncidenceMatrix m,m_1,m_2,m_3;
       BackendDAE.IncidenceMatrixT mT,mT_1,mT_2,mT_3;
       array<Integer> v1,v2,v1_1,v2_1,v1_2,v2_2;
@@ -990,9 +990,9 @@ algorithm
         Debug.fcall("tearingdump", print, str2);
         // copy dlow
         dlowc = copyDaeLowforTearing(dlow);
-        BackendDAE.DAELOW(ordvars as BackendDAE.VARIABLES(varArr=varr),knvars,exobj,av,eqns,remeqns,inieqns,arreqns,algorithms,einfo,eoc) = dlowc;
+        BackendDAE.DAE(ordvars as BackendDAE.VARIABLES(varArr=varr),knvars,exobj,av,eqns,remeqns,inieqns,arreqns,algorithms,einfo,eoc) = dlowc;
         dlowc1 = copyDaeLowforTearing(dlow1);
-        BackendDAE.DAELOW(orderedVars = ordvars1,orderedEqs = eqns1) = dlowc1;
+        BackendDAE.DAE(orderedVars = ordvars1,orderedEqs = eqns1) = dlowc1;
         // add Tearing Var
         BackendDAE.VAR(varName = cr as DAE.CREF_IDENT(ident = ident, identType = identType, subscriptLst = subscriptLst )) = BackendVariable.vararrayNth(varr, tearingvar-1);
         ident_t = stringAppend("tearingresidual_",ident);
@@ -1013,8 +1013,8 @@ algorithm
                           {},false,true,DAE.ET_REAL(),DAE.NO_INLINE()),
                           DAE.CREF(cr,DAE.ET_REAL()), DAE.emptyElementSource));
         tearingeqnid = BackendDAEUtil.equationSize(eqns_2);
-        dlow_1 = BackendDAE.DAELOW(vars_1,knvars,exobj,av,eqns_2,remeqns,inieqns,arreqns,algorithms,einfo,eoc);
-        dlow1_1 = BackendDAE.DAELOW(ordvars1,knvars,exobj,av,eqns1_1,remeqns,inieqns,arreqns,algorithms,einfo,eoc);
+        dlow_1 = BackendDAE.DAE(vars_1,knvars,exobj,av,eqns_2,remeqns,inieqns,arreqns,algorithms,einfo,eoc);
+        dlow1_1 = BackendDAE.DAE(ordvars1,knvars,exobj,av,eqns1_1,remeqns,inieqns,arreqns,algorithms,einfo,eoc);
         // try causalisation
         m_1 = BackendDAEUtil.incidenceMatrix(dlow_1);
         mT_1 = BackendDAEUtil.transposeMatrix(m_1);
@@ -1052,7 +1052,7 @@ algorithm
         comp_2 = Util.listSelect1(cmops_flat,comp,Util.listContains);
       then
         (residualeqns_1,tearingvars_1,tearingeqns_1,dlow_3,dlow1_2,m_3,mT_3,v1_2,v2_2,comp_2);
-    case (dlow as BackendDAE.DAELOW(orderedVars = BackendDAE.VARIABLES(varArr=varr)),dlow1,m,mT,v1,v2,comp,vars,exclude,residualeqn,residualeqns,tearingvars,tearingeqns,crlst)
+    case (dlow as BackendDAE.DAE(orderedVars = BackendDAE.VARIABLES(varArr=varr)),dlow1,m,mT,v1,v2,comp,vars,exclude,residualeqn,residualeqns,tearingvars,tearingeqns,crlst)
       equation
         (tearingvar,_) = getMaxfromListList(mT,vars,comp,0,0,exclude);
         // check if tearing var is found
@@ -1063,7 +1063,7 @@ algorithm
         (residualeqns_1,tearingvars_1,tearingeqns_1,dlow_1,dlow1_1,m_1,mT_1,v1_1,v2_1,comp_1) = tearingSystem3(dlow,dlow1,m,mT,v1,v2,comp,vars,tearingvar::exclude,residualeqn,residualeqns,tearingvars,tearingeqns,crlst);
       then
         (residualeqns_1,tearingvars_1,tearingeqns_1,dlow_1,dlow1_1,m_1,mT_1,v1_1,v2_1,comp_1);
-    case (dlow as BackendDAE.DAELOW(orderedVars = BackendDAE.VARIABLES(varArr=varr)),dlow1,m,mT,v1,v2,comp,vars,exclude,residualeqn,residualeqns,tearingvars,tearingeqns,_)
+    case (dlow as BackendDAE.DAE(orderedVars = BackendDAE.VARIABLES(varArr=varr)),dlow1,m,mT,v1,v2,comp,vars,exclude,residualeqn,residualeqns,tearingvars,tearingeqns,_)
       equation
         (tearingvar,_) = getMaxfromListList(mT,vars,comp,0,0,exclude);
         // check if tearing var is found
@@ -1081,8 +1081,8 @@ protected function tearingSystem4
   autor: Frenkel TUD
   Internal Main loop for additional
   tearing vars and residual eqns."
-  input BackendDAE.DAELow inDlow;
-  input BackendDAE.DAELow inDlow1;
+  input BackendDAE.BackendDAE inDlow;
+  input BackendDAE.BackendDAE inDlow1;
   input BackendDAE.IncidenceMatrix inM;
   input BackendDAE.IncidenceMatrixT inMT;
   input array<Integer> inV1;
@@ -1097,8 +1097,8 @@ protected function tearingSystem4
   output list<Integer> outResEqns;
   output list<Integer> outTearVars;
   output list<Integer> outTearEqns;
-  output BackendDAE.DAELow outDlow;
-  output BackendDAE.DAELow outDlow1;
+  output BackendDAE.BackendDAE outDlow;
+  output BackendDAE.BackendDAE outDlow1;
   output BackendDAE.IncidenceMatrix outM;
   output BackendDAE.IncidenceMatrixT outMT;
   output array<Integer> outV1;
@@ -1109,7 +1109,7 @@ algorithm
   (outResEqns,outTearVars,outTearEqns,outDlow,outDlow1,outM,outMT,outV1,outV2,outComp,outCompCount):=
   matchcontinue (inDlow,inDlow1,inM,inMT,inV1,inV2,inComps,inResEqns,inTearVars,inTearEqns,inComp,inCompCount,inCrlst)
     local
-      BackendDAE.DAELow dlow,dlow_1,dlow_2,dlow1,dlow1_1,dlow1_2;
+      BackendDAE.BackendDAE dlow,dlow_1,dlow_2,dlow1,dlow1_1,dlow1_2;
       BackendDAE.IncidenceMatrix m,m_1,m_2;
       BackendDAE.IncidenceMatrixT mT,mT_1,mT_2;
       array<Integer> v1,v2,v1_1,v2_1,v1_2,v2_2;