[NB] check alias replacements for validity (#13662)

Author: linuslangenkamp

OMCompiler/Compiler/NBackEnd/Classes/NBEquation.mo

@@ -65,6 +65,7 @@ public
   import OldBackendDAE = BackendDAE;
 
   // New Backend imports
+  import DetectStates = NBDetectStates;
   import Evaluation = NBEvaluation;
   import Inline = NBInline;
   import Replacements = NBReplacements;
@@ -1441,6 +1442,8 @@ public
       input output Equation eq;
       input String name = "";
       input String indent = "";
+      input Pointer<list<Pointer<Variable>>> acc_discrete_states = Pointer.create({});
+      input Pointer<list<Pointer<Variable>>> acc_previous = Pointer.create({});
       input SimplifyFunc simplifyExp = function SimplifyExp.simplifyDump(includeScope = true, name = name, indent = indent);
 
       partial function SimplifyFunc
@@ -1499,7 +1502,9 @@ public
             case SOME(body) algorithm
               eq.body := body;
             then eq;
-            else Equation.DUMMY_EQUATION();
+            else algorithm
+              DetectStates.findDiscreteStatesFromWhenBody(eq.body, acc_discrete_states, acc_previous);
+            then Equation.DUMMY_EQUATION();
           end match;
         then new_eq;
 

OMCompiler/Compiler/NBackEnd/Classes/NBVariable.mo

@@ -225,6 +225,17 @@ public
     Pointer.update(par_ptr, par);
   end connectPartners;
 
+  function removePartner
+    "removes the partner for the variable"
+    input Pointer<Variable> var_ptr;
+    input BackendInfo.setPartner func;
+  protected
+    Variable var = Pointer.access(var_ptr);
+  algorithm
+    var.backendinfo := func(var.backendinfo, NONE());
+    Pointer.update(var_ptr, var);
+  end removePartner;
+
   function getVar
     input ComponentRef cref;
     output Variable var;

OMCompiler/Compiler/NBackEnd/Classes/NBackendDAE.mo

@@ -388,9 +388,14 @@ public
     input output BackendDAE bdae;
     input Boolean init;
   protected
+    Pointer<list<Pointer<Variable>>> acc_discrete_states = Pointer.create({});
+    Pointer<list<Pointer<Variable>>> acc_previous = Pointer.create({});
+
     BEquation.MapFuncEqn func = function Equation.simplify(
             name = getInstanceName(),
             indent = "",
+            acc_discrete_states = acc_discrete_states,
+            acc_previous = acc_previous,
             simplifyExp = function SimplifyExp.simplifyDump(
               includeScope = true,
               name = getInstanceName(),
@@ -399,13 +404,40 @@ public
     bdae := match bdae
       local
         EqData eqData;
+        VarData varData;
+        list<Pointer<Variable>> acc_discrete_states_accessed;
+
       case MAIN(eqData = eqData as BEquation.EQ_DATA_SIM()) algorithm
         if init then
           eqData.initials := EquationPointers.map(eqData.initials, func);
         else
           eqData.equations := EquationPointers.map(eqData.equations, func);
         end if;
         bdae.eqData := EqData.compress(eqData);
+
+        // update varData with accs obtained from mapping
+        bdae.varData := match bdae.varData
+          case varData as VarData.VAR_DATA_SIM() algorithm
+            acc_discrete_states_accessed := Pointer.access(acc_discrete_states);
+
+            VariablePointers.removeList(acc_discrete_states_accessed, varData.unknowns);
+            VariablePointers.removeList(acc_discrete_states_accessed, varData.discretes);
+            VariablePointers.removeList(acc_discrete_states_accessed, varData.discrete_states);
+            // TODO: CLOCKED?
+
+            VariablePointers.removeList(Pointer.access(acc_previous), varData.previous);
+            VariablePointers.removeList(Pointer.access(acc_previous), varData.variables);
+
+            VariablePointers.addList(acc_discrete_states_accessed, varData.parameters);
+            VariablePointers.addList(acc_discrete_states_accessed, varData.knowns);
+
+            for v in acc_discrete_states_accessed loop
+              BVariable.setVarKind(v, VariableKind.PARAMETER(NONE()));
+              BVariable.removePartner(v, BackendInfo.setVarPre);
+            end for;
+          then varData;
+          else bdae.varData;
+        end match;
       then bdae;
       else bdae;
     end match;
@@ -420,12 +452,17 @@ public
     bdae := match bdae
       local
         EqData eqData;
+        Pointer<list<Pointer<Variable>>> acc_discrete_states = Pointer.create({});
+        Pointer<list<Pointer<Variable>>> acc_previous = Pointer.create({});
+
       case MAIN(eqData = eqData as BEquation.EQ_DATA_SIM()) algorithm
         eqData.equations := EquationPointers.map(
           eqData.equations,
           function Equation.simplify(
             name = getInstanceName(),
             indent = "",
+            acc_discrete_states = acc_discrete_states,
+            acc_previous = acc_previous,
             simplifyExp = SimplifyExp.removeStream));
         bdae.eqData := EqData.compress(eqData);
       then bdae;
@@ -1245,7 +1282,7 @@ protected
     eq := Pointer.create(Equation.ALGORITHM(size, alg, alg.source, DAE.EXPAND(), attr));
   end lowerAlgorithm;
 
-  protected function lowerEquationAttributes
+  function lowerEquationAttributes
     input Type ty;
     input Boolean init;
     output EquationAttributes attr;
@@ -1259,7 +1296,7 @@ protected
     end if;
   end lowerEquationAttributes;
 
-  function lowerComponentReferences
+  protected function lowerComponentReferences
     input output EquationPointers equations;
     input VariablePointers variables;
   algorithm

OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBAlias.mo

@@ -75,6 +75,7 @@ protected
   import ComponentRef = NFComponentRef;
   import Expression = NFExpression;
   import ExpressionIterator = NFExpressionIterator;
+  import NFFunction.Function;
   import Type = NFType;
   import Operator = NFOperator;
   import Variable = NFVariable;
@@ -220,14 +221,15 @@ protected
         UnorderedMap<ComponentRef, Expression> replacements;
         EquationPointers newEquations;
         list<Pointer<Variable>> alias_vars, const_vars, non_trivial_alias;
-        list<Pointer<Equation>> non_trivial_eqs;
+        list<Pointer<Equation>> non_trivial_eqs, auxEquations;
 
       case (BVariable.VAR_DATA_SIM(), BEquation.EQ_DATA_SIM())
         algorithm
           // -----------------------------------
           //            1. 2. 3.
           // -----------------------------------
           (replacements, newEquations) := aliasCausalize(varData.unknowns, eqData.simulation, "Simulation");
+          (replacements, auxEquations) := checkReplacements(replacements, eqData);
 
           // -----------------------------------
           // 4. apply replacements
@@ -273,14 +275,92 @@ protected
           non_trivial_eqs := list(Equation.generateBindingEquation(var, eqData.uniqueIndex, false) for var in non_trivial_alias);
           eqData.removed := EquationPointers.addList(non_trivial_eqs, eqData.removed);
           //eqData.equations := EquationPointers.addList(non_trivial_eqs, eqData.equations);
-      then (varData, eqData);
+      then (varData, EqData.addUntypedList(eqData, auxEquations, false));
 
       else algorithm
         Error.addMessage(Error.INTERNAL_ERROR, {getInstanceName() + " failed."});
       then fail();
     end match;
   end aliasDefault;
 
+  function checkReplacements
+    "Checks validity of all replacements, returns all valid replacements and auxiliary equations"
+    input UnorderedMap<ComponentRef, Expression> replacements;
+    input EqData eqData;
+    output UnorderedMap<ComponentRef, Expression> newReplacements = UnorderedMap.new<Expression>(ComponentRef.hash, ComponentRef.isEqual);
+    output list<Pointer<Equation>> auxEquations = {};
+  protected
+    UnorderedSet<ComponentRef> exceptionSet = UnorderedSet.new(ComponentRef.hash, ComponentRef.isEqual);
+    ComponentRef cref;
+    Expression exp;
+    Pointer<Equation> eqPtr;
+    EquationAttributes attr;
+  algorithm
+    EqData.mapExp(eqData, function filterPre(acc = exceptionSet));
+    for keyValueTpl in UnorderedMap.toList(replacements) loop
+      (cref, exp) := keyValueTpl;
+      if isValidReplacement(cref, exp, exceptionSet) then
+        // replacement is valid - add to newReplacements
+        UnorderedMap.add(cref, exp, newReplacements);
+      else
+        // add auxiliary equation
+        attr := BackendDAE.lowerEquationAttributes(ComponentRef.getSubscriptedType(cref), false);
+        eqPtr := Equation.makeAssignment(Expression.fromCref(cref), exp, EqData.getUniqueIndex(eqData), "SIM", Iterator.EMPTY(), attr);
+        auxEquations := eqPtr :: auxEquations;
+      end if;
+    end for;
+
+    if Flags.isSet(Flags.DUMP_REPL)  then
+      dumpReplacements(newReplacements, auxEquations);
+    end if;
+  end checkReplacements;
+
+  function isValidReplacement
+    "Checks if a replacement (cref, exp) is valid"
+    input ComponentRef cref;
+    input Expression exp;
+    input UnorderedSet<ComponentRef> exceptionSet;
+    output Boolean b = true;
+  algorithm
+    // TODO: possibly match cref, exp here: add if needed
+    if UnorderedSet.contains(cref, exceptionSet) then
+      b := false;
+    end if;
+  end isValidReplacement;
+
+  function filterPre
+    "Filter expression for pre call"
+    input output Expression exp;
+    input UnorderedSet<ComponentRef> acc;
+  algorithm
+    () := match exp
+      local
+        Call call;
+        ComponentRef cref;
+
+      case Expression.CALL(call = call as Call.TYPED_CALL(arguments = {Expression.CREF(cref = cref)}))
+        guard(AbsynUtil.pathString(Function.nameConsiderBuiltin(call.fn)) == "pre") algorithm
+        UnorderedSet.add(cref, acc);
+      then ();
+
+      else ();
+    end match;
+  end filterPre;
+
+  function dumpReplacements
+    input UnorderedMap<ComponentRef, Expression> replacements;
+    input list<Pointer<Equation>> auxEquations = {};
+  algorithm
+    print(Replacements.simpleToString(replacements) + "\n");
+    if not listEmpty(auxEquations) then
+      print(StringUtil.headline_4("[dumprepl] Found But Illegal Alias Replacements (added as equations):"));
+      for eqPtr in auxEquations loop
+        print("\t" + Equation.toString(Pointer.access(eqPtr)) + "\n");
+      end for;
+      print("\n");
+    end if;
+  end dumpReplacements;
+
   function aliasClocks
     "STEPS:
       1. collect alias sets (variables, equations, optional constant binding)
@@ -296,13 +376,15 @@ protected
         UnorderedMap<ComponentRef, Expression> replacements;
         EquationPointers newEquations;
         list<Pointer<Variable>> alias_vars;
+        list<Pointer<Equation>> auxEquations;
 
       case (BVariable.VAR_DATA_SIM(), BEquation.EQ_DATA_SIM())
         algorithm
           // -----------------------------------
           //            1. 2. 3.
           // -----------------------------------
           (replacements, newEquations) := aliasCausalize(varData.clocks, eqData.clocked, "Clocked");
+          (replacements, auxEquations) := checkReplacements(replacements, eqData);
 
           // -----------------------------------
           // 4. apply replacements
@@ -317,7 +399,7 @@ protected
           // remove alias variables from clocks and add to alias
           varData.clocks    := VariablePointers.removeList(alias_vars, varData.clocks);
           varData.aliasVars := VariablePointers.addList(alias_vars, varData.aliasVars);
-      then (varData, eqData);
+      then (varData, EqData.addUntypedList(eqData, auxEquations, false));
 
       else algorithm
         Error.addMessage(Error.INTERNAL_ERROR, {getInstanceName() + " failed."});
@@ -371,9 +453,6 @@ protected
       replacements := createReplacementRules(set, replacements);
     end for;
 
-    if Flags.isSet(Flags.DUMP_REPL) then
-      print(Replacements.simpleToString(replacements) + "\n");
-    end if;
   end aliasCausalize;
 
   function findSimpleEquation

OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBDetectStates.mo

@@ -584,6 +584,33 @@ protected
     end if;
   end getPreVar;
 
+  public function findDiscreteStatesFromWhenBody
+    "All variables on the LHS in a when equation are considered discrete, add these to acc lists"
+    input WhenEquationBody body;
+    input Pointer<list<Pointer<Variable>>> acc_discrete_states;
+    input Pointer<list<Pointer<Variable>>> acc_previous;
+  algorithm
+    for body_stmt in body.when_stmts loop
+      () := match body_stmt
+        local
+          ComponentRef state_cref, pre_cref;
+          Pointer<Variable> state_var, pre_var;
+
+        case WhenStatement.ASSIGN(lhs = Expression.CREF(cref = state_cref)) algorithm
+          state_var := BVariable.getVarPointer(state_cref);
+          _ := match BVariable.getVarPre(state_var)
+            case SOME(pre_var) algorithm
+              Pointer.update(acc_previous, pre_var :: Pointer.access(acc_previous));
+            then ();
+            else ();
+          end match;
+          Pointer.update(acc_discrete_states, state_var :: Pointer.access(acc_discrete_states));
+        then ();
+        else ();
+      end match;
+    end for;
+  end findDiscreteStatesFromWhenBody;
+
   annotation(__OpenModelica_Interface="backend");
 end NBDetectStates;