Warn about iteration variables with no nominal attribute

Activate warning with: -d=warnNoNominal
see ticket:4512

Author: ptaeuber

Compiler/BackEnd/BackendDAEUtil.mo

@@ -6882,6 +6882,9 @@ algorithm
 
   // generate system for initialization
   (outInitDAE, outInitDAE_lambda0_option, outRemovedInitialEquationLst, globalKnownVars) := Initialization.solveInitialSystem(dae);
+  if Flags.isSet(Flags.WARN_NO_NOMINAL) then
+    warnAboutIterationVariablesWithNoNominal(outInitDAE);
+  end if;
 
   // use function tree from initDAE further for simDAE
   simDAE := BackendDAEUtil.setFunctionTree(dae, BackendDAEUtil.getFunctions(outInitDAE.shared));
@@ -6897,6 +6900,9 @@ algorithm
 
   // post-optimization phase
   simDAE := postOptimizeDAE(simDAE, postOptModules, matchingAlgorithm, daeHandler);
+  if Flags.isSet(Flags.WARN_NO_NOMINAL) then
+    warnAboutIterationVariablesWithNoNominal(simDAE);
+  end if;
 
   // sort the globalKnownVars
   simDAE := sortGlobalKnownVarsInDAE(simDAE);
@@ -9235,5 +9241,53 @@ algorithm
   names := stringDelimitList(list(ComponentReference.printComponentRefStr(BackendVariable.varCref(BackendVariable.getVarAt(varsArray, v))) for v in vars), ", ");
 end getVariableNamesForErrorMessage;
 
+// =============================================================================
+// warn about iteration variables with no nominal attribute
+//
+// =============================================================================
+
+protected function warnAboutIterationVariablesWithNoNominal
+" author: ptaeuber"
+  input BackendDAE.BackendDAE inDAE;
+protected
+  BackendDAE.StrongComponents comps;
+  String daeTypeStr, compKind;
+  list<Integer> vlst = {};
+  list<BackendDAE.Var> vars;
+algorithm
+  daeTypeStr := BackendDump.printBackendDAEType2String(inDAE.shared.backendDAEType);
+  for syst in inDAE.eqs loop
+    BackendDAE.EQSYSTEM(matching=BackendDAE.MATCHING(comps=comps)) := syst;
+
+    // Go through all the strongly connected components.
+    for comp in comps loop
+      // Get the component's variables.
+      (compKind, vlst) := match(comp)
+        case BackendDAE.EQUATIONSYSTEM(vars = vlst, jacType = BackendDAE.JAC_NONLINEAR())
+          then ("nonlinear equation system in the " + daeTypeStr + " DAE:", vlst);
+        case BackendDAE.EQUATIONSYSTEM(vars = vlst, jacType = BackendDAE.JAC_GENERIC())
+          then ("equation system w/o analytic Jacobian in the " + daeTypeStr + " DAE:", vlst);
+        case BackendDAE.EQUATIONSYSTEM(vars = vlst, jacType = BackendDAE.JAC_NO_ANALYTIC())
+          then ("equation system w/o analytic Jacobian in the " + daeTypeStr + " DAE:", vlst);
+        case BackendDAE.TORNSYSTEM(BackendDAE.TEARINGSET(tearingvars = vlst), linear = false)
+          then ("torn nonlinear equation system in the " + daeTypeStr + " DAE:", vlst);
+        // If the component is none of these types, do nothing.
+        else ("", {});
+      end match;
+
+      if not listEmpty(vlst) then
+        // Filter out the variables that are missing start values.
+        vars := List.map1r(vlst, BackendVariable.getVarAt, syst.orderedVars);
+        vars := list(v for v guard(not BackendVariable.varHasNominalValue(v)) in vars);
+
+        // Print a warning if we found any variables with missing start values.
+        if not listEmpty(vars) then
+          Error.addCompilerWarning(BackendDump.varListStringIndented(vars, "Iteration variables with no nominal value in " + compKind));
+        end if;
+      end if;
+    end for;
+  end for;
+end warnAboutIterationVariablesWithNoNominal;
+
 annotation(__OpenModelica_Interface="backend");
 end BackendDAEUtil;

Compiler/BackEnd/BackendDump.mo

@@ -452,6 +452,40 @@ algorithm
   outTpl := (varNo + 1, buffer);
 end var1String;
 
+public function varListStringIndented
+  input list<BackendDAE.Var> inVars;
+  input String heading;
+  output String outString;
+algorithm
+  outString := match(inVars, heading)
+    local
+      String buffer;
+
+    case (_, "") equation
+      ((_, buffer)) = List.fold(inVars, var1StringIndented, (1, ""));
+    then buffer;
+
+    else equation
+      ((_, buffer)) = List.fold(inVars, var1StringIndented, (1, ""));
+      buffer = heading + "\n" + buffer;
+    then buffer;
+  end match;
+end varListStringIndented;
+
+protected function var1StringIndented
+  input BackendDAE.Var inVar;
+  input tuple<Integer /*inVarNo*/, String /*buffer*/> inTpl;
+  output tuple<Integer /*outVarNo*/, String /*buffer*/> outTpl;
+protected
+  Integer varNo;
+  String buffer;
+algorithm
+  (varNo, buffer) := inTpl;
+  buffer := buffer + "   " + intString(varNo) + ": ";
+  buffer := buffer + varString(inVar) + "\n";
+  outTpl := (varNo + 1, buffer);
+end var1StringIndented;
+
 protected function printExternalObjectClasses "dump classes of external objects"
   input BackendDAE.ExternalObjectClasses cls;
 algorithm

Compiler/Util/Flags.mo

@@ -513,7 +513,9 @@ constant DebugFlag NF_UNITCHECK = DEBUG_FLAG(168, "frontEndUnitCheck", false,
 constant DebugFlag DISABLE_COLORING = DEBUG_FLAG(169, "disableColoring", false,
   Util.gettext("Disables coloring algorithm while spasity detection."));
 constant DebugFlag MERGE_ALGORITHM_SECTIONS = DEBUG_FLAG(170, "mergeAlgSections", false,
-  Util.gettext("Disables coloring algorithm while spasity detection."));
+  Util.gettext("Disables coloring algorithm while sparsity detection."));
+constant DebugFlag WARN_NO_NOMINAL = DEBUG_FLAG(171, "warnNoNominal", false,
+  Util.gettext("Prints the iteration variables in the initialization and simulation DAE, which do not have a nominal value."));
 
 
 // This is a list of all debug flags, to keep track of which flags are used. A
@@ -691,7 +693,8 @@ constant list<DebugFlag> allDebugFlags = {
   EVAL_PARAM_DUMP,
   NF_UNITCHECK,
   DISABLE_COLORING,
-  MERGE_ALGORITHM_SECTIONS
+  MERGE_ALGORITHM_SECTIONS,
+  WARN_NO_NOMINAL
 };
 
 public