[DAEmode] added several minor things

 - added DAE_CONTEXT
 - disable compiler optimization for some dae functions
 - preparation to use eqAttr in the code generation

Belonging to [master]:
  - #2309

Author: Willi Braun

Compiler/SimCode/SimCodeFunction.mo

@@ -222,6 +222,9 @@ uniontype Context
 
   record FMI_CONTEXT
   end FMI_CONTEXT;
+
+  record DAE_MODE_CONTEXT
+  end DAE_MODE_CONTEXT;
 end Context;
 
 public constant Context contextSimulationNonDiscrete  = SIMULATION_CONTEXT(false);
@@ -236,6 +239,7 @@ public constant Context contextParallelFunction       = PARALLEL_FUNCTION_CONTEX
 public constant Context contextZeroCross              = ZEROCROSSINGS_CONTEXT();
 public constant Context contextOptimization           = OPTIMIZATION_CONTEXT();
 public constant Context contextFMI                    = FMI_CONTEXT();
+public constant Context contextDAEmode                = DAE_MODE_CONTEXT();
 
 constant list<DAE.Exp> listExpLength1 = {DAE.ICONST(0)} "For CodegenC.tpl";
 constant list<Variable> boxedRecordOutVars = VARIABLE(DAE.CREF_IDENT("",DAE.T_COMPLEX_DEFAULT_RECORD,{}),DAE.T_COMPLEX_DEFAULT_RECORD,NONE(),{},DAE.NON_PARALLEL(),DAE.VARIABLE())::{} "For CodegenC.tpl";

Compiler/SimCode/SimCodeMain.mo

@@ -1068,7 +1068,7 @@ protected
   Integer maxDelayedExpIndex;
   Integer uniqueEqIndex = 1;
   Integer nStates;
-  Integer numberofEqns, numStateSets, numberofLinearSys, numberofNonLinearSys,
+  Integer numberofEqns, numberofLinearSys, numberofNonLinearSys,
   numberofMixedSys, numberOfJacobians, numberofFixedParameters;
   Boolean tmpB;
 
@@ -1086,9 +1086,9 @@ protected
   Option<SimCode.JacobianMatrix> daeModeSP;
   Option<SimCode.DaeModeData> daeModeData;
   SimCode.DaeModeConfig daeModeConf;
-  list<SimCode.SimEqSystem> daeEquations, removedEquations;
+
+  list<list<SimCode.SimEqSystem>> daeEquations;
   list<SimCodeVar.SimVar> residualVars, algebraicStateVars, auxiliaryVars;
-  list<SimCode.StateSet> stateSets;
 
   tuple<Option<BackendDAE.SymbolicJacobian>, BackendDAE.SparsePattern, BackendDAE.SparseColoring> daeModeJac;
   SimCode.JacobianMatrix symDAESparsPattern;
@@ -1155,19 +1155,8 @@ algorithm
 
     discreteModelVars := BackendDAEUtil.foldEqSystem(inBackendDAE, SimCodeUtil.extractDiscreteModelVars, {});
 
-    //prepare DAEmode stuff
-    eqnsLst := BackendEquation.equationSystemsEqnsLst(inBackendDAE.eqs);
-    varsLst := BackendVariable.equationSystemsVarsLst(inBackendDAE.eqs);
-    daeVars := BackendVariable.listVar(varsLst);
-    daeEqns := BackendEquation.listEquation(eqnsLst);
-    // create SimCode residual equation
-    (daeEquations, uniqueEqIndex, tempVars) := SimCodeUtil.createEquationsfromList(listReverse(eqnsLst), varsLst, uniqueEqIndex, tempVars, inBackendDAE.shared.info, true, true);
-
-    (uniqueEqIndex, removedEquations) := BackendEquation.traverseEquationArray(BackendDAEUtil.collapseRemovedEqs(inBackendDAE), SimCodeUtil.traversedlowEqToSimEqSystem, (uniqueEqIndex, {}));
-    daeEquations := listAppend(daeEquations, removedEquations);
-    // state set stuff
-    (_, stateSets, uniqueEqIndex, tempVars, numStateSets) := SimCodeUtil.createStateSets(inBackendDAE, {}, uniqueEqIndex, tempVars);
-    if debug then ExecStat.execStat("simCode: createStateSets"); end if;
+    // create DAEmode equations
+    (daeEquations, uniqueEqIndex, tempVars) := SimCodeUtil.createEquationsfromBackendDAE(inBackendDAE, uniqueEqIndex, tempVars, true, true);
 
     // create model info
     // create dummy system where all original variables are created
@@ -1177,14 +1166,12 @@ algorithm
     // disable start value calculation, it's only helpful in case of algebraic loops
     // and they are not present in DAEmode
     tmpB := Flags.set(Flags.NO_START_CALC, true);
-    modelInfo := SimCodeUtil.createModelInfo(className, p, emptyBDAE, inInitDAE, functions, {}, numStateSets, fileDir, 0, tempVars);
+    modelInfo := SimCodeUtil.createModelInfo(className, p, emptyBDAE, inInitDAE, functions, {}, 0, fileDir, 0, tempVars);
     Flags.set(Flags.NO_START_CALC, tmpB);
 
     //create hash table
     crefToSimVarHT := SimCodeUtil.createCrefToSimVarHT(modelInfo);
 
-    // collect symbolic jacobians from state selection
-    (stateSets, modelInfo, SymbolicJacsStateSelect) :=  SimCodeUtil.addAlgebraicLoopsModelInfoStateSets(stateSets, modelInfo);
     // collect symbolic jacobians in initialization loops of the overall jacobians
     SymbolicJacsNLS := {};
     (initialEquations, modelInfo, SymbolicJacsTemp) := SimCodeUtil.addAlgebraicLoopsModelInfo(initialEquations, modelInfo);
@@ -1193,7 +1180,7 @@ algorithm
     SymbolicJacsNLS := listAppend(SymbolicJacsTemp, SymbolicJacsNLS);
     (symJacs, uniqueEqIndex) := SimCodeUtil.createSymbolicJacobianssSimCode({}, crefToSimVarHT, uniqueEqIndex, {"A", "B", "C", "D"}, {});
     (SymbolicJacs, modelInfo, SymbolicJacsTemp) := SimCodeUtil.addAlgebraicLoopsModelInfoSymJacs(symJacs, modelInfo);
-    SymbolicJacs := listAppend(SymbolicJacs, SymbolicJacsStateSelect);
+
     // collect jacobian equation only for equantion info file
     jacobianEquations := SimCodeUtil.collectAllJacobianEquations(SymbolicJacs);
     if debug then ExecStat.execStat("simCode: create Jacobian linear code"); end if;
@@ -1205,8 +1192,10 @@ algorithm
     seedVars := SimCodeUtil.collectAllSeedVars(SymbolicJacs);
     modelInfo := SimCodeUtil.setSeedVars(seedVars, modelInfo);
 
-
     // create dae SimVars: residual and algebraic
+    varsLst := BackendVariable.equationSystemsVarsLst(inBackendDAE.eqs);
+    daeVars := BackendVariable.listVar(varsLst);
+
     // create residual variables, set index and push them SimCode HashTable
     ((_, resVars)) := BackendVariable.traverseBackendDAEVars(daeVars, BackendVariable.collectVarKindVarinVariables, (BackendVariable.isDAEmodeResVar, BackendVariable.emptyVars()));
     ((residualVars, _)) :=  BackendVariable.traverseBackendDAEVars(resVars, SimCodeUtil.traversingdlowvarToSimvar, ({}, BackendVariable.emptyVars()));
@@ -1237,7 +1226,7 @@ algorithm
     ({symDAESparsPattern}, uniqueEqIndex) := SimCodeUtil.createSymbolicJacobianssSimCode({daeModeJac}, crefToSimVarHT, uniqueEqIndex, {"daeMode"}, {});
     daeModeSP := SOME(symDAESparsPattern);
     daeModeConf := SimCode.ALL_EQUATIONS();
-    daeModeData := SOME(SimCode.DAEMODEDATA({daeEquations}, daeModeSP, residualVars, algebraicStateVars, auxiliaryVars, daeModeConf));
+    daeModeData := SOME(SimCode.DAEMODEDATA(daeEquations, daeModeSP, residualVars, algebraicStateVars, auxiliaryVars, daeModeConf));
 
     /* This is a *much* better estimate than the guessed number of equations */
     modelInfo := SimCodeUtil.addNumEqns(modelInfo, uniqueEqIndex-listLength(jacobianEquations));
@@ -1262,11 +1251,11 @@ algorithm
                               minValueEquations,
                               maxValueEquations,
                               parameterEquations,
-                              removedEquations,
                               {},
                               {},
                               {},
-                              stateSets,
+                              {},
+                              {},
                               {},
                               {},
                               zeroCrossings,

Compiler/SimCode/SimCodeUtil.mo

@@ -4990,6 +4990,39 @@ algorithm
   end matchcontinue;
 end createEquationsIfBranch;
 
+public function createEquationsfromBackendDAE
+  input BackendDAE.BackendDAE inBDAE;
+  input Integer iuniqueEqIndex;
+  input list<SimCodeVar.SimVar> itempvars;
+  input Boolean genDiscrete = false;
+  input Boolean includeWhen = false;
+  input Boolean skipDiscInZc = false;
+  input Boolean skipDiscInAlgorithm = false;
+  output list<list<SimCode.SimEqSystem>> outEquations = {};
+  output Integer uniqueEqIndex = iuniqueEqIndex;
+  output list<SimCodeVar.SimVar> tempvars = itempvars;
+protected
+  BackendDAE.StrongComponents comps;
+  list<SimCode.SimEqSystem> simEqs, zeroVarEquations;
+algorithm
+  for syst in inBDAE.eqs loop
+    // get components
+    comps := BackendDAEUtil.getCompsOfMatching(syst.matching);
+
+    // create SimCode equatinos
+    (simEqs, _, uniqueEqIndex, tempvars) := createEquations(includeWhen, skipDiscInZc, genDiscrete, skipDiscInAlgorithm, syst, inBDAE.shared, comps, uniqueEqIndex, tempvars);
+
+    // process also the zeroVariable equations
+    (uniqueEqIndex, zeroVarEquations) := BackendEquation.traverseEquationArray(syst.removedEqs, SimCodeUtil.traversedlowEqToSimEqSystem, (uniqueEqIndex, {}));
+
+    // add the zero variable equations
+    simEqs := listAppend(simEqs, zeroVarEquations);
+
+    // add equations
+    outEquations := listAppend(outEquations, {simEqs});
+  end for;
+end createEquationsfromBackendDAE;
+
 public function createEquationsfromList
   input list<BackendDAE.Equation> inEquations;
   input list<BackendDAE.Var> inVars;

Compiler/Template/CodegenC.tpl

@@ -3873,6 +3873,18 @@ template functionXXX_systems(list<list<SimEqSystem>> eqs, String name, Text &loo
     >>
 end functionXXX_systems;
 
+template createEquationsAndCalls(list<list<SimEqSystem>> systems, String name, Context context, String modelNamePrefixStr, Text eqCalls, Text eqFuncs)
+::=
+  let _ = (systems |> equations => (
+          equations |> eq => (
+            let &eqFuncs += equation_impl(-1, eq, context, modelNamePrefixStr)
+            let &eqCalls += equationNames_(eq, context, modelNamePrefixStr)
+            <<>>
+          )
+        )
+      )
+  <<>>
+end createEquationsAndCalls;
 
 template equationNamesArrayFormat(SimEqSystem eq, Context context, String name, Integer arrayIndex, Text &arrayEqs, Text &forwardEqs, String modelNamePrefixStr)
  "Generates an equation.
@@ -4017,30 +4029,21 @@ template evaluateDAEResiduals(list<list<SimEqSystem>> resEquations, String model
   "Generates function in simulation file."
 ::=
   let &eqFuncs = buffer ""
-  let &nrfuncs = buffer ""
-  let &fncalls = buffer ""
+  let &eqCalls = buffer ""
 
-  let systems = if Flags.isSet(Flags.PARMODAUTO) then
-                    (functionXXX_systems_arrayFormat(resEquations, "DAERes", &fncalls, &nrfuncs, &eqFuncs, modelNamePrefix))
-                else
-                    (functionXXX_systems(resEquations, "DAERes", &fncalls, &eqFuncs, modelNamePrefix))
+  let systems = createEquationsAndCalls(resEquations, "DAERes", contextDAEmode, modelNamePrefix, &eqCalls, &eqFuncs)
   <<
   /*residual equations*/
   <%eqFuncs%>
-  <%(resEquations |> eqLst => (eqLst |> eq hasindex i0 =>
-                    equation_impl(-1, eq, contextSimulationDiscrete, modelNamePrefix)
-                    ;separator="\n");separator="\n")%>
-  <%systems%>
+
   /* for residuals DAE variables */
+  OMC_DISABLE_OPT
   int <%symbolName(modelNamePrefix,"evaluateDAEResiduals")%>(DATA *data, threadData_t *threadData)
   {
     TRACE_PUSH
     data->simulationInfo->callStatistics.functionEvalDAE++;
 
-    <%if Flags.isSet(Flags.PARMODAUTO) then 'PM_functionDAERes(<%nrfuncs%>, data, threadData, functionDAERes_systems);'
-    else fncalls %>
-
-    <%symbolName(modelNamePrefix,"function_savePreSynchronous")%>(data, threadData);
+    <%eqCalls%>
 
     TRACE_POP
     return 0;
@@ -4075,6 +4078,7 @@ template algebraicDAEVar(list<SimVar> algVars, String modelNamePrefix)
 
   <<
   /* algebraic nominal values */
+  OMC_DISABLE_OPT
   int <%symbolName(modelNamePrefix,"getAlgebraicDAEVarNominals")%>(DATA *data, threadData_t *threadData, double* algebraicNominal)
   {
     TRACE_PUSH
@@ -4085,6 +4089,7 @@ template algebraicDAEVar(list<SimVar> algVars, String modelNamePrefix)
   }
 
   /* forward algebraic variables */
+  OMC_DISABLE_OPT
   int <%symbolName(modelNamePrefix,"setAlgebraicDAEVars")%>(DATA *data, threadData_t *threadData, double* algebraic)
   {
     TRACE_PUSH
@@ -4093,6 +4098,7 @@ template algebraicDAEVar(list<SimVar> algVars, String modelNamePrefix)
     return 0;
   }
   /* get algebraic variables */
+  OMC_DISABLE_OPT
   int <%symbolName(modelNamePrefix,"getAlgebraicDAEVars")%>(DATA *data, threadData_t *threadData, double* algebraic)
   {
     TRACE_PUSH
@@ -4114,6 +4120,7 @@ template initializeDAEmodeData(Integer nResVars, Integer nAlgVars, Integer nAuxV
   let maxColorStr = '<%maxColor%>'
   <<
   /* initialize the daeMode variables */
+  OMC_DISABLE_OPT
   int <%symbolName(modelNamePrefix,"initializeDAEmodeData")%>(DATA *inData, DAEMODE_DATA* daeModeData)
   {
     TRACE_PUSH
@@ -5101,7 +5108,9 @@ template equationNames_(SimEqSystem eq, Context context, String modelNamePrefixS
   else
     equationIndex(eq)
   end match
+  let simEqAttr = match context case(DAE_MODE_CONTEXT()) then '/* eqAttr: <%simEqAttr(eq)%> */'
   <<
+  <%simEqAttr%>
   <% if profileAll() then 'SIM_PROF_TICK_EQ(<%ix%>);' %>
   <%symbolName(modelNamePrefixStr,"eqFunction")%>_<%ix%>(data, threadData);
   <% if profileAll() then 'SIM_PROF_ACC_EQ(<%ix%>);' %>
@@ -5826,6 +5835,42 @@ template crefM(ComponentRef cr)
   else "P" + crefToMStr(cr)
 end crefM;
 
+template simEqAttr(SimEqSystem eq)
+::=
+  match eq
+  case SES_RESIDUAL(__)
+  case SES_SIMPLE_ASSIGN(__)
+  case SES_SIMPLE_ASSIGN_CONSTRAINTS(__)
+  case SES_ARRAY_CALL_ASSIGN(__)
+  case SES_IFEQUATION(__)
+  case SES_ALGORITHM(__)
+  case SES_LINEAR(__)
+  case SES_NONLINEAR(__)
+  case SES_MIXED(__)
+  case SES_WHEN(__)
+  case SES_FOR_LOOP(__)
+    then eqAttributes(eqAttr)
+end simEqAttr;
+
+template eqAttributes(EquationAttributes eqAtt)
+::=
+  match eqAtt
+  case EQUATION_ATTRIBUTES(kind=kind) then '<%eqKind(kind)%>'
+  else ''
+end eqAttributes;
+
+template eqKind(EquationKind eqKind)
+::=
+  match eqKind
+  case DYNAMIC_EQUATION() then  'DYNAMIC_EQN_KIND'
+  case BINDING_EQUATION() then  'BINDING_EQN_KIND'
+  case INITIAL_EQUATION() then  'INITAL_EQN_KIND'
+  case CLOCKED_EQUATION() then  'CLOCKED_EQN_KIND'
+  case DISCRETE_EQUATION() then 'DISCRETE_EQN_KIND'
+  case AUX_EQUATION() then      'AUX_EQN_KIND'
+  case UNKNOWN_EQUATION_KIND() then 'UNKNOWN_EQN_KIND'
+end eqKind;
+
 /*****************************************************************************
  *         SECTION: GENERATE OPTIMIZATION IN SIMULATION FILE
  *****************************************************************************/

Compiler/Template/CodegenCFunctions.tpl

@@ -3184,6 +3184,7 @@ template algStmtWhen(DAE.Statement when, Context context, Text &varDecls, Text &
  "Generates a when algorithm statement."
 ::=
   match context
+    case DAE_MODE_CONTEXT(__)
     case SIMULATION_CONTEXT(__) then
       match when
         case STMT_WHEN(__) then
@@ -5178,6 +5179,7 @@ template daeExpRelationSim(Exp exp, Context context, Text &preExp,
 match exp
 case rel as RELATION(__) then
   match context
+  case DAE_MODE_CONTEXT(__)
   case SIMULATION_CONTEXT(__) then
     match rel.optionExpisASUB
     case NONE() then

Compiler/Template/SimCodeTV.mo

@@ -830,6 +830,8 @@ package SimCodeFunction
     end OPTIMIZATION_CONTEXT;
     record FMI_CONTEXT
     end FMI_CONTEXT;
+    record DAE_MODE_CONTEXT
+    end DAE_MODE_CONTEXT;
   end Context;
 
   constant Context contextSimulationNonDiscrete;
@@ -844,6 +846,7 @@ package SimCodeFunction
   constant Context contextZeroCross;
   constant Context contextOptimization;
   constant Context contextFMI;
+  constant Context contextDAEmode;
   constant list<DAE.Exp> listExpLength1;
   constant list<SimCodeFunction.Variable> boxedRecordOutVars;
 end SimCodeFunction;
@@ -1321,6 +1324,30 @@ package BackendDAE
 
   type Constraints = list<DAE.Constraint> "Constraints on the solvability of the (casual) tearing set; needed for proper Dynamic Tearing";
 
+  uniontype EquationKind "equation kind"
+    record BINDING_EQUATION
+    end BINDING_EQUATION;
+    record DYNAMIC_EQUATION
+    end DYNAMIC_EQUATION;
+    record INITIAL_EQUATION
+    end INITIAL_EQUATION;
+    record CLOCKED_EQUATION
+      Integer clk;
+    end CLOCKED_EQUATION;
+    record DISCRETE_EQUATION
+    end DISCRETE_EQUATION;
+    record AUX_EQUATION
+    end AUX_EQUATION;
+    record UNKNOWN_EQUATION_KIND
+    end UNKNOWN_EQUATION_KIND;
+  end EquationKind;
+
+  uniontype EquationAttributes
+    record EQUATION_ATTRIBUTES
+      Boolean differentiated "true if the equation was differentiated, and should not differentiated again to avoid equal equations";
+      EquationKind kind;
+    end EQUATION_ATTRIBUTES;
+  end EquationAttributes;
 end BackendDAE;
 
 package System