linny-r 1.6.7 → 1.7.0

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

@@ -88,7 +88,6 @@ class LinnyRModel {
     this.selected_round = 0;
     
     // Model settings
-    this.timeout_period = 30; // max. solver time in seconds
     this.block_length = 1;
     this.start_period = 1; // defines starting point in datasets
     this.end_period = 1;
@@ -99,6 +98,12 @@ class LinnyRModel {
     this.report_results = false;
     this.show_block_arrows = true;
     this.last_zoom_factor = 1;
+    
+    // Default solver settings
+    this.timeout_period = 30; // max. solver time in seconds
+    this.preferred_solver = ''; // empty string denotes "use default"
+    this.integer_tolerance = 5e-7; // integer feasibility tolerance
+    this.MIP_gap = 1e-4; // relative MIP gap
 
     // Sensitivity-related properties
     this.base_case_selectors = '';
@@ -140,17 +145,18 @@ class LinnyRModel {
   /* METHODS THAT LOOKUP ENTITIES, OR INFER PROPERTIES */
 
   get simulationTimeStep() {
-    // Returns actual model time step, rather than `t`, which is relative to the
-    // start of the simulation period
+    // Return actual model time step, rather than `t`, which is relative
+    // to the start of the simulation period.
     return this.t + this.start_period - 1;
   }
   
   get timeStepDuration() {
-    // Returns duration of 1 time step in hours
+    // Return duration of 1 time step in hours.
     return this.time_scale * VM.time_unit_values[this.time_unit];
   }
   
   get outcomes() {
+    // Return the list of outcome datasets.
     const olist = [];
     for(let k in this.datasets) if(this.datasets.hasOwnProperty(k)) {
       if(this.datasets[k].outcome) olist.push(this.datasets[k]);
@@ -2631,17 +2637,17 @@ class LinnyRModel {
   }
 
   initFromXML(node) {
-    // Initialize a model from the XML tree with `node` as root
-    // NOTE: do NOT reset and initialize basic model properties when *including*
-    // a module into the current model
-    // NOTE: obsolete XML nodes indicate: legacy Linny-R model
+    // Initialize a model from the XML tree with `node` as root.
+    // NOTE: do NOT reset and initialize basic model properties when
+    // *including* a module into the current model.
+    // NOTE: Obsolete XML nodes indicate: legacy Linny-R model.
     const legacy_model = (nodeParameterValue(node, 'view-options') +
         nodeParameterValue(node, 'autosave') +
         nodeParameterValue(node, 'look-ahead') +
         nodeParameterValue(node, 'save-series') +
         nodeParameterValue(node, 'show-lp') +
         nodeParameterValue(node, 'optional-slack')).length > 0;
-    // Flag to set when legacy time series data are added 
+    // Flag to set when legacy time series data are added.
     this.legacy_datasets = false;
     if(!IO_CONTEXT) {
       this.reset();
@@ -2668,7 +2674,12 @@ class LinnyRModel {
       this.version = xmlDecoded(nodeContentByTag(node, 'version'));
       this.timeout_period = Math.max(0,
           safeStrToInt(nodeContentByTag(node, 'timeout-period')));
-      // Legacy models have tag "optimization-period" instead of "block-length"
+      this.preferred_solver = xmlDecoded(
+          nodeContentByTag(node, 'preferred-solver')); 
+      this.integer_tolerance = safeStrToFloat(
+          nodeContentByTag(node, 'integer-tolerance'), 5e-7);
+      this.MIP_gap = safeStrToFloat(nodeContentByTag(node, 'mip-gap'), 1e-4);
+      // Legacy models have tag "optimization-period" instead of "block-length".
       const bl_str = nodeContentByTag(node, 'block-length') ||
           nodeContentByTag(node, 'optimization-period'); 
       this.block_length = Math.max(1, safeStrToInt(node, bl_str));
@@ -2693,7 +2704,7 @@ class LinnyRModel {
       if(!this.default_unit) this.default_unit = CONFIGURATION.default_scale_unit;
     } // END IF *not* including a model
 
-    // Declare some local variables that will be used a lot
+    // Declare some local variables that will be used a lot.
     let i,
         c,
         name,
@@ -3014,7 +3025,10 @@ class LinnyRModel {
         '</default-scale-unit><currency-unit>', xmlEncoded(this.currency_unit),
         '</currency-unit><grid-pixels>', this.grid_pixels,
         '</grid-pixels><timeout-period>', this.timeout_period,
-        '</timeout-period><block-length>', this.block_length,
+        '</timeout-period><preferred-solver>', xmlEncoded(this.preferred_solver), 
+        '</preferred-solver><integer-tolerance>', this.integer_tolerance,
+        '</integer-tolerance><mip-gap>', this.MIP_gap,
+        '</mip-gap><block-length>', this.block_length,
         '</block-length><start-period>', this.start_period,
         '</start-period><end-period>', this.end_period,
         '</end-period><look-ahead-period>', this.look_ahead,

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

@@ -2328,7 +2328,13 @@ class VirtualMachine {
     // Statistics that can be calculated for outcomes and experiment run results
     this.outcome_statistics =
       ['LAST', 'MAX', 'MEAN', 'MIN', 'N', 'NZ', 'SD', 'SUM', 'VAR'];
-    }
+    this.solver_names = {
+      gurobi: 'Gurobi',
+      cplex: 'CPLEX',
+      scip: 'SCIP',
+      lp_solve: 'LP_solve'
+    };
+  }
 
   reset() {
     // Reset the virtual machine so that it can execute the model again.
@@ -2945,6 +2951,7 @@ class VirtualMachine {
       return obj.la_peak_inc[c];
     }
     const prior_level = obj.actualLevel(t);
+//console.log('HERE obj prilev t', obj.displayName, prior_level, t, obj.level);
     if(type === 'OO') return prior_level > 0 ? 1 : 0;
     if(type === 'IZ') return prior_level === 0 ? 1 : 0;
     // Start-up at time t entails that t is in the list of start-up
@@ -4305,7 +4312,7 @@ class VirtualMachine {
     // Return floating point number `n`, or +INF or -INF if the absolute
     // value of `n` is relatively (!) close to the VM infinity constants
     // (since the solver may return imprecise values of such magnitude).
-    if(n > 0.5 * VM.PLUS_INFINITY && n < VM.BEYOND_PLUS_INFINITY) {
+      if(n > 0.5 * VM.PLUS_INFINITY && n < VM.BEYOND_PLUS_INFINITY) {
       return VM.PLUS_INFINITY;
     } 
     if(n < 0.5 * VM.MINUS_INFINITY && n > VM.BEYOND_MINUS_INFINITY) {
@@ -4526,6 +4533,21 @@ class VirtualMachine {
     }
   }
   
+  severestIssue(list, result) {
+    // Returns severest exception code or +/- INFINITY in `list`, or the
+    // result of the computation that involves the elements of `list`.
+    let issue = 0;
+    for(let i = 0; i < list.length; i++) {
+      if(list[i] <= VM.MINUS_INFINITY) {
+        issue = Math.min(list[i], issue);
+      } else if(list[i] >= VM.PLUS_INFINITY) {
+        issue = Math.max(list[i], issue);
+      }
+    }
+    if(issue) return issue;
+    return result;
+  }
+  
   calculateDependentVariables(block) {
     // Calculate the values of all model variables that depend on the
     // values of the decision variables output by the solver.
@@ -4539,7 +4561,7 @@ class VirtualMachine {
         cbl = this.actualBlockLength(block);
 
     // FIRST: Calculate the actual flows on links.
-    let b, bt, p, pl, ld;
+    let b, bt, p, pl, ld, ci;
     for(let l in MODEL.links) if(MODEL.links.hasOwnProperty(l) &&
         !MODEL.ignored_entities[l]) {
       l = MODEL.links[l];
@@ -4552,6 +4574,8 @@ class VirtualMachine {
         // NOTE: Flows may have a delay!
         ld = l.actualDelay(b);
         bt = b - ld;
+        // NOTE: Block index may fall beyond actual chunk length.
+        ci = i - ld;
         // NOTE: Use non-zero level here to ignore non-zero values that
         // are very small relative to the bounds on the process
         // (typically values below the non-zero tolerance of the solver).
@@ -4575,20 +4599,22 @@ class VirtualMachine {
           // Similar to STARTUP, but now look in the shut-down list.
           pl = (p.shut_downs.indexOf(bt) < 0 ? 0 : 1);
         } else if(l.multiplier === VM.LM_INCREASE) {
-          pl = VM.keepException(pl, pl - p.actualLevel(bt - 1));
+          const ppl = p.actualLevel(bt - 1);
+          pl = this.severestIssue([pl, ppl], pl - ppl);
         } else if(l.multiplier === VM.LM_SUM || l.multiplier === VM.LM_MEAN) {
           // Level for `bt` counts as first value.
           let count = 1;
           // NOTE: Link delay may be < 0!
           if(ld < 0) {
-            // NOTE: Actual levels beyond end of period are undefined,
+            // NOTE: Actual levels beyond the chunk length are undefined,
             // and should be ignored while summing / averaging.
-            if(bt >= p.level.length) pl = 0;
+            if(ci >= cbl) pl = 0;
             // If so, take sum over t, t+1, ..., t+(d-1).
             for(let j = ld + 1; j <= 0; j++) {
-              // Again: ignore levels beyond end of period.
-              if(b - j < p.level.length) {
-                pl = VM.keepException(pl, pl + p.actualLevel(b - j));
+              // Again: only consider levels up to the end of the chunk.
+              if(ci - j < cbl) {
+                const spl = p.actualLevel(b - j);
+                pl = this.severestIssue([pl, spl], pl + spl);
                 count++;
               }
             }
@@ -4597,22 +4623,24 @@ class VirtualMachine {
             for(let j = 0; j < ld; j++) {
               // NOTE: Actual levels before t=0 are considered equal to
               // the initial level, and hence should NOT be ignored.
-              pl = VM.keepException(pl, pl + p.actualLevel(b - j));
+              const spl = p.actualLevel(b - j);
+              pl = this.severestIssue([pl, spl], pl + spl);
               count++;
             }
           }
           if(l.multiplier === VM.LM_MEAN && count > 1) {
             // Average if more than 1 values have been summed.
-            pl = VM.keepException(pl, pl / count);
+            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
           pl = 0;
           for(let j = 0; j < p.inputs.length; j++) {
-            pl = VM.keepException(pl,
-                pl + (p.inputs[j].from_node.actualLevel(bt) *
-                    p.inputs[j].relative_rate.result(bt)));
+            const
+                ipl = p.inputs[j].from_node.actualLevel(bt),
+                rr =  p.inputs[j].relative_rate.result(bt); 
+            pl = this.severestIssue([pl, ipl, rr], pl + ipl * rr);
           }
         } else if(l.multiplier === VM.LM_PEAK_INC) {
           // Actual flow over "peak increase" link is zero unless...
@@ -4627,17 +4655,10 @@ class VirtualMachine {
           }
         }
         // Preserve special values such as INF, UNDEFINED and VM error codes.
-        if(pl <= VM.MINUS_INFINITY || pl > VM.PLUS_INFINITY) {
-          l.actual_flow[b] = pl;
-        } else {
-          const rr = l.relative_rate.result(bt);
-          if(rr <= VM.MINUS_INFINITY || rr > VM.PLUS_INFINITY) {
-            l.actual_flow[b] = rr;
-          } else {
-            const af = rr * pl;
-            l.actual_flow[b] = (Math.abs(af) > VM.NEAR_ZERO ? af : 0);
-          }
-        }
+        const
+            rr = l.relative_rate.result(bt),
+            af = this.severestIssue([pl, rr], rr * pl);
+        l.actual_flow[b] = (Math.abs(af) > VM.NEAR_ZERO ? af : 0);
         b++;
       }
     }
@@ -5586,24 +5607,33 @@ Solver status = ${json.status}`);
     // levels and stock level), but do NOT overwrite "look-ahead" levels
     // if this block was not solved (indicated by the 4th parameter that
     // tests the status).
-    // NOTE: Appropriate status codes are solver-dependent.
-    this.setLevels(bnr, rl, json.data.x,
-      this.noSolutionStatus.indexOf(json.status) >= 0);
-    // NOTE: Post-process levels only AFTER the last round!
-    if(rl === this.lastRound) {
-      // Calculate data for all other dependent variables.
-      this.calculateDependentVariables(bnr);    
-      // Add progress bar segment only now, knowing status AND slack use.
-      const issue = json.status !== 0 || this.error_count > 0;
-      if(issue) this.block_issues++;
-      // NOTE: in case of multiple rounds, use the sum of the round times.
-      const time = this.round_times.reduce((a, b) => a + b, 0);
-      this.round_times.length = 0;
-      this.solver_times[bnr - 1] = time;
-      const ssecs = this.round_secs.reduce((a, b) => a + b, 0);
-      this.solver_secs[bnr - 1] = (ssecs ? VM.sig4Dig(ssecs) : '0');
-      this.round_secs.length = 0;
-      MONITOR.addProgressBlock(bnr, issue, time);
+    try {
+      this.setLevels(bnr, rl, json.data.x,
+        // NOTE: Appropriate status codes are solver-dependent.
+        this.noSolutionStatus.indexOf(json.status) >= 0);
+      // NOTE: Post-process levels only AFTER the last round!
+      if(rl === this.lastRound) {
+        // Calculate data for all other dependent variables.
+        this.calculateDependentVariables(bnr);    
+        // Add progress bar segment only now, knowing status AND slack use.
+        const issue = json.status !== 0 || this.error_count > 0;
+        if(issue) this.block_issues++;
+        // NOTE: in case of multiple rounds, use the sum of the round times.
+        const time = this.round_times.reduce((a, b) => a + b, 0);
+        this.round_times.length = 0;
+        this.solver_times[bnr - 1] = time;
+        const ssecs = this.round_secs.reduce((a, b) => a + b, 0);
+        this.solver_secs[bnr - 1] = (ssecs ? VM.sig4Dig(ssecs) : '0');
+        this.round_secs.length = 0;
+        MONITOR.addProgressBlock(bnr, issue, time);
+      }
+    } catch(err) {
+      const msg = `ERROR while processing solver data for block ${bnr}: ${err}`;
+      console.log(msg);      
+      MONITOR.logMessage(bnr, msg);
+      UI.alert(msg);
+      this.stopSolving();
+      this.halted = true;
     }
     // Free up memory.
     json = null;
@@ -5696,7 +5726,7 @@ Solver status = ${json.status}`);
   }  
 
   submitFile() {
-    // Prepares to POST the model file (LP or MPS) to the Linny-R server.
+    // Prepare to POST the model file (LP or MPS) to the Linny-R server.
     // NOTE: The tableau is no longer needed, so free up its memory.
     this.resetTableau();
     if(this.numeric_issue) {
@@ -5749,6 +5779,13 @@ Solver status = ${json.status}`);
   solveModel() {
     // Start the sequence of data loading, model translation, solving
     // consecutive blocks, and finally calculating dependent variables.
+    // NOTE: Do this only if the model defines a MILP problem, i.e.,
+    // contains at least one process or product.
+    if(!(Object.keys(MODEL.processes).length ||
+        Object.keys(MODEL.products).length)) {
+      UI.notify('Nothing to solve');
+      return;
+    }
     const n = MODEL.loading_datasets.length;
     if(n > 0) {
       // Still within reasonable time? (3 seconds per dataset)
@@ -5757,7 +5794,7 @@ Solver status = ${json.status}`);
         UI.setMessage(`Waiting for ${pluralS(n, 'dataset')} to load`);
         // Decrease the remaining time to wait (half second units)
         MODEL.max_time_to_load--;
-        // Try again after half a second
+        // Try again after half a second.
         setTimeout(() => VM.solveModel(), 500);
         return;
       } else {