Changeset 29797a1 in OpenModelica

Timestamp:

2021-04-08T11:44:41+02:00 (3 years ago)

Author:

Martin Sjölund <martin@…>

Children:

defe92d3

Parents:

7d6513e

Message:

Algebraic equations have index higher than dynamic

File:

• OMCompiler/Compiler/SimCode/SimCodeUtil.mo (modified) (12 diffs)

OMCompiler/Compiler/SimCode/SimCodeUtil.mo

@@ -867 +867 @@
     (_, _, equations, _, ouniqueEqIndex, clockedVars, oeqSccMapping, oeqBackendSimCodeMapping, oBackendMapping) :=
         createEquationsForSystem(stateeqnsmark, zceqnsmarks, syst, inShared, comps, ouniqueEqIndex, {},
-                                 sccOffset, oeqSccMapping, oeqBackendSimCodeMapping, oBackendMapping, true);
+                                 sccOffset, oeqSccMapping, oeqBackendSimCodeMapping, oBackendMapping, OutputSystems.Both, true);
     sccOffset := listLength(comps) + sccOffset;
     //otempvars := listAppend(clockedVars, otempvars);
@@ -1438 +1438 @@
 // =============================================================================
 
+protected type OutputSystems = enumeration(States, NonStates, Both);
 
 protected type CreateEquationsForSystemsFold =
@@ -1450 +1451 @@
       SimCode.BackendMapping  /*backendSimCodeMapping*/,
       Integer  /*sccOffset*/>;
-protected type CreateEquationsForSystemsArg = tuple<BackendDAE.Shared, list<BackendDAE.ZeroCrossing>, Boolean>;
+protected type CreateEquationsForSystemsArg = tuple<BackendDAE.Shared, list<BackendDAE.ZeroCrossing>, OutputSystems, Boolean>;
 
 protected function createEquationsForSystems "Some kind of comments would be very helpful!"
@@ -1477 +1478 @@
 algorithm
   try
-    arg := (shared, inAllZeroCrossings, createAlgebraicEquations);
+    arg := (shared, inAllZeroCrossings, OutputSystems.States, createAlgebraicEquations);
     foldArg := (iuniqueEqIndex, {}, {}, {}, {}, itempvars, {}, {}, iBackendMapping, iSccOffset);
+    foldArg := List.fold1(inSysts, createEquationsForSystems1, arg, foldArg);
+    arg := (shared, inAllZeroCrossings, OutputSystems.NonStates, createAlgebraicEquations);
     foldArg := List.fold1(inSysts, createEquationsForSystems1, arg, foldArg);
     (ouniqueEqIndex, oodeEquations, oalgebraicEquations, oallEquations, oequationsForZeroCrossings, otempvars,
@@ -1495 +1498 @@
   input CreateEquationsForSystemsFold inFold;
   output CreateEquationsForSystemsFold outFold;
-algorithm
+protected
+  BackendDAE.StrongComponents compsStates, compsNonStates, comps;
+  list<BackendDAE.ZeroCrossing> zeroCrossings;
+  BackendDAE.Shared shared;
+  Boolean createAlgebraicEquations;
+  OutputSystems outputSystemsKind;
+algorithm
+  (shared, zeroCrossings, outputSystemsKind, createAlgebraicEquations) := inArg;
   outFold := match inSyst.matching
     local
       list<SimCode.SimEqSystem> odeEquations1, algebraicEquations1, allEquations1;
-      BackendDAE.StrongComponents comps;
       BackendDAE.EqSystem syst;
       list<list<SimCode.SimEqSystem>> odeEquations, algebraicEquations;
@@ -1511 +1520 @@
       list<tuple<Integer,Integer>> eqSccMapping, eqBackendSimCodeMapping;
       SimCode.BackendMapping backendMapping;
-      list<BackendDAE.ZeroCrossing> zeroCrossings;
-      BackendDAE.Shared shared;
-      Boolean createAlgebraicEquations;
     case BackendDAE.MATCHING(ass1=ass1, comps=comps)
       equation
@@ -1520 +1526 @@
         end if;
 
-        (shared, zeroCrossings, createAlgebraicEquations) = inArg;
         (uniqueEqIndex, odeEquations, algebraicEquations, allEquations, equationsForZeroCrossings, tempvars,
          eqSccMapping, eqBackendSimCodeMapping, backendMapping, sccOffset) = inFold;
@@ -1536 +1541 @@
             createEquationsForSystem(
                 stateeqnsmark, zceqnsmarks, syst, shared, comps, uniqueEqIndex, tempvars,
-                sccOffset, eqSccMapping, eqBackendSimCodeMapping, backendMapping, createAlgebraicEquations);
+                sccOffset, eqSccMapping, eqBackendSimCodeMapping, backendMapping, outputSystemsKind, createAlgebraicEquations);
         GC.free(stateeqnsmark);
         GC.free(zceqnsmarks);
@@ -1565 +1570 @@
 protected type CreateEquationsForSystemArg =
 tuple<array<Integer> /*stateeqnsmark*/, array<Integer> /*zceqnsmark*/,
-      BackendDAE.EqSystem /*syst*/, BackendDAE.Shared /*shared*/, Boolean>;
+      BackendDAE.EqSystem /*syst*/, BackendDAE.Shared /*shared*/, OutputSystems, Boolean>;
 
 protected function createEquationsForSystem
@@ -1579 +1584 @@
   input list<tuple<Integer,Integer>> ieqBackendSimCodeMapping;
   input SimCode.BackendMapping iBackendMapping;
+  input OutputSystems outputSystemsKind;
   input Boolean createAlgebraicEquations;
   output list<SimCode.SimEqSystem> outOdeEquations;
@@ -1594 +1600 @@
   list<list<SimCode.SimEqSystem>> odeEquations, algebraicEquations, allEquations, equationsforZeroCrossings;
 algorithm
-  arg := (stateeqnsmark, zceqnsmark, syst, shared, createAlgebraicEquations);
+  arg := (stateeqnsmark, zceqnsmark, syst, shared, outputSystemsKind, createAlgebraicEquations);
   foldArg := (iuniqueEqIndex, {}, {}, {}, {}, itempvars, ieqSccMapping, ieqBackendSimCodeMapping, iBackendMapping, iSccIndex);
   foldArg := List.fold2(comps, createEquationsForSystem1, arg, partitionKindToClockIndex(syst.partitionKind), foldArg);
@@ -1649 +1655 @@
   list<BackendDAE.Var> varlst;
   list<BackendDAE.Equation> eqnlst;
+  OutputSystems outputSystemsKind;
   Boolean createAlgebraicEquations, bdynamic, skip;
-  Boolean debug = false;
-algorithm
-  (stateeqnsmark, zceqnsmark, syst, shared, createAlgebraicEquations) := inArg;
+  constant Boolean debug = false;
+algorithm
+  (stateeqnsmark, zceqnsmark, syst, shared, outputSystemsKind, createAlgebraicEquations) := inArg;
   (uniqueEqIndex, odeEquations, algebraicEquations, allEquations, equationsforZeroCrossings,
   tempvars, eqSccMapping, eqBackendSimCodeMapping, backendMapping, sccIndex) := inFold;
-  (varlst,varIdx,eqnlst,eqsIdx) := BackendDAEUtil.getStrongComponentVarsAndEquations(comp, syst.orderedVars, syst.orderedEqs);
+  (varlst, varIdx, eqnlst, eqsIdx) := BackendDAEUtil.getStrongComponentVarsAndEquations(comp, syst.orderedVars, syst.orderedEqs);
   bdynamic := BackendDAEUtil.blockIsDynamic(eqsIdx, stateeqnsmark);
+
+  if outputSystemsKind==OutputSystems.Both or (if outputSystemsKind==OutputSystems.States then bdynamic else not bdynamic) then
+    outFold := inFold;
+    return;
+  end if;
 
   skip := false;