Merge remote-tracking branch 'origin/master' into masterMW

OpenModelica · Jun 23, 2015 · 3432e3e · 3432e3e
2 parents 2ab8072 + 47ff858
commit 3432e3e
Show file tree

Hide file tree

Showing 42 changed files with 2,125 additions and 2,250 deletions.
diff --git a/3rdParty b/3rdParty
diff --git a/Compiler/BackEnd/BackendDAECreate.mo b/Compiler/BackEnd/BackendDAECreate.mo
@@ -135,11 +135,7 @@ algorithm
   ieqnarr := BackendEquation.listEquation(ieqns);
   einfo := BackendDAE.EVENT_INFO(timeEvents, whenclauses_1, {}, {}, {}, 0, arrayCreate(0, DAE.INFERRED_CLOCK()));
   symjacs := {(NONE(), ({}, {}, ({}, {})), {}), (NONE(), ({}, {}, ({}, {})), {}), (NONE(), ({}, {}, ({}, {})), {}), (NONE(), ({}, {}, ({}, {})), {})};
-  outBackendDAE := BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,
-                                                      eqnarr,
-                                                      NONE(),
-                                                      NONE(),
-                                                      BackendDAE.NO_MATCHING(), {}, BackendDAE.UNKNOWN_PARTITION())::{},
+  outBackendDAE := BackendDAE.DAE(BackendDAEUtil.createEqSystem(vars_1, eqnarr)::{},
                                   BackendDAE.SHARED(knvars,
                                                     extVars,
                                                     aliasVars,

diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo
@@ -1537,7 +1537,7 @@ algorithm
 
       case (SOME((bdae, _, _, _, _)), _, _)
         equation
-          bdae = BackendDAEUtil.addBackendDAEFunctionTree(inFunctions, bdae);
+          bdae = BackendDAEUtil.setFunctionTree(bdae, inFunctions);
           BackendDAE.DAE(shared = BackendDAE.SHARED(functionTree = usedfuncs)) =
             removeUnusedFunctions(bdae);
           outUsedFunctions = DAEUtil.joinAvlTrees(outUsedFunctions, usedfuncs);
@@ -4124,6 +4124,133 @@ algorithm
   outDAE := BackendDAE.DAE(osystlst, oshared);
 end addedScaledVarsWork;
 
+// =============================================================================
+// section for sortEqnsVars
+//
+// author: Vitalij Ruge
+// =============================================================================
+
+public function sortEqnsVars
+  input BackendDAE.BackendDAE iDAE;
+  output BackendDAE.BackendDAE oDAE;
+algorithm
+  oDAE := if Flags.isSet(Flags.SORT_EQNS_AND_VARS)  then sortEqnsVarsWork(iDAE) else iDAE;
+end sortEqnsVars;
+
+protected function sortEqnsVarsWork
+  input BackendDAE.BackendDAE iDAE;
+  output BackendDAE.BackendDAE oDAE = iDAE;
+protected
+  list<BackendDAE.EqSystem> systlst, new_systlst = {};
+  BackendDAE.Shared shared;
+  BackendDAE.Variables vars;
+  BackendDAE.EquationArray eqns;
+  BackendDAE.BaseClockPartitionKind partitionKind;
+  BackendDAE.StateSets stateSets;
+  BackendDAE.IncidenceMatrix m;
+  BackendDAE.IncidenceMatrixT mT;
+  Integer ne,nv;
+  array<Integer> w_vars, w_eqns;
+  DAE.FunctionTree functionTree;
+  array<Option<BackendDAE.Var>> varOptArr;
+  array<Option<BackendDAE.Equation>> equOptArr;
+  list<tuple<Integer,Integer>> tplIndexWeight;
+  list<Integer> indexs;
+  list<BackendDAE.Var> var_lst;
+  list<BackendDAE.Equation> eqn_lst;
+algorithm
+  //BackendDump.bltdump("START:", oDAE);
+  BackendDAE.DAE(systlst, shared) := iDAE;
+  BackendDAE.SHARED(functionTree=functionTree) := shared;
+  for syst in systlst loop
+    BackendDAE.EQSYSTEM(orderedVars=vars,orderedEqs=eqns,stateSets=stateSets,partitionKind=partitionKind) := syst;
+    (_, m, mT) := BackendDAEUtil.getIncidenceMatrix(syst, BackendDAE.SPARSE(), SOME(functionTree));
+
+    BackendDAE.VARIABLES(varArr = BackendDAE.VARIABLE_ARRAY(varOptArr = varOptArr, numberOfElements = nv)) := vars;
+    BackendDAE.EQUATION_ARRAY(equOptArr = equOptArr, numberOfElement = ne) := eqns;
+
+    //init weights
+    w_vars := arrayCreate(nv, -1);
+    w_eqns := arrayCreate(ne, -1);
+
+    //weights vars, TODO: improve me!
+    sortEqnsVarsWeights(w_vars, nv, mT);
+    //weights eqns, TODO: improve me!
+    sortEqnsVarsWeights(w_eqns, ne, m);
+
+    //sort vars
+    tplIndexWeight := list((i, w_vars[i]) for i in 1:nv);
+    //sorted vars
+    tplIndexWeight := List.sort(tplIndexWeight, compWeightsVars);
+    //new order vars indexs
+    indexs := sortEqnsVarsWorkTpl(tplIndexWeight);
+    var_lst := list(BackendVariable.getVarAt(vars, i) for i in indexs);
+   // new vars
+    vars := BackendVariable.listVar1(var_lst);
+
+    //sort eqns
+    tplIndexWeight := list((i, w_eqns[i]) for i in 1:ne);
+    //sorted eqns
+    tplIndexWeight := List.sort(tplIndexWeight, compWeightsEqns);
+    //new order eqns indexs
+    indexs := sortEqnsVarsWorkTpl(tplIndexWeight);
+    eqn_lst := list(BackendEquation.equationNth1(eqns, i) for i in indexs);
+    //new eqns
+    eqns := BackendEquation.listEquation(eqn_lst);
+
+    new_systlst := BackendDAE.EQSYSTEM(vars, eqns, NONE(), NONE(), BackendDAE.NO_MATCHING(), stateSets, partitionKind) :: new_systlst;
+  end for; //syst
+
+  oDAE:= BackendDAE.DAE(new_systlst, shared);
+  //BackendDump.bltdump("ENDE:", oDAE);
+end sortEqnsVarsWork;
+
+protected function sortEqnsVarsWorkTpl
+  input list<tuple<Integer,Integer>> tplIndexWeight;
+  output list<Integer> outIndexs;
+algorithm
+  outIndexs := list(Util.tuple21(elem) for elem in tplIndexWeight);
+end sortEqnsVarsWorkTpl;
+
+protected function sortEqnsVarsWeights
+  input array<Integer> inW;
+  input Integer n;
+  input BackendDAE.IncidenceMatrix m;
+  output array<Integer> outW = inW;
+protected
+  Integer i;
+algorithm
+  for i in 1:n loop
+    outW[i] := listLength(m[i]);
+  end for;
+end sortEqnsVarsWeights;
+
+// sort({2, 1, 3}, intGt) => {1, 2, 3}
+// sort({2, 1, 3}, intLt) => {3, 2, 1}
+protected function compWeightsVars
+  input tuple<Integer,Integer> inTpl1;
+  input tuple<Integer,Integer> inTpl2;
+  output Boolean b;
+protected
+  Integer i1,i2;
+algorithm
+  (_,i1) := inTpl1;
+  (_,i2) := inTpl2;
+  b := intGt(i1 ,i2);
+end compWeightsVars;
+
+protected function compWeightsEqns
+  input tuple<Integer,Integer> inTpl1;
+  input tuple<Integer,Integer> inTpl2;
+  output Boolean b;
+protected
+  Integer i1,i2;
+algorithm
+  (_,i1) := inTpl1;
+  (_,i2) := inTpl2;
+  //b := intLt(i1 ,i2);
+  b := intGt(i1 ,i2);
+end compWeightsEqns;
 
 // =============================================================================
 // section for symEuler
@@ -4693,7 +4820,7 @@ algorithm
 
     case BackendDAE.EQSYSTEM(orderedVars, orderedEqs, _, _, _, stateSets, partitionKind) equation
       (orderedEqs, _) = BackendEquation.traverseEquationArray_WithUpdate(orderedEqs, addTimeAsState2, inFoo);
-    then BackendDAE.EQSYSTEM(orderedVars, orderedEqs, NONE(), NONE(), BackendDAE.NO_MATCHING(), stateSets, partitionKind);
+    then BackendDAEUtil.createEqSystem(orderedVars, orderedEqs, stateSets, partitionKind);
 
     else inSystem;
   end matchcontinue;

diff --git a/Compiler/BackEnd/BackendDAETransform.mo b/Compiler/BackEnd/BackendDAETransform.mo
@@ -293,7 +293,7 @@ algorithm
       vars_1 = BackendVariable.listVar1(var_lst_1);
       eqns_1 = BackendEquation.listEquation(eqn_lst1);
       (mixedSystem, _) = BackendEquation.iterationVarsinRelations(eqn_lst1, vars_1);
-      syst = BackendDAE.EQSYSTEM(vars_1, eqns_1, NONE(), NONE(), BackendDAE.NO_MATCHING(), {}, BackendDAE.UNKNOWN_PARTITION());
+      syst = BackendDAEUtil.createEqSystem(vars_1, eqns_1);
       (m, mt) = BackendDAEUtil.incidenceMatrix(syst, BackendDAE.ABSOLUTE(), NONE());
       // calculate jacobian. If constant, linear system of equations. Otherwise nonlinear
       (jac, shared) = SymbolicJacobian.calculateJacobian(vars_1, eqns_1, m, true, ishared);