linny-r 3.0.7 → 3.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linny-r",
-  "version": "3.0.7",
+  "version": "3.0.9",
   "description": "Executable graphical language with WYSIWYG editor for MILP models",
   "main": "server.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@xmldom/xmldom": ">=0.8.2"
+    "@xmldom/xmldom": ">=0.9.10"
   },
   "repository": {
     "type": "git",

package/static/scripts/linny-r-ctrl.js

@@ -1480,8 +1480,9 @@ class PowerGridManager {
     // to add constraints that enforce Kirchhoff's voltage law.
     this.nodes = {};
     this.edges = {};
-    this.spanning_tree = [];
     this.tree_incidence = {};
+    this.node_sets = [];
+    this.spanning_edges = [];
     this.cycle_edges = [];
     this.cycle_basis = [];
     this.min_length = 0;
@@ -1599,33 +1600,68 @@ class PowerGridManager {
         grid.join(', ').toLowerCase());
   }
   
-  inferSpanningTree() {
+  nodeSetIndex(n) {
+    // Return index of node set containing `n`, or -1 if no such set exists.
+    for(let i = 0; i < this.node_sets.length; i++) {
+      if(this.node_sets[i][n]) return i;
+    }
+    return -1;    
+  }
+  
+  inferSpanningTrees() {
     // Use Kruksal's algorithm to build spanning tree.
     // NOTE: Tree needs not be minimal, so edges are not sorted.
-    this.spanning_tree.length = 0;
+    this.spanning_edges.length = 0;
     this.cycle_edges.length = 0;
     this.tree_incidence = {};
-    const node_set = {};
+    this.node_sets = [];
     for(let k in this.edges) if(this.edges.hasOwnProperty(k)) {
       const
           edge = this.edges[k],
           efn = edge.from_node,
           etn = edge.to_node,
           kvl = edge.process.grid.kirchhoff,
-          fn_in_tree = node_set.hasOwnProperty(efn),
-          tn_in_tree = node_set.hasOwnProperty(etn);
+          fn_set = this.nodeSetIndex(efn),
+          tn_set = this.nodeSetIndex(etn);
       // Only add edges of grids for which Kirchhoff's voltage law
       // has to be enforced.
       if(kvl) {
-        if(fn_in_tree && tn_in_tree) {
-          // Edge forms a cycle, so add it to the cycle edge list.
-          this.cycle_edges.push(edge);
+        if(fn_set === tn_set) {
+          if(fn_set < 0) {
+            // Edge disconnected from tree => add nodes as a new set.
+            const new_set = {};
+            new_set[efn] = true;
+            new_set[etn] = true;
+            this.node_sets.push(new_set);
+            this.spanning_edges.push(edge);
+          } else {
+            // Edge forms a cycle, so add it to the cycle edge list.
+            this.cycle_edges.push(edge);
+          }
         } else {
-          // Edge is not incident with *two* nodes already in the tree, so
-          // add it to the tree.
-          this.spanning_tree.push(edge);
-          node_set[efn] = true;
-          node_set[etn] = true;
+          // Edge is not incident with *two* nodes in same node set, so
+          // add it to the tree...
+          this.spanning_edges.push(edge);
+          if(fn_set < 0) {
+            // Add FROM node to the TO node set.
+            this.node_sets[tn_set][efn] = true;
+          } else if(tn_set < 0) {
+            // Add TO node to the FROM node set.
+            this.node_sets[fn_set][etn] = true;
+          } else {
+            // If both nodes are "known" but in diferent sets, then merge
+            // the sets into the one having the lowest index...
+            let
+                target = fn_set,
+                other = tn_set;
+            if(fn_set > tn_set) {
+              target = tn_set;
+              other = fn_set;
+            }
+            Object.assign(this.node_sets[target], this.node_sets[other]);
+            // ...  and delete the other set.
+            this.node_sets.splice(other, 1);
+          }
         }
         const ti = this.tree_incidence;
         // Always record that both its nodes are incident with it.
@@ -1643,19 +1679,27 @@ class PowerGridManager {
     }
   }
   
-  pathInSpanningTree(fn, tn, path) {
+  pathInSpanningTree(fn, tn, path, eop) {
     // Recursively constructs `path` as the list of edges forming the path
     // from `fn` to `tn` in the spanning tree of this grid.
     // If edge connects path with TO node, `path` is complete.
     if(fn === tn) return true;
+    // Consider all edges that connect with the FROM node.
     for(const e of this.tree_incidence[fn]) {
       // Ignore edges already in the path.
-      if(path.indexOf(e) < 0) {
+      if(eop.indexOf(e) < 0) {
         // NOTE: Edges are directed, but should not be considered as such.
-        const nn = (e.from_node === fn ? e.to_node : e.from_node);
-        path.push(e);
-        if(this.pathInSpanningTree(nn, tn, path)) return true;
+        let nn = e.to_node,
+            sign = 1;
+        if(e.from_node !== fn) {
+          nn = e.from_node;
+          sign = -1;
+        }
+        path.push({process: e.process, orientation: sign});
+        eop.push(e);
+        if(this.pathInSpanningTree(nn, tn, path, eop)) return true;
         path.pop();
+        eop.pop();
       }
     }
     return false;
@@ -1666,28 +1710,19 @@ class PowerGridManager {
     this.cycle_basis.length = 0;
     if(!(MODEL.with_power_flow && MODEL.powerGridsWithKVL.length)) return;
     this.inferNodesAndEdges();
-    this.inferSpanningTree();
+    this.inferSpanningTrees();
     for(const edge of this.cycle_edges) {
-      const path = [];
-      if(this.pathInSpanningTree(edge.from_node, edge.to_node, path)) {
-        // Add flags that indicate whether the edge on the path is reversed.
-        // The closing edge determines the orientation.
-        const cycle = [{process: edge.process, orientation: 1}];
-        let node = edge.to_node;
-        for(let i = path.length - 1; i >= 0; i--) {
-          const
-              pe = path[i],
-              ce = {process: pe.process};
-          if(pe.from_node === node) {
-            ce.orientation = 1;
-            node = pe.to_node;
-          } else {
-            ce.orientation = -1;
-            node = pe.from_node;
-          }
-          cycle.push(ce);
-        }
-        this.cycle_basis.push(cycle);
+      const
+          path = [],
+          // Path cannot include the closing edge.
+          eop = [edge];
+      if(this.pathInSpanningTree(edge.to_node, edge.from_node, path, eop)) {
+        // The closing edge has orientation +1.
+        path.push({process: edge.process, orientation: 1});
+        this.cycle_basis.push(path);
+      } else {
+        // Log that edge did not close a cycle.
+        console.log('ANOMALY: No path for edge', edge);
       }
     }
   }

package/static/scripts/linny-r-gui-file-manager.js

@@ -314,10 +314,10 @@ class GUIFileManager {
       const mi = this.model_index;
       if(mi >= 0) {
         path += this.separator;
-        if(mi < sd.sdcount) {
+        if(mi < this.sd_count) {
           path += sd.subdirs[mi].name;
         } else {
-          path += sd.models[mi - sd.sdcount].name + '.lnr';
+          path += sd.models[mi - this.sd_count].name + '.lnr';
           this.new_window_btn.title =
               'Open selected model in new Linny-R tab in browser';
         }
@@ -1260,7 +1260,7 @@ class GUIFileManager {
       const
           mi = this.model_index,
           sd = this.selected_dir;
-      if(mi >= sd.sdcount) {
+      if(mi >= this.sd_count) {
         const mdl = sd.models[mi - this.sd_count];
         if(mdl) {
           window.localStorage.setItem('linny-r-model-file',

package/static/scripts/linny-r-gui-finder.js

@@ -167,6 +167,8 @@ class Finder {
         enl = [],
         et = this.entity_types,
         fp = this.filter_pattern && this.filter_pattern.length > 0;
+    // Position "orphan" products (if any) in focal cluster and notify modeler.
+    MODEL.revealOrphans();
     let imgs = '';
     this.entities.length = 0;
     this.filtered_types.length = 0;

package/static/scripts/linny-r-gui-power-grid-manager.js

@@ -293,4 +293,4 @@ class GUIPowerGridManager extends PowerGridManager {
     return flows.join('\n');
   }
   
-} // END of class GUIPowerGridManager
+} // END of class GUIPowerGridManager

package/static/scripts/linny-r-model.js

@@ -1102,6 +1102,8 @@ class LinnyRModel {
   canLink(from, to) {
     // Return TRUE iff FROM-node can feature a "straight" link (i.e., a
     // product flow) to TO-node.
+    // FROM and TO *must* be different nodes.
+    if(from === to) return false;
     if(from.type === to.type) {
       // No "straight" link between nodes of same type (see canConstrain
       // for "curved" links) UNLESS TO-node is a data product.
@@ -1135,6 +1137,37 @@ class LinnyRModel {
     return this.end_period - this.start_period + 1 + this.look_ahead;
   }
   
+  revealOrphans() {
+    // Find all products that are *not* positioned in some cluster,
+    // position them in the focal cluster, and notify the user.
+    const orphans = [];
+    for(const k in this.products) if(this.products.hasOwnProperty(k)) {
+      const p = this.products[k];
+      if(p.isOrphan) orphans.push(p);
+    }
+    if(orphans.length) {
+      let x = 100,
+          y = 70,
+          n = 0;
+      const fc = this.focal_cluster;
+      for(const p of orphans) {
+        const pp = fc.addProductPosition(p, x, y);
+        if(pp) {
+          x += 90;
+          y += 45;
+          n++;
+        }
+      }
+      // Prepare focal cluster for redrawing.
+      fc.clearAllProcesses();
+      // Select the added product positions and redraw.
+      this.selectList(orphans);
+      UI.drawDiagram(this);
+      // Finally, notify the modeler.
+      UI.warn(pluralS(n, '"orphaned" product') + ' added to the focal cluster');
+    }
+  }
+  
   processSelectorList(sl) {
     // Check whether selector list `sl` constitutes a new dimension.
     // Ignore lists of fewer than 2 "plain" selectors.
@@ -1675,6 +1708,12 @@ class LinnyRModel {
       if(node) l.initFromXML(node);
       return l;
     }
+    // FROM and TO nodes must be different. The UI should not permit
+    // drawing such nodes, but check nonetheless.
+    if(from === to) {
+      UI.warn(`${from.type} "${from.displayName}" cannot be linked to itself`);
+      return null;
+    }
     l = new Link(from, to);
     if(node) l.initFromXML(node);
     this.links[l.identifier] = l;
@@ -1705,6 +1744,12 @@ class LinnyRModel {
       if(node) c.initFromXML(node);
       return c;
     }
+    // FROM and TO nodes must be different. The UI should not permit
+    // drawing such nodes, but check nonetheless.
+    if(from === to) {
+      UI.warn(`${from.type} "${from.displayName}" cannot constrain itself`);
+      return null;
+    }
     c = new Constraint(from, to);
     if(node) c.initFromXML(node);
     // New constraint => prepare for redraw.
@@ -2829,15 +2874,12 @@ class LinnyRModel {
   updateChartVariables(e) {
     // Ensure that all chart variable names based on entity `e` will be
     // displayed correctly the next time they are drawn.
-console.log('HERE e', e.displayName);
     const sc = this.charts[CHART_MANAGER.chart_index];
     let ucm = false;
     for(const c of this.charts) {
       for(const v of c.variables) {
-        console.log('HERE v', v.displayName);
         if(v.object === e) {
           v.display_name = '';
-          console.log('HERE v new', v.displayName);
           ucm = ucm || c === sc;
         }
       }
@@ -4083,8 +4125,8 @@ console.log('HERE e', e.displayName);
             }
             // All potential inflows known => CP proxy can be calculated.
             if(count === p.inputs.length) {
-              // Also consider output links to products having price < 0.
-              for(const l of p.outputs) {
+              // Also consider regular output links to products having price < 0.
+              for(const l of p.outputs) if(l.multiplier === VM.LM_LEVEL) {
                 // NOTE: Here, a delay may apply.
                 const
                     d = l.actualDelay(t),
@@ -8826,6 +8868,11 @@ class Product extends Node {
     return ppc;
   }
   
+  get isOrphan() {
+    // Return TRUE if this product has no position in any cluster.
+    return this.productPositionClusters.length <= 0;
+  }
+  
   get toBeBlackBoxed() {
     // Return TRUE if this product occurs only in "black box" clusters.
     for(const c of this.productPositionClusters) if(!c.blackBoxed) return false;

package/static/scripts/linny-r-vm.js

@@ -173,9 +173,6 @@ class Expression {
     this.wildcard_vectors = {};
     this.wildcard_vector_index = false;
     this.method_object_list.length = 0;
-    if(!isEmpty(this.cache)) {
-      console.log('HERE Clearing cache', this.text, '\n', Object.keys(this.cache));
-    }
     this.cache = {};
     this.compile(); // if(!this.compiled)  REMOVED to ensure correct isStatic!! 
     // Static expressions only need a vector with one element (having index 0)
@@ -1223,26 +1220,24 @@ class ExpressionParser {
       if(!anchor1) anchor1 = 't';
       if(!anchor2) anchor2 = 't';
     }
-    // First handle this special case: no name or attribute. This is valid
-    // only for dataset modifier expressions (and hence also equations).
-    // Variables like [@t-1] are interpreted as a self-reference. This is
-    // meaningful when a *negative* offset is specified to denote "use the
-    // value of this expression for some earlier time step".
-    // NOTES:
-    // (1) This makes the expression dynamic.
-    // (2) It does not apply to array-type datasets, as these have no
-    //     time dimension.
-    if(!name && !attr && this.dataset && !this.dataset.array) {
+    // First handle this special case: an equation self-reference.
+    // Variables like [@t-1] are interpreted as an implicit self-reference.
+    // Self-references are meaningful when a *negative* offset is specified
+    // to denote "use the value of this expression for some earlier time step".
+    // NOTE: This makes the expression dynamic.
+    if(!attr && this.dataset === MODEL.equations_dataset &&
+        (!name || UI.nameToID(name) === UI.nameToID(this.attribute))) {
       this.is_static = false;
       this.log('dynamic because of self-reference');
-      if(('cips'.indexOf(anchor1) >= 0 || anchor1 === 't' && offset1 < 0) &&
-          ('cips'.indexOf(anchor2) >= 0 ||anchor2 === 't' && offset2 < 0)) {
+      if(('cfps'.indexOf(anchor1) >= 0 || anchor1 === 't' && offset1 < 0) &&
+          ('cfps'.indexOf(anchor2) >= 0 ||anchor2 === 't' && offset2 < 0)) {
         if(this.TRACE) console.log('TRACE: Variable is a self-reference.');
         // The `xv` attribute will be recognized by VMI_push_var to denote
         // "use the vector of the expression for which this VMI is code".
-        return [{xv: true, dv: this.dataset.defaultValue},
+        return [{xv: true, dv: VM.UNDEFINED},
             anchor1, offset1, anchor2, offset2];
       }
+      // Fall-through: invalid offset => warning.
       msg = 'Expression can reference only previous values of itself';
     }
     // A leading "!" denotes: pass variable reference instead of its value.
@@ -1531,8 +1526,12 @@ class ExpressionParser {
       let sel = '',
           xtype = '';
       if(obj instanceof DatasetModifier) {
-        sel = obj.selector;
-        xtype = 'Equation';
+        if(attr) {
+          msg = 'Equations have no attributes';
+        } else {
+          sel = obj.selector;
+          xtype = 'Equation';
+        }
       } else if(obj instanceof Dataset) {
         sel = attr;
         xtype = 'Dataset modifier expression';
@@ -3394,7 +3393,7 @@ class VirtualMachine {
       // If not a sink, UB is set to 0.
       if(notsnk) u = 0;
     }
-    
+
     // NOTE: Stock constraints must take into account extra inflows
     // (source) or outflows (sink).
     // Check for special case of equal bounds, as then one EQ constraint
@@ -3434,7 +3433,7 @@ class VirtualMachine {
         this.code.push(
           [l instanceof Expression? VMI_set_var_rhs : VMI_set_const_rhs, l],
           [VMI_add_constraint, VM.GE]
-        );          
+        );
       }
       // Add upper bound (LE) constraint unless product is a sink node
       if(notsnk) {
@@ -3448,7 +3447,7 @@ class VirtualMachine {
         this.code.push(
           [u instanceof Expression ? VMI_set_var_rhs : VMI_set_const_rhs, u],
           [VMI_add_constraint, VM.LE]
-        );          
+        );
       }
     }
   }
@@ -5079,7 +5078,7 @@ class VirtualMachine {
         MODEL.calculateCostPrices(b);
       }
     }
-
+/*
     // THEN: Reset all datasets that are outcomes or serve as "formulas".
     for(let k in MODEL.datasets) if(MODEL.datasets.hasOwnProperty(k)) {
       const ds = MODEL.datasets[k];
@@ -5092,7 +5091,7 @@ class VirtualMachine {
         }
       }
     }
-
+*/
     // THEN: Reset the vectors of all chart variables.
     for(const c of MODEL.charts) c.resetVectors();
     
@@ -6743,7 +6742,12 @@ function VMI_push_var(x, args) {
     x.push(v);
   } else if(xv) {
     // Variable references an earlier value computed for this expression `x`.
-    x.push(t >= 0 && t < x.vector.length ? x.vector[t] : obj.dv);
+    // NOTE: When this value has NOT been computed yet, use the specified default.
+    if(t >= 0 && t < x.vector.length && x.vector[t] !== VM.NOT_COMPUTED) {
+      x.push(x.vector[t]);
+    } else {
+      x.push(obj.dv);
+    }
   } else if(obj.hasOwnProperty('c') && obj.hasOwnProperty('u')) {
     // Object holds link lists for cluster balance computation.
     x.push(MODEL.flowBalance(obj, t));
@@ -8375,7 +8379,7 @@ function VMI_set_bounds(args) {
       VM.variables[vi - 1][0],'] t = ', VM.t, ' LB = ', VM.sig4Dig(l),
       ', UB = ', VM.sig4Dig(u), fixed].join(''), l, u, inf_val, 'args:', args);
     console.log(p);
-    throw "STOP";
+    if(!DEBUGGING) throw "STOP";
   } else if(u < l) {
     // Check the difference, as this may be negligible.
     if(u - l < VM.SIG_DIF_FROM_ZERO) {
@@ -9075,6 +9079,8 @@ function VMI_update_grid_process_cash_coefficients(p) {
   // VMI_update_cash_coefficient).
   let fn = null,
       tn = null;
+  // NOTE: Grid processes are assumed to connect exactly *two* products by
+  // regular links, so it suffices to find the *first* ingoing...
   for(const l of p.inputs) {
     if(l.multiplier === VM.LM_LEVEL &&
         !MODEL.ignored_entities[l.identifier]) {
@@ -9082,6 +9088,7 @@ function VMI_update_grid_process_cash_coefficients(p) {
       break;
     }
   }
+  // ... and the first outgoing regular link.
   for(const l of p.outputs) {
     if(l.multiplier === VM.LM_LEVEL &&
         !MODEL.ignored_entities[l.identifier]) {
@@ -9092,7 +9099,7 @@ function VMI_update_grid_process_cash_coefficients(p) {
   const
       fp = (fn && fn.price.defined ? fn.price.result(VM.t) : 0),
       tp = (tn && tn.price.defined ? tn.price.result(VM.t) : 0);
-  // Only proceed if process links to a product with a non-zero price.
+  // Only proceed if process links to at least one product with a non-zero price.
   if(fp || tp) {
     const
         gpv = VM.gridProcessVarIndices(p, VM.offset),
@@ -9101,30 +9108,30 @@ function VMI_update_grid_process_cash_coefficients(p) {
       // If FROM node has price > 0, then all UP flows generate cash OUT
       // *without* loss while all DOWN flows generate cash IN *with* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashOut(gpv.up[i], -fp);
-        addCashIn(gpv.down[i], (1 - lr[i]) * -fp);
+        addCashOut(gpv.up[i], fp);
+        addCashIn(gpv.down[i], (1 - lr[i]) * fp);
       }
     } else if(fp < 0) {
       // If FROM node has price < 0, then all UP flows generate cash IN
       // *without* loss while all DOWN flows generate cash OUT *with* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashIn(gpv.up[i], fp);
-        addCashOut(gpv.down[i], (1 - lr[i]) * fp);
+        addCashIn(gpv.up[i], -fp);
+        addCashOut(gpv.down[i], (1 - lr[i]) * -fp);
       }
     }
     if(tp > 0) {    
       // If TO node has price > 0, then all UP flows generate cash IN *with*
       // loss while all DOWN flows generate cash OUT *without* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashIn(gpv.up[i], (1 - lr[i]) * -tp);
-        addCashOut(gpv.down[i], -tp);
+        addCashIn(gpv.up[i], (1 - lr[i]) * tp);
+        addCashOut(gpv.down[i], tp);
       }
     } else if(tp < 0) {
       // If TO node has price < 0, then all UP flows generate cash OUT
       // *with* loss while all DOWN flows generate cash IN *without* loss.
       for(let i = 0; i < gpv.slopes; i++) {
-        addCashOut(gpv.up[i], (1 - lr[i]) * tp);
-        addCashIn(gpv.down[i], tp);
+        addCashOut(gpv.up[i], (1 - lr[i]) * -tp);
+        addCashIn(gpv.down[i], -tp);
       }
     }
   }
@@ -9179,15 +9186,14 @@ function VMI_add_constraint(ct) {
   for(let i in VM.coefficients) if(Number(i)) {
     // Do not add (near)zero coefficients to the matrix.
     const c = VM.coefficients[i];
-    if(Math.abs(c) >= VM.NEAR_ZERO) {
-      row[i] = c;
-    }
+    if(Math.abs(c) >= VM.NEAR_ZERO) row[i] = c;
   }
   // Special case: 
   if(ct === VM.ACTOR_CASH) {
     VM.actor_cash_constraints.push(VM.matrix.length);
     ct = VM.EQ;
   }
+
   let rhs = VM.rhs;
   // Check for <= (near) +infinity and >= (near) -infinity: such
   // constraints should not be added to the model.