linny-r 3.0.6 → 3.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linny-r",
-  "version": "3.0.6",
+  "version": "3.0.8",
   "description": "Executable graphical language with WYSIWYG editor for MILP models",
   "main": "server.js",
   "scripts": {

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

@@ -1026,7 +1026,8 @@ class GUIChartManager extends ChartManager {
       this.updateDialog();
       // Also update the experiment viewer (charts define the output variables)
       // and finder dialog.
-      if(EXPERIMENT_MANAGER.selected_experiment) UI.updateControllerDialogs('FX');
+      if(EXPERIMENT_MANAGER.selected_experiment) EXPERIMENT_MANAGER.updateDialog();
+      FINDER.updateDialog();
     }
     this.variable_modal.hide();
   }

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;
@@ -554,7 +556,7 @@ class Finder {
         stack = UI.boxChecked('confirm-add-chart-variables-stacked'),
         equations = this.entities[0] instanceof DatasetModifier,
         enl = [];
-    for(const e of this.entities) enl.push(equations ? e.selector : e.name);
+    for(const e of this.entities) enl.push(equations ? e.selector : e.displayName);
     enl.sort((a, b) => UI.compareFullNames(a, b, true));
     for(const en of enl) {
       let vi = null;

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

@@ -104,30 +104,25 @@ module.exports = class MILPSolver {
     const
         windows = os.platform().startsWith('win'),
         path_list = process.env.PATH.split(path.delimiter);
-    // Iterate over all seprate paths in environment variable PATH. 
+    // Iterate over all separate paths in environment variable PATH.
+    // NOTE: gurobi_cl.exe version 12 and higher appears not to exit cleanly
+    // for some models (not clear when), so keep track of all Gurobi paths.
+    let gsp = {};
     for(const p of path_list) {
       // Assume that path is not a solver path.
       sp = '';
       // Check whether it is a Gurobi path.
       match = p.match(/gurobi(\d+)/i);
-      if(match) sp = p;
-      // If so, ensure that it has a higher version number.
-      // NOTE: gurobi_cl.exe version 12 and higher appears not to exit cleanly for
-      // some models (not clear when). To force using version 11 (if installed),
-      // remove "true ||" from line below.
-      const version_OK = true || !(match[1].startsWith('12') || match[1].startsWith('13'));
-      if(sp && parseInt(match[1]) > max_vn && version_OK) {
+      if(match) {
         // Check whether command line version is executable.
-        sp = path.join(sp, 'gurobi_cl' + (windows ? '.exe' : ''));
+        sp = path.join(p, 'gurobi_cl' + (windows ? '.exe' : ''));
         try {
           fs.accessSync(sp, fs.constants.X_OK);
-          console.log('Path to Gurobi:', sp);
-          this.solver_list.gurobi = {name: 'Gurobi', path: sp};
-          max_vn = parseInt(match[1]);
+          gsp[match[1]] = p;
         } catch(err) {
           console.log(err.message);
           console.log(
-              'WARNING: Failed to access the Gurobi command line application');
+              'WARNING: Failed to access the Gurobi command line application', sp);
         }
       }
       if(sp) continue;
@@ -191,6 +186,22 @@ module.exports = class MILPSolver {
       }
       // NOTE: Order of paths is unknown, so keep iterating.
     }
+    // Only now set the Gurobi path. To force using a version < 12 (if installed),
+    // set before_12 to TRUE.
+    const
+        before_12 = false,
+        gsp_keys = Object.keys(gsp).sort();
+    while(gsp_keys.length) {
+      const
+          k = gsp_keys.pop(),
+          version = Math.trunc(parseInt(k) / 100);
+      if(version < 12 || !before_12) {
+        this.solver_list.gurobi = {name: 'Gurobi',
+            path: path.join(gsp[k], 'gurobi_cl')};
+        console.log('Path to Gurobi:', this.solver_list.gurobi.path);
+        break;
+      }
+    }
     // For macOS, look in applications directory if not found in PATH.
     if(!this.solver_list.gurobi && !windows) {
       console.log('Looking for Gurobi in /usr/local/bin');

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.
@@ -2701,6 +2746,8 @@ class LinnyRModel {
         UNDO_STACK.addXML(a.asXML);
         this.removeImport(a);
         this.removeExport(a);
+        // Ensure that chart variables referencing this actor are removed.
+        this.removeActorChartVariables(a);
         delete this.actors[k];
       }
     }
@@ -2823,6 +2870,46 @@ class LinnyRModel {
     }
     return xl;
   }
+  
+  updateChartVariables(e) {
+    // Ensure that all chart variable names based on entity `e` will be
+    // displayed correctly the next time they are drawn.
+    const sc = this.charts[CHART_MANAGER.chart_index];
+    let ucm = false;
+    for(const c of this.charts) {
+      for(const v of c.variables) {
+        if(v.object === e) {
+          v.display_name = '';
+          ucm = ucm || c === sc;
+        }
+      }
+    }
+    if(ucm) CHART_MANAGER.updateDialog();
+  }
+
+  removeActorChartVariables(a) {
+    // Ensure that all chart variable names based on entity `e` or actor `a`
+    // will be displayed correctly the next time they are drawn.
+    const sc = this.charts[CHART_MANAGER.chart_index];
+    let ucm = false;
+    for(const c of this.charts) {
+      for(let vi = 0; vi < c.variables.length; vi++) {
+        if(c.variables[vi].object === a) {
+          c.variables.splice(vi, 1);
+          if(c === sc) {
+            ucm = true;
+            if(CHART_MANAGER.variable_index === vi) {
+              CHART_MANAGER.variable_index = -1;
+            }
+          }
+        }
+      }
+    }
+    // Update stay-on-top dialogs (if needed).
+    if(ucm) CHART_MANAGER.updateDialog();
+    if(EXPERIMENT_MANAGER.selected_experiment) EXPERIMENT_MANAGER.updateDialog();
+    FINDER.updateDialog();
+  }
 
   replaceEntityInExpressions(en1, en2, notify=true) {
     // Replace entity name `en1` by `en2` in all variables in all expressions
@@ -2853,12 +2940,6 @@ class LinnyRModel {
           pluralS(ioc.expression_count, 'expression');
       if(notify) UI.notify('Renamed ' + replace_msg);
     }
-    // Clear display name cache of potentially affected chart variables.
-    for(const c of this.charts) {
-      for(const v of c.variables) {
-        if(v.display_name.indexOf(en1) >= 0) v.display_name = '';
-      }
-    }    
     // Rename entities in parameters and outcomes of sensitivity analysis.
     for(let i = 0; i < this.sensitivity_parameters.length; i++) {
       const sp = this.sensitivity_parameters[i].split('|');
@@ -5181,6 +5262,8 @@ class Actor {
     MODEL.actors[a.identifier] = this;
     // Remove the old entry.
     delete MODEL.actors[old_id];
+    // Ensure that cached variable names are updated.
+    MODEL.updateChartVariables(this);
     MODEL.replaceEntityInExpressions(old_name, this.name);
     MODEL.inferIgnoredEntities();
   }
@@ -6042,6 +6125,8 @@ class NodeBox extends ObjectWithXYWH {
     }
     // Update actor list in case some actor name is no longer used.
     MODEL.cleanUpActors();
+    // Ensure that cached variable names are updated.
+    MODEL.updateChartVariables(this);
     // Update expression texts.
     MODEL.replaceEntityInExpressions(old_name, this.displayName);
     // NOTE: Renaming changes identifier that is used as index in
@@ -8783,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;
@@ -9747,6 +9837,8 @@ class Dataset {
     this.name = name;
     MODEL.datasets[new_id] = this;
     if(old_id !== new_id) delete MODEL.datasets[old_id];
+    // Ensure that cached variable names are updated.
+    MODEL.updateChartVariables(this);
     MODEL.replaceEntityInExpressions(old_name, name, notify);
     return MODEL.datasets[new_id];
   }

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';
@@ -2304,7 +2303,7 @@ class VirtualMachine {
     // for the numerical stability. Meanwhile, the slack variables themselves
     // will have values 1/sm times the actual slack, so this needs to be
     // scaled back in solver messages.
-    this.SLACK_MULTIPLIER = 0.01;
+    this.SLACK_MULTIPLIER = 1;
     // The "epsilon multiplier" divides the ON/OFF threshold over the POS
     // and NEG binaries and the EPS slack variable to avoid high coefficients.
     this.EPSILON_MULTIPLIER = 1 / Math.sqrt(this.ON_OFF_THRESHOLD);
@@ -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]
-        );          
+        );
       }
     }
   }
@@ -3622,6 +3621,7 @@ class VirtualMachine {
     // However, Linny-R does not prohibit negative bounds on processes, nor
     // negative rates on links. To be consistently permissive, cash IN and
     // cash OUT of all actors are both allowed to become negative.
+    /*
     for(const k of actor_keys) {
       const a = MODEL.actors[k];
       // NOTE: Add fourth parameter TRUE to signal that the SOLVER's
@@ -3635,7 +3635,7 @@ class VirtualMachine {
               VM.MINUS_INFINITY, VM.PLUS_INFINITY, true]]
       );
     }
-
+    */
     // NEXT: Define the bounds for all production level variables.
     // NOTE: The VM instructions check dynamically whether the variable
     // index is listed as "fixed" for the round that is being solved.
@@ -3669,7 +3669,7 @@ class VirtualMachine {
       if(rf != 0) {
         // Note: 32-bit integer `b` is used for bit-wise AND
         let b = 1;
-        for(j = 0; j < MODEL.rounds; j++) {
+        for(let j = 0; j < MODEL.rounds; j++) {
           if((rf & b) != 0) {
             this.fixed_var_indices[j][p.level_var_index] = true;
             // @@ TO DO: fixate associated binary variables if applicable!
@@ -4180,8 +4180,9 @@ class VirtualMachine {
        
        (a) L = POSL - NEGL
        
-       This "partitions" the level in two components. The following constraints
-       ensure a (functionally) unique partitioning:
+       This "partitions" the level in two components.
+       
+       The following constraints ensure a (functionally) unique partitioning:
        
        (b) NEGL - M*NEG <= 0  (so NEG=1 if NEGL > 0)
        (c) POSL - M*POS <= 0  (so POS=1 if POSL > 0)
@@ -4872,14 +4873,31 @@ class VirtualMachine {
             pl = this.keepException(pl, pl / count);
           }
         } else if(l.multiplier === VM.LM_THROUGHPUT) {
-          // NOTE: calculate throughput on basis of levels and rates,
-          // as not all actual flows may have been computed yet
+          // NOTE: Calculate throughput on basis of *process* levels and rates,
+          // as not all actual flows may have been computed yet.
           pl = 0;
-          for(const ll of p.inputs) {
+          for(const ll of p.inputs) if(ll.from_node instanceof Process) {
             const
-                ipl = ll.from_node.actualLevel(bt),
-                rr =  ll.relative_rate.result(bt); 
-            pl = this.severestIssue([pl, ipl, rr], pl + ipl * rr);
+                lld = ll.actualDelay(b),
+                ipl = ll.from_node.actualLevel(bt - lld),
+                rr =  ll.relative_rate.result(bt - lld),
+                flow = ipl * rr;
+            // NOTE: Only consider INflows, so flow must be > 0.
+            if(flow > 0) { 
+              pl = this.severestIssue([pl, ipl, rr], pl + flow);
+            }
+          }
+          // NOTE: Again, only consider processes.
+          for(const ll of p.outputs) if(ll.to_node instanceof Process) {
+            const
+                // NOTE: Links TO a process cannot have a delay.
+                opl = ll.to_node.actualLevel(bt),
+                rr =  ll.relative_rate.result(bt),
+                flow = opl * rr;
+            // NOTE: Only consider INflows, so now flow must be < 0.
+            if(flow < 0) {
+              pl = this.severestIssue([pl, opl, rr], pl - flow);
+            }
           }
         } else if(l.multiplier === VM.LM_PEAK_INC) {
           // Actual flow over "peak increase" link is zero unless...
@@ -5060,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];
@@ -5073,7 +5091,7 @@ class VirtualMachine {
         }
       }
     }
-
+*/
     // THEN: Reset the vectors of all chart variables.
     for(const c of MODEL.charts) c.resetVectors();
     
@@ -5461,8 +5479,8 @@ class VirtualMachine {
         v,
         line = '';
     // NOTE: Iterate over ALL columns to maintain variable order.
-    let n = abl * this.cols + this.chunk_variables.length;
-    for(p = 1; p <= n; p++) {
+    let ncols = abl * this.cols + this.chunk_variables.length;
+    for(p = 1; p <= ncols; p++) {
       if(this.objective.hasOwnProperty(p)) {
         c = this.objective[p];
         // Check for numeric issues.
@@ -5486,8 +5504,8 @@ class VirtualMachine {
     } else {
       this.lines += '\n/* Constraints */\n';
     }
-    n = this.matrix.length;
-    for(let r = 0; r < n; r++) {
+    let nrows = this.matrix.length;
+    for(let r = 0; r < nrows; r++) {
       const row = this.matrix[r];
       if(named_constraints) line = `C${r + 1}: `;
       for(p in row) if (row.hasOwnProperty(p)) {
@@ -5521,8 +5539,7 @@ class VirtualMachine {
     } else {
       this.lines += '\n/* Variable bounds */\n';
     }
-    n = abl * this.cols;
-    for(p = 1; p <= n; p++) {
+    for(p = 1; p <= ncols; p++) {
       let lb = null,
           ub = null;
       if(this.lower_bounds.hasOwnProperty(p)) {
@@ -5658,7 +5675,7 @@ class VirtualMachine {
       for(let i in this.is_semi_continuous) if(Number(i)) v_set.push(vbl(i));
       if(v_set.length > 0) this.lines += 'sec ' + v_set.join(', ') + ';\n';
       // LP_solve supports SOS, so add the SOS section if needed.
-      if(this.nzp_var_indices.length ||this.sos_var_indices.length) {
+      if(this.nzp_var_indices.length || this.sos_var_indices.length) {
         this.lines += 'sos\n';
         for(let j = 0; j < abl; j++) {
           // First add the SOS1 constraints for NZP-partitioned levels.
@@ -6149,11 +6166,11 @@ Solver status = ${json.status}`);
     // Generate lines of code in format that should be accepted by solver.
     if(this.solver_id === 'gurobi') {
       this.writeLpFormat(true);
-    } else if(this.solver_id === 'mosek') {
+    } else if(this.solver_id === 'mosek' || this.solver_id === 'scip') {
       // NOTE: For MOSEK, constraints must be named, or variable names
-      // in solution file will not match.
+      // in solution file will not match. SCIP works, but generates warnings.
       this.writeLpFormat(true, true);
-    } else if(this.solver_id === 'cplex' || this.solver_id === 'scip') {
+    } else if(this.solver_id === 'cplex') {
       // NOTE: The more widely accepted CPLEX LP format differs from the
       // LP_solve format that was used by the first versions of Linny-R.
       // TRUE indicates "CPLEX format".
@@ -6725,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));
@@ -8329,7 +8351,7 @@ function VMI_set_bounds(args) {
       l = args[1];
       u = args[2];
       if(u instanceof Expression) u = u.result(VM.t);
-      if(u === VM.UNDEFINED) {
+      if(u === VM.UNDEFINED || u === VM.DIAGNOSIS_UPPER_BOUND) {
         u = inf_val;
       } else {
         u = Math.min(u, inf_val);
@@ -8340,6 +8362,8 @@ function VMI_set_bounds(args) {
         if(l instanceof Expression) l = l.result(VM.t);
         if(l === VM.UNDEFINED || !l) {
           l = 0;
+        } else if(l === -VM.DIAGNOSIS_UPPER_BOUND) {
+          l = -inf_val;
         } else {
           l = Math.max(l, -inf_val);
         }
@@ -8355,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) {
@@ -8407,7 +8431,7 @@ function VMI_set_bounds(args) {
             cvi = VM.chunk_offset + p.peak_inc_var_index,
             // Check if peak UB already set for previous t
             piub = VM.upper_bounds[cvi];
-        // If so, use the highest value
+        // If so, use the highest value.
         if(piub) u = Math.max(piub, u);
         VM.upper_bounds[cvi] = u;
         VM.upper_bounds[cvi + 1] = u;
@@ -9055,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]) {
@@ -9062,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]) {
@@ -9072,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),
@@ -9081,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);
       }
     }
   }
@@ -9123,7 +9150,10 @@ function VMI_set_objective() {
     for(let i = 0; i < VM.chunk_variables.length; i++) {
       const vn = VM.chunk_variables[i][0]; 
       if(vn.indexOf('peak') > 0) {
-        const pvp = VM.PEAK_VAR_PENALTY / VM.cash_scalar;
+        // NOTE: When prices in model are low, the cash scalar is small
+        // and then a peak variable penalty of 0.1 currency unit will
+        // significantly impact the tipping point for investment choices
+        const pvp = VM.PEAK_VAR_PENALTY / Math.max(VM.cash_scalar, 2000);
         // NOTE: Chunk offset takes into account that indices are 0-based.
         VM.objective[VM.chunk_offset + i] = -pvp;
         // Put higher penalty on "block peak" than on "look-ahead peak"
@@ -9156,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.
@@ -9210,7 +9239,7 @@ function VMI_add_semicontinuous_constraints(p) {
       // level - UB*binary <= 0
       row = {};
       row[l_index] = 1;
-      row[lb_index] = -ub;
+      row[lb_index] = -ub - 1;
       VM.matrix.push(row);
       VM.right_hand_side.push(0);
       VM.constraint_types.push(VM.LE);
@@ -9227,11 +9256,26 @@ function VMI_add_NZP_continuous_constraints(p) {
     console.log('add_NZP_continuous_constraints (t = ' + VM.t + ')');
   }
   if(!p || p.posl_var_index < 0) throw 'ANOMALY: No NZP variable indices';
-  const row = {};
-  // (a) L + NEGL - POSL = 0  (so POSL - NEGL = L).
-  row[VM.offset + p.level_var_index] = 1;
-  row[VM.offset + p.negl_var_index] = 1;
-  row[VM.offset + p.posl_var_index] = -1;
+  let row = {};
+  if(p.level_to_zero) {
+    // For semi-continuous processes, the level is always >= 0.
+    // To prevent issues with binaries, set POSL = L and NEGL = 0 to rule out
+    // the possibility of NEGL being used to compensate for a positive epsilon.
+    // (a1) L - POSL = 0.
+    row[VM.offset + p.level_var_index] = 1;
+    row[VM.offset + p.posl_var_index] = -1;
+    VM.matrix.push(row);
+    VM.right_hand_side.push(0);
+    VM.constraint_types.push(VM.EQ);
+    row = {};
+    // (a2) NEGL = 0.
+    row[VM.offset + p.negl_var_index] = 1;
+  } else {
+    // (a) L + NEGL - POSL = 0  (so POSL - NEGL = L).
+    row[VM.offset + p.level_var_index] = 1;
+    row[VM.offset + p.negl_var_index] = 1;
+    row[VM.offset + p.posl_var_index] = -1;
+  }
   VM.matrix.push(row);
   VM.right_hand_side.push(0);
   VM.constraint_types.push(VM.EQ);
@@ -9291,14 +9335,17 @@ function VMI_add_NZP_binary_constraints(p) {
   row[pos_index] = VM.EPSILON_MULTIPLIER * VM.ON_OFF_THRESHOLD;
   row[posl_index] = -VM.EPSILON_MULTIPLIER;
   // Provide slack so the constraint can always be met, but at a significant cost.
-  row[eps_index] = -VM.SLACK_MULTIPLIER / VM.EPSILON_MULTIPLIER;
+  // NOTE: Do *NOT* do this for semi-continuous processes.
+  if(!p.level_to_zero) {
+    row[eps_index] = -VM.SLACK_MULTIPLIER / VM.EPSILON_MULTIPLIER;
+  }
   VM.matrix.push(row);
   VM.right_hand_side.push(0);
   VM.constraint_types.push(VM.LE);
   // NOTE: This VMI is added when LB *may* become negative, so check
   // whether now (at run time) LB >= 0, as then NZP partitioning is
   // trivial and need not be done by the solver.
-  if(lb >= 0) {
+  if(lb >= 0 || p.level_to_zero) {
     // If L >= 0, NEG must be 0.
     row = {};
     row[neg_index] = 1;
@@ -9748,7 +9795,7 @@ function VMI_add_throughput_to_coefficients(link) {
     // Skip link when it has rate = 0.
     if(r2 === 0) continue;
     // By default, use the FROM node's level...
-    let vi = (lfn.is_zero_var_index < 0 ? lfn.level_var_index :
+    let vi = (lfn.posl_var_index < 0 ? lfn.level_var_index :
         // ... but differentiate when this level is NZP-partitioned.
         // Then use positive level component when rate > 0, and negative
         // level component when rate < 0, so throughput flow is always >= 0.
@@ -9807,7 +9854,7 @@ function VMI_add_throughput_to_coefficients(link) {
     if(r2 === 0) continue;
     // Also skip when level is not NZP-partitioned, as then an output-link
     // cannot contribute to the *inflow* of the process being "read".
-    if(ltn.is_zero_var_index < 0) continue;
+    if(ltn.posl_var_index < 0) continue;
     // Now use the negative level component when rate > 0, and positive
     // level component when rate < 0, so throughput flow is always >= 0.
     const