[NF] Treat vectorized connectors with flow variables

- split array connectors into variables and keep dimensions
- enhanced generation of for equations
- add unconnected flow variables after connections to sets
  to get the right dimensions of connections

Belonging to [master]:
  - #2768
  - OpenModelica/OpenModelica-testsuite#1070

Author: rfranke

Compiler/NFFrontEnd/NFConnectionSets.mo

@@ -71,12 +71,19 @@ package ConnectionSets
       listLength(connections.connections) + listLength(connections.flows));
 
     // Add flow variable to the sets, unless disabled by flag.
-    if not Flags.isSet(Flags.DISABLE_SINGLE_FLOW_EQ) then
+    // Do this here if NF_SCALARIZE to use fast addList for scalarized flows.
+    if not Flags.isSet(Flags.DISABLE_SINGLE_FLOW_EQ) and Flags.isSet(Flags.NF_SCALARIZE) then
       sets := List.fold(connections.flows, addConnector, sets);
     end if;
 
     // Add the connections.
     sets := List.fold1(connections.connections, addConnection, connections.broken, sets);
+
+    // Add remaining flow variables to the sets, unless disabled by flag.
+    // Do this after addConnection if not NF_SCALARIZE to get array dims right.
+    if not Flags.isSet(Flags.DISABLE_SINGLE_FLOW_EQ) and not Flags.isSet(Flags.NF_SCALARIZE) then
+      sets := List.fold(connections.flows, addSingleConnector, sets);
+    end if;
   end fromConnections;
 
   function addScalarConnector
@@ -94,6 +101,16 @@ package ConnectionSets
     sets := addList(Connector.split(conn), sets);
   end addConnector;
 
+  function addSingleConnector
+    "Adds a connector to the sets if it does not already exist"
+    input Connector conn;
+    input output ConnectionSets.Sets sets;
+  algorithm
+    for c in Connector.split(conn) loop
+      sets := find(c, sets);
+    end for;
+  end addSingleConnector;
+
   function addConnection
     "Adds a connection to the sets, which means merging the two sets that the
      connectors belong to, unless they already belong to the same set."

Compiler/NFFrontEnd/NFConnector.mo

@@ -48,6 +48,7 @@ protected
   import NFClass.Class;
   import Restriction = NFRestriction;
   import ComplexType = NFComplexType;
+  import Dimension = NFDimension;
 
 public
   type Face = enumeration(INSIDE, OUTSIDE);
@@ -205,6 +206,7 @@ protected
     input DAE.ElementSource source;
     input ConnectorType cty;
     input output list<Connector> conns = {};
+    input list<Dimension> dims = {} "accumulated dimensions if not NF_SCALARIZE";
   algorithm
     conns := match ty
       local
@@ -214,36 +216,37 @@ protected
 
       case Type.COMPLEX(complexTy = ct as ComplexType.CONNECTOR())
         algorithm
-          conns := splitImpl2(name, face, source, ct.potentials, conns);
-          conns := splitImpl2(name, face, source, ct.flows, conns);
-          conns := splitImpl2(name, face, source, ct.streams, conns);
+          conns := splitImpl2(name, face, source, ct.potentials, conns, dims);
+          conns := splitImpl2(name, face, source, ct.flows, conns, dims);
+          conns := splitImpl2(name, face, source, ct.streams, conns, dims);
         then
           conns;
 
       case Type.COMPLEX()
         algorithm
           tree := Class.classTree(InstNode.getClass(ty.cls));
           conns := splitImpl2(name, face, source,
-            arrayList(ClassTree.getComponents(tree)), conns);
+            arrayList(ClassTree.getComponents(tree)), conns, dims);
         then
           conns;
 
       case Type.ARRAY()
         algorithm
+          t := Type.arrayElementType(ty);
           if Flags.isSet(Flags.NF_SCALARIZE) then
-            t := Type.arrayElementType(ty);
             for c in ComponentRef.scalarize(name) loop
-              conns := splitImpl(c, t, face, source, cty, conns);
+              conns := splitImpl(c, t, face, source, cty, conns, dims);
             end for;
           else
             if not Type.isEmptyArray(ty) then
-              conns := CONNECTOR(name, ty, face, cty, source) :: conns;
+              conns := splitImpl(name, t, face, source, cty, conns,
+                                 listAppend(dims, ty.dimensions));
             end if;
           end if;
         then
           conns;
 
-      else CONNECTOR(name, ty, face, cty, source) :: conns;
+      else CONNECTOR(name, Type.liftArrayLeftList(ty, dims), face, cty, source) :: conns;
     end match;
   end splitImpl;
 
@@ -253,6 +256,7 @@ protected
     input DAE.ElementSource source;
     input list<InstNode> comps;
     input output list<Connector> conns;
+    input list<Dimension> dims;
   protected
     Component c;
     ComponentRef cref;
@@ -264,7 +268,7 @@ protected
       ty := Component.getType(c);
       cty := Component.connectorType(c);
       cref := ComponentRef.append(ComponentRef.fromNode(comp, ty), name);
-      conns := splitImpl(cref, ty, face, source, cty, conns);
+      conns := splitImpl(cref, ty, face, source, cty, conns, dims);
     end for;
   end splitImpl2;
 

Compiler/NFFrontEnd/NFFlatten.mo

@@ -694,14 +694,18 @@ function addIterator_traverse
   input output Expression exp;
   input ComponentRef prefix;
   input Subscript subscript;
+protected
+  String restString, prefixString = ComponentRef.toString(prefix);
+  Integer prefixLength = stringLength(prefixString);
 algorithm
   exp := match exp
     local
       ComponentRef restCref;
     case Expression.CREF(cref = ComponentRef.CREF(restCref = restCref))
       algorithm
-        if ComponentRef.isEqual(restCref, prefix) then
-          exp.cref := ComponentRef.addSubscript(subscript, exp.cref);
+        restString := ComponentRef.toString(restCref);
+        if prefixLength <= stringLength(restString) and prefixString == substring(restString, 1, prefixLength) then
+          exp.cref := ComponentRef.setSubscripts(subscript :: ComponentRef.getSubscripts(exp.cref), exp.cref);
         end if;
       then
         exp;