[NB] introduce flag to turn of sim code scalarization (#14497)

* [NB] introduce flag to turn of sim code scalarization

* [NB] allow array strings as literal bindings

* [testsuite] add init xml array test files

Author: kabdelhak

OMCompiler/Compiler/FrontEnd/Expression.mo

@@ -13451,6 +13451,7 @@ public function isSimpleLiteralValue "A value that requires nothing special duri
   output Boolean b;
 algorithm
   b := match exp
+    case DAE.SCONST() then allow_arrays /* allow string constants with arrays */;
     case DAE.ICONST() then true;
     case DAE.RCONST() then true;
     case DAE.BCONST() then true;

OMCompiler/Compiler/NBackEnd/Classes/NBVariable.mo

@@ -1525,19 +1525,34 @@ public
   function hasEvaluableBinding
     extends checkVar;
   protected
-    Expression binding;
-  algorithm
-    if isBound(var_ptr) then
-      binding := Binding.getExp(var.binding);
-      b := Expression.isLiteral(binding);
+    Expression binding, start;
+    Option<Expression> opt_start;
+    function isEvaluable
+      input Expression exp;
+      output Boolean b;
+    protected
+      Expression new_exp;
+    algorithm
+      b := Expression.isLiteralXML(exp);
       if not b then
         // try to extract literal from array constructor (use dummy map, there should not be any new iterators)
-        (_, binding) := Iterator.extract(binding);
-        binding := SimplifyExp.simplifyDump(binding, true, getInstanceName());
-        b := Expression.isLiteral(Ceval.tryEvalExp(binding));
+        (_, new_exp) := Iterator.extract(exp);
+        new_exp := SimplifyExp.simplifyDump(new_exp, true, getInstanceName());
+        b := Expression.isLiteralXML(Ceval.tryEvalExp(new_exp));
       end if;
+    end isEvaluable;
+  algorithm
+    // check binding
+    if isBound(var_ptr) then
+      binding := Binding.getExp(var.binding);
+      b := isEvaluable(binding);
     else
-      b := false;
+      // check start value
+      opt_start := getStartAttribute(var_ptr);
+      b := match opt_start
+        case SOME(start) then isEvaluable(start);
+        else false;
+      end match;
     end if;
   end hasEvaluableBinding;
 
@@ -1601,9 +1616,9 @@ public
   end setFixed;
 
   function setBindingAsStart
-    "use this if a binding is found out to be constant, remove variable to known vars (param/const)
-    NOTE: this overwrites the old start value. throw error/warning if different?"
+    "use this if a binding is found out to be constant, remove variable to known vars (param/const)"
     input Pointer<Variable> var_ptr;
+    input Boolean overwrite = false;
   protected
     Variable var;
   algorithm
@@ -1615,7 +1630,7 @@ public
 
       case Variable.VARIABLE(backendinfo = binfo as BackendInfo.BACKEND_INFO()) algorithm
         start := Binding.getExp(var.binding);
-        binfo.attributes := VariableAttributes.setStartAttribute(binfo.attributes, start, true);
+        binfo.attributes := VariableAttributes.setStartAttribute(binfo.attributes, start, overwrite);
         var.backendinfo := binfo;
       then var;
 
@@ -1629,8 +1644,9 @@ public
   function setBindingAsStartAndFix
     input output Pointer<Variable> var_ptr;
     input Boolean b = true;
+    input Boolean overwrite = false;
   algorithm
-    setBindingAsStart(var_ptr);
+    setBindingAsStart(var_ptr, overwrite);
     var_ptr := setFixed(var_ptr, b);
   end setBindingAsStartAndFix;
 

OMCompiler/Compiler/NBackEnd/Modules/1_Main/NBInitialization.mo

@@ -227,7 +227,7 @@ public
             local
               Expression e;
             // use the start attribute itself if it is not a literal
-            case SOME(e) guard not Expression.isLiteral(e) then e;
+            case SOME(e) guard not Expression.isLiteralXML(e) then e;
             else algorithm
               // create a start variable if it is a literal
               (_, name, start_var, start_name) := createStartVar(var, name, {});
@@ -394,7 +394,9 @@ public
         end if;
       else
         for c_var in BVariable.getRecordChildren(var) loop
-          BVariable.setBindingAsStart(c_var);
+          if BVariable.isBound(c_var) then
+            BVariable.setBindingAsStart(c_var, true);
+          end if;
           (parameter_eqs, initial_param_vars) := createParameterEquation(c_var, new_iters, idx, parameter_eqs, initial_param_vars);
         end for;
       end if;
@@ -409,8 +411,8 @@ public
         if BVariable.isFixed(var) then
           parameter_eqs := Equation.generateBindingEquation(var, idx, true, new_iters) :: parameter_eqs;
         end if;
-      else
-        BVariable.setBindingAsStart(var);
+      elseif BVariable.isBound(var) then
+        BVariable.setBindingAsStart(var, true);
       end if;
     end if;
   end createParameterEquation;
@@ -444,7 +446,7 @@ public
         ComponentRef new_iter;
 
       // convert array constructor to for-equation if elements are not a literal
-      case SOME(Expression.CALL(call = array_constructor as Call.TYPED_ARRAY_CONSTRUCTOR(exp = e))) guard not Expression.isLiteral(e) algorithm
+      case SOME(Expression.CALL(call = array_constructor as Call.TYPED_ARRAY_CONSTRUCTOR(exp = e))) guard not Expression.isLiteralXML(e) algorithm
         (var_ptr, name, _, _, _, frames, iterator) := createIteratedStartCref(var_ptr, name);
         replacements := UnorderedMap.new<Expression>(ComponentRef.hash, ComponentRef.isEqual);
         for tpl in List.zip(array_constructor.iters, frames) loop
@@ -454,7 +456,7 @@ public
       then Expression.map(array_constructor.exp, function Replacements.applySimpleExp(replacements = replacements));
 
       // use the start attribute itself if it is not a literal
-      case SOME(e) guard not Expression.isLiteral(e) algorithm
+      case SOME(e) guard not Expression.isLiteralXML(e) algorithm
         if Slice.isFull(var_slice) then
           (var_ptr, name, _, _) := createStartVar(var_ptr, name, {});
           iterator := Iterator.EMPTY();

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

@@ -265,7 +265,7 @@ protected
           (const_vars, alias_vars) := List.splitOnTrue(alias_vars, BVariable.hasConstOrParamAliasBinding);
           for var in const_vars loop
             BVariable.setVarKind(var, VariableKind.PARAMETER(NONE()));
-            BVariable.setBindingAsStartAndFix(var);
+            BVariable.setBindingAsStartAndFix(var, true);
           end for;
           varData.parameters := VariablePointers.addList(const_vars, varData.parameters);
           varData.knowns := VariablePointers.addList(const_vars, varData.knowns);

OMCompiler/Compiler/NFFrontEnd/NFComponentRef.mo

@@ -2342,16 +2342,20 @@ public
   protected
     list<Subscript> subs;
   algorithm
-    subs := subscriptsAllFlat(scal);
-    if listEmpty(subs) then
-      // do not do it for scalar variables
-      arr := NONE();
-    elseif List.all(subs, function Subscript.isEqual(subscript1 = Subscript.INDEX(Expression.INTEGER(1)))) then
-      // if it is the first element, save the array var
-      arr := SOME(stripSubscriptsAll(scal));
+    if Flags.getConfigBool(Flags.SIM_CODE_SCALARIZE) then
+      subs := subscriptsAllFlat(scal);
+      if listEmpty(subs) then
+        // do not do it for scalar variables
+        arr := NONE();
+      elseif List.all(subs, function Subscript.isEqual(subscript1 = Subscript.INDEX(Expression.INTEGER(1)))) then
+        // if it is the first element, save the array var
+        arr := SOME(stripSubscriptsAll(scal));
+      else
+        // not first element
+        arr := NONE();
+      end if;
     else
-      // not first element
-      arr := NONE();
+      arr := if Type.isArray(getSubscriptedType(scal)) then SOME(scal) else NONE();
     end if;
   end getArrayCrefOpt;
 

OMCompiler/Compiler/NFFrontEnd/NFExpression.mo

@@ -4684,6 +4684,29 @@ public
     end match;
   end isLiteral;
 
+  function isLiteralXML
+    "allows for expressions additionally for init_xml"
+    input Expression exp;
+    output Boolean literal;
+  algorithm
+    literal := match exp
+      local
+        Expression call_exp;
+      case INTEGER() then true;
+      case REAL() then true;
+      case STRING() then true;
+      case BOOLEAN() then true;
+      case ENUM_LITERAL() then true;
+      case ARRAY() then exp.literal or Array.all(exp.elements, isLiteralXML);
+      case RECORD() then List.all(exp.elements, isLiteralXML);
+      case RANGE() then isLiteralXML(exp.start) and isLiteralXML(exp.stop) and
+                        Util.applyOptionOrDefault(exp.step, isLiteralXML, true);
+      case FILENAME() then true;
+      case CALL(call = Call.TYPED_ARRAY_CONSTRUCTOR(exp = call_exp)) then isLiteralXML(call_exp);
+      else false;
+    end match;
+  end isLiteralXML;
+
   function isLiteralReplace
     input Expression exp;
     output Boolean b;

OMCompiler/Compiler/NSimCode/NSimCode.mo

@@ -561,7 +561,8 @@ public
         partitionData                 = OldSimCode.PARTITIONDATA(-1,{},{},{}),
         daeModeData                   = if isSome(simCode.daeModeData) then SOME(DaeModeData.convert(Util.getOption(simCode.daeModeData))) else NONE(),
         inlineEquations               = {},
-        omsiData                      = NONE());
+        omsiData                      = NONE(),
+        scalarized                    = Flags.getConfigBool(Flags.SIM_CODE_SCALARIZE));
     end convert;
 
     function getDirectoryAndLibs

OMCompiler/Compiler/NSimCode/NSimJacobian.mo

@@ -215,7 +215,7 @@ public
           SimStrongComponent.Block columnEqn;
           list<SimStrongComponent.Block> columnEqns = {};
           VarData varData;
-          VariablePointers seed_scalar, res_scalar, tmp_scalar;
+          VariablePointers seed_vec, res_vec, tmp_vec;
           Pointer<list<SimVar>> seedVars_ptr = Pointer.create({});
           Pointer<list<SimVar>> resVars_ptr = Pointer.create({});
           Pointer<list<SimVar>> tmpVars_ptr = Pointer.create({});
@@ -245,13 +245,20 @@ public
           indices.generic_call_map := sim_map;
 
           // scalarize variables for sim code
-          seed_scalar := VariablePointers.scalarize(varData.seedVars);
-          res_scalar  := VariablePointers.scalarize(varData.resultVars);
-          tmp_scalar  := VariablePointers.scalarize(varData.tmpVars);
+          if Flags.getConfigBool(Flags.SIM_CODE_SCALARIZE) then
+            seed_vec := VariablePointers.scalarize(varData.seedVars);
+            res_vec  := VariablePointers.scalarize(varData.resultVars);
+            tmp_vec  := VariablePointers.scalarize(varData.tmpVars);
+          else
+            seed_vec := varData.seedVars;
+            res_vec  := varData.resultVars;
+            tmp_vec  := varData.tmpVars;
+          end if;
+
           // use dummy simcode indices to always start at 0 for column and seed vars
-          VariablePointers.map(seed_scalar, function SimVar.traverseCreate(acc = seedVars_ptr, indices_ptr = Pointer.create(NSimCode.EMPTY_SIM_CODE_INDICES()), varType = VarType.SIMULATION));
-          VariablePointers.map(res_scalar,  function SimVar.traverseCreate(acc = resVars_ptr,  indices_ptr = Pointer.create(NSimCode.EMPTY_SIM_CODE_INDICES()), varType = VarType.SIMULATION));
-          VariablePointers.map(tmp_scalar,  function SimVar.traverseCreate(acc = tmpVars_ptr,  indices_ptr = Pointer.create(NSimCode.EMPTY_SIM_CODE_INDICES()), varType = VarType.SIMULATION));
+          VariablePointers.map(seed_vec,  function SimVar.traverseCreate(acc = seedVars_ptr, indices_ptr = Pointer.create(NSimCode.EMPTY_SIM_CODE_INDICES()), varType = VarType.SIMULATION));
+          VariablePointers.map(res_vec,   function SimVar.traverseCreate(acc = resVars_ptr,  indices_ptr = Pointer.create(NSimCode.EMPTY_SIM_CODE_INDICES()), varType = VarType.SIMULATION));
+          VariablePointers.map(tmp_vec,   function SimVar.traverseCreate(acc = tmpVars_ptr,  indices_ptr = Pointer.create(NSimCode.EMPTY_SIM_CODE_INDICES()), varType = VarType.SIMULATION));
           seedVars  := listReverse(Pointer.access(seedVars_ptr));
           resVars   := listReverse(Pointer.access(resVars_ptr));
           tmpVars   := listReverse(Pointer.access(tmpVars_ptr));

OMCompiler/Compiler/NSimCode/NSimVar.mo

@@ -965,7 +965,7 @@ public
       input SplitType splitType;
       input VarType varType;
     protected
-      VariablePointers scalar_vars;
+      VariablePointers sim_vars = if Flags.getConfigBool(Flags.SIM_CODE_SCALARIZE) then VariablePointers.scalarize(vars) else vars;
       Pointer<list<SimVar>> acc = Pointer.create({});
       Pointer<list<SimVar>> real_lst = Pointer.create({});
       Pointer<list<SimVar>> int_lst = Pointer.create({});
@@ -974,17 +974,15 @@ public
       Pointer<list<SimVar>> enum_lst = Pointer.create({});
       Pointer<SimCode.SimCodeIndices> indices_ptr = Pointer.create(simCodeIndices);
     algorithm
-      // scalarize variables for simcode
-      scalar_vars := VariablePointers.scalarize(vars);
       if splitType == SplitType.NONE then
         // Do not split and return everything as one single list
-        VariablePointers.map(scalar_vars, function SimVar.traverseCreate(acc = acc, indices_ptr = indices_ptr, varType = varType));
+        VariablePointers.map(sim_vars, function SimVar.traverseCreate(acc = acc, indices_ptr = indices_ptr, varType = varType));
         simVars := {listReverse(Pointer.access(acc))};
         simCodeIndices := Pointer.access(indices_ptr);
       elseif splitType == SplitType.TYPE then
         // Split the variables by basic type (real, integer, boolean, string)
         // and return a list for each type
-        VariablePointers.map(scalar_vars, function splitByType(real_lst = real_lst, int_lst = int_lst, bool_lst = bool_lst, string_lst = string_lst, enum_lst = enum_lst, indices_ptr = indices_ptr, varType = varType));
+        VariablePointers.map(sim_vars, function splitByType(real_lst = real_lst, int_lst = int_lst, bool_lst = bool_lst, string_lst = string_lst, enum_lst = enum_lst, indices_ptr = indices_ptr, varType = varType));
         simVars := {listReverse(Pointer.access(real_lst)),
                     listReverse(Pointer.access(int_lst)),
                     listReverse(Pointer.access(bool_lst)),
@@ -1009,7 +1007,7 @@ public
     protected
       SimCode.SimCodeIndices simCodeIndices = Pointer.access(indices_ptr);
     algorithm
-      () := match (var.ty, varType)
+      () := match (Type.arrayElementType(var.ty), varType)
 
         case (Type.REAL(), VarType.SIMULATION)
           algorithm
@@ -1189,8 +1187,13 @@ public
       input UnorderedMap<ComponentRef, SimVar> simcode_map;
       output list<SimVar> vars = {};
     algorithm
-      vars := list(UnorderedMap.getSafe(BVariable.getVarName(v), simcode_map, sourceInfo()) for v in VariablePointers.scalarizeList({var}));
+      if Flags.getConfigBool(Flags.SIM_CODE_SCALARIZE) then
+        vars := list(UnorderedMap.getSafe(BVariable.getVarName(v), simcode_map, sourceInfo()) for v in VariablePointers.scalarizeList({var}));
+      else
+        vars := {UnorderedMap.getSafe(BVariable.getVarName(var), simcode_map, sourceInfo())};
+      end if;
     end getVars;
+
   end SimVars;
 
   constant SimVars emptySimVars = SIMVARS(

OMCompiler/Compiler/SimCode/SimCode.mo

@@ -161,6 +161,7 @@ uniontype SimCode
     Option<DaeModeData> daeModeData;
     list<SimEqSystem> inlineEquations;
     Option<OMSIData> omsiData "used for OMSI to generate equations code";
+    Boolean scalarized;
   end SIMCODE;
 end SimCode;