linny-r 1.3.0 → 1.3.2

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

@@ -82,6 +82,42 @@ module.exports = class MILPSolver {
        14: 'Optimization still in progress',
        15: 'User-specified objective limit has been reached'
       };
+    } else if(this.id === 'scip') {
+      this.ext = '.lp';
+      this.user_model = path.join(workspace.solver_output, 'usr_model.lp');
+      this.solver_model = path.join(workspace.solver_output, 'solver_model.lp');
+      this.solution = path.join(workspace.solver_output, 'model.sol');
+      this.log = path.join(workspace.solver_output, 'model.log');
+      // NOTE: SCIP command line accepts space separated commands ...
+      this.args = [
+          'read', this.user_model,
+          'write problem', this.solver_model,
+          'set limit time', 300,
+          'optimize',
+          'write solution', this.solution,
+          'quit'
+        ];
+      // ... when SCIP is called with -c option; then commands must be
+      // enclosed in double quotes; SCIP outputs its messages to the
+      // terminal, so these must be caputured in a log file
+      this.solve_cmd = 'scip -c "' + this.args.join(' ') + '" >' + this.log;
+      this.errors = {
+        1: 'User interrupt',
+        2: 'Node limit reached',
+        3: 'Total node limit reached',
+        4: 'Stalling node limit reached',
+        5: 'Time limit reached',
+        6: 'Memory limit reached',
+        7: 'Gap limit reached',
+        8: 'Solution limit reached',
+        9: 'Solution improvement limit reached',
+       10: 'Restart limit reached',
+       11: 'Optimal solution found',
+       12: 'Problem is infeasible',
+       13: 'Problem is unbounded',
+       14: 'Problem is either infeasible or unbounded',
+       15: 'Solver terminated by user'
+      };
     } else if(this.id === 'lp_solve') {
       // Execute file commands differ across platforms
       if(os.platform().startsWith('win')) {
@@ -129,8 +165,12 @@ module.exports = class MILPSolver {
         error: '',
         messages: []
       };
-    let timeout = parseInt(sp.get('timeout'));
+    // Number of columns (= decision variables) is passed to ensure
+    // that solution vector is complete and its values are placed in
+    // the correct order
+    result.columns = parseInt(sp.get('columns')) || 0;
     // Default timeout per block is 30 seconds
+    let timeout = parseInt(sp.get('timeout'));
     if(isNaN(timeout)) timeout = 30;
     if(!this.id) {
       result.status = -999;
@@ -165,19 +205,24 @@ module.exports = class MILPSolver {
           // (2) the shell option must be set to TRUE (so the command is
           //     executed within an OS shell script) or LP_solve will interpret
           //     the first argument as the model file, and complain
-          // (3) output must be ignored, as LP_solve will output many warnings
-          //     about 0-value coefficients, and these would otherwise also
+          // (3) output must be ignored, as LP_solve warnings should not also
           //     appear on the console
           // (4) prevent Windows opening a visible sub-process shell window
           const
               cmd = this.solve_cmd + ' ' + this.args.join(' '),
               options = {shell: true, stdio: 'ignore', windowsHide: true};
-          spawn = child_process.spawnSync(cmd,  options);
-        } else {          
+          spawn = child_process.spawnSync(cmd, options);
+        } else if(this.id === 'gurobi') {          
+          // When using Gurobi, the standard way with arguments works well
           this.args[0] = 'TimeLimit=' + timeout;
-          // When using Gurobi, the standard way works well
           const options = {windowsHide: true};
           spawn = child_process.spawnSync(this.solver_path, this.args, options);
+        } else if(this.id === 'scip') {          
+          // When using SCIP, take the LP_solve approach
+          const
+              cmd = this.solve_cmd.replace(/limit time \d+/, `limit time ${timeout}`),
+              options = {shell: true, stdio: 'ignore', windowsHide: true};
+          spawn = child_process.spawnSync(cmd, options);
         }
         status = spawn.status;
       } catch(err) {
@@ -200,7 +245,37 @@ module.exports = class MILPSolver {
   
   processSolverOutput(result) {
     // Read solver output files and return solution (or error)
-    const x_values = [];
+    const
+        x_values = [],
+        x_dict = {},
+        getValuesFromDict = () => {
+          // Returns a result vector for as many real numbers (as strings!)
+          // as there are columns (0 if not reported by the solver)
+          // (1) Sort on variable name
+          const vlist = Object.keys(x_dict).sort();
+          // Start with column 1
+          let col = 1;
+          for(let i = 0; i < vlist.length; i++) {
+            const
+                v = vlist[i],
+                // Variable names have zero-padded column numbers, e.g. "X001"
+                vnr = parseInt(v.substring(1));
+            // Add zeros for unreported variables until column number matches
+            while(col < vnr) {
+              x_values.push('0');
+              col++;
+            }
+            x_values.push(x_dict[v]);
+            col++;
+          }
+          // Add zeros to vector for remaining columns
+          while(col <= result.columns) {
+            x_values.push('0');
+            col++;
+          }
+          // No return value; function operates on x_values
+        };
+
     if(this.id === 'gurobi') {
       // `messages` must be an array of strings
       result.messages = fs.readFileSync(this.log, 'utf8').split(os.EOL);
@@ -236,6 +311,60 @@ module.exports = class MILPSolver {
           result.error = 'No solution found';
         }
       }
+    } else if(this.id === 'scip') {
+      result.seconds = 0;
+      // `messages` must be an array of strings
+      result.messages = fs.readFileSync(this.log, 'utf8').split(os.EOL);
+      let solved = false,
+          output = [];
+      if(result.status !== 0) {
+        // Non-zero solver exit code indicates serious trouble
+        result.error = 'SCIP solver terminated with error';
+      } else {
+        try {
+          output = fs.readFileSync(
+              this.solution, 'utf8').trim().split(os.EOL);
+        } catch(err) {
+          console.log('No SCIP solution file');
+        }
+        // Look in messages for solver status and solving time
+        for(let i = 0; i < result.messages.length; i++) {
+          const m = result.messages[i];
+          if(m.startsWith('SCIP Status')) {
+            if(m.indexOf('problem is solved') >= 0) {
+              solved = true;
+            } else if(m.indexOf('interrupted') >= 0) {
+              if(m.indexOf('time limit') >= 0) {
+                result.status = 5;
+              } else if(m.indexOf('memory limit') >= 0) {
+                result.status = 6;
+              } else if(m.indexOf('infeasible') >= 0) {
+                result.status = (m.indexOf('unbounded') >= 0 ? 14 : 12);
+              } else if(m.indexOf('unbounded') >= 0) {
+                result.status = 13;
+              }
+              result.error = this.errors[result.status];
+            }
+          } else if (m.startsWith('Solving Time')) {
+            result.seconds = parseFloat(m.split(':')[1]);
+          }
+        }
+      }
+      if(solved) {
+        // Look for line with first variable
+        let i = 0;
+        while(i < output.length && !output[i].startsWith('X')) i++;
+        // Fill dictionary with variable name: value entries 
+        while(i < output.length) {
+          const v = output[i].split(/\s+/);
+          x_dict[v[0]] = v[1];
+          i++;
+        }
+        // Fill the solution vector, adding 0 for missing columns
+        getValuesFromDict();
+      } else {
+        console.log('No solution found');
+      }
     } else if(this.id === 'lp_solve') {
       // Read solver messages from file
       // NOTE: Linny-R client expects a list of strings
@@ -246,7 +375,7 @@ module.exports = class MILPSolver {
       result.seconds = 0;
       let i = 0,
           solved = false;
-      while(i< output.length && !solved) {
+      while(i < output.length && !solved) {
         msgs.push(output[i]);
         const m = output[i].match(/in total (\d+\.\d+) seconds/);
         if(m && m.length > 1) result.seconds = parseFloat(m[1]);
@@ -255,14 +384,16 @@ module.exports = class MILPSolver {
       }
       result.messages = msgs;
       if(solved) {
-        while(i < output.length && !output[i].startsWith('C1')) i++;
+        // Look for line with first variable
+        while(i < output.length && !output[i].startsWith('X')) i++;
+        // Fill dictionary with variable name: value entries 
         while(i < output.length) {
-          let v = output[i].replace(/C\d+\s*/, '');
-          // Remove variable names from result output
-          v = parseFloat(v);
-          x_values.push(v);
+          const v = output[i].split(/\s+/);
+          x_dict[v[0]] = v[1];
           i++;
         }
+        // Fill the solution vector, adding 0 for missing columns
+        getValuesFromDict();
       } else {
         console.log('No solution found');
       }

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

@@ -277,6 +277,21 @@ class LinnyRModel {
     return null;
   }
 
+  productByID(id) {
+    if(this.products.hasOwnProperty(id)) return this.products[id];
+    return null;
+  }
+  
+  processByID(id) {
+    if(this.processes.hasOwnProperty(id)) return this.processes[id];
+    return null;
+  }
+  
+  clusterByID(id) {
+    if(this.clusters.hasOwnProperty(id)) return this.clusters[id];
+    return null;
+  }
+  
   nodeBoxByID(id) {
     if(this.products.hasOwnProperty(id)) return this.products[id];
     if(this.processes.hasOwnProperty(id)) return this.processes[id];
@@ -1572,7 +1587,7 @@ class LinnyRModel {
     }
     return true;
   }
-  
+
   get selectionAsXML() {
     // Returns XML for the selected entities, and also for the entities
     // referenced by expressions for their attributes.
@@ -1595,34 +1610,92 @@ class LinnyRModel {
         from_tos = [],
         xml = [],
         ft_xml = [],
-        extra_xml = [];
+        extra_xml = [],
+        selected_xml = [];
     for(let i = 0; i < this.selection.length; i++) {
       const obj = this.selection[i];
       entities[obj.type].push(obj);
+      selected_xml.push('<sel>' + xmlEncoded(obj.displayName) + '</sel>');
     }
+    // Expand clusters by adding all its model entities to their respective
+    // lists
+    for(let i = 0; i < entities.Cluster.length; i++) {
+      const c = entities.Cluster[i];
+      c.clearAllProcesses();
+      c.categorizeEntities();
+      // All processes and products in (sub)clusters must be copied
+      mergeDistinct(c.all_processes, entities.Process);
+      mergeDistinct(c.all_products, entities.Product);
+      // Likewise for all related links and constraints
+      mergeDistinct(c.related_links, entities.Link);
+      mergeDistinct(c.related_constraints, entities.Constraint);
+      // NOTE: add entities referenced by notes within selected clusters
+      // to `extras`, but not the XML for these notes, as this is already
+      // part of the clusters' XML
+      const an = c.allNotes;
+      // Add selected notes as these must also be checked for "extras"
+      mergeDistinct(entities.Note, an);
+      for(let i = 0; i < an.length; i++) {
+        const n = an[i];
+        mergeDistinct(n.color.referencedEntities, extras);
+        for(let i = 0; i < n.fields.length; i++) {
+          addDistinct(n.object, extras);
+        }
+      }
+    }
+    // Only add the XML for notes in the selection
     for(let i = 0; i < entities.Note.length; i++) {
-      const n = entities.Note[i];
       xml.push(n.asXML);
     }
     for(let i = 0; i < entities.Product.length; i++) {
-      xml.push(entities.Product[i].asXML);
+      const p = entities.Product[i];
+      mergeDistinct(p.lower_bound.referencedEntities, extras);
+      mergeDistinct(p.upper_bound.referencedEntities, extras);
+      mergeDistinct(p.initial_level.referencedEntities, extras);
+      mergeDistinct(p.price.referencedEntities, extras);
+      xml.push(p.asXML);
     }
     for(let i = 0; i < entities.Process.length; i++) {
-      xml.push(entities.Process[i].asXML);
-    }
+      const p = entities.Process[i];
+      mergeDistinct(p.lower_bound.referencedEntities, extras);
+      mergeDistinct(p.upper_bound.referencedEntities, extras);
+      mergeDistinct(p.initial_level.referencedEntities, extras);
+      mergeDistinct(p.pace_expression.referencedEntities, extras);
+      xml.push(p.asXML);
+    }
+    // Only now add the XML for the selected clusters
     for(let i = 0; i < entities.Cluster.length; i++) {
       xml.push(entities.Cluster[i].asXML);
     }
+    // Add all links that have (implicitly via clusters) been selected
     for(let i = 0; i < entities.Link.length; i++) {
       const l = entities.Link[i];
-      if(this.selection.indexOf(l.from_node) < 0) addDistinct(l.from_node, from_tos);
-      if(this.selection.indexOf(l.to_node) < 0) addDistinct(l.to_node, from_tos);
+      // NOTE: the FROM and/or TO node need not be selected; if not, put
+      // them in a separate list
+      if(entities.Process.indexOf(l.from_node) < 0 &&
+          entities.Product.indexOf(l.from_node) < 0) {
+        addDistinct(l.from_node, from_tos);
+      }
+      if(entities.Process.indexOf(l.to_node) < 0 &&
+          entities.Product.indexOf(l.to_node) < 0) {
+        addDistinct(l.to_node, from_tos);
+      }
+      mergeDistinct(l.relative_rate.referencedEntities, extras);
+      mergeDistinct(l.flow_delay.referencedEntities, extras);
       xml.push(l.asXML);
     }
     for(let i = 0; i < entities.Constraint.length; i++) {
       const c = entities.Constraint[i];
-      if(this.selection.indexOf(c.from_node) < 0) addDistinct(c.from_node, from_tos);
-      if(this.selection.indexOf(c.to_node) < 0) addDistinct(c.to_node, from_tos);
+      // NOTE: the FROM and/or TO node need not be selected; if not, put
+      // them in a separate list
+      if(entities.Process.indexOf(c.from_node) < 0 &&
+          entities.Product.indexOf(c.from_node) < 0) {
+        addDistinct(c.from_node, from_tos);
+      }
+      if(entities.Process.indexOf(c.to_node) < 0 &&
+          entities.Product.indexOf(c.to_node) < 0) {
+        addDistinct(c.to_node, from_tos);
+      }
       xml.push(c.asXML);
     }
     for(let i = 0; i < from_tos.length; i++) {
@@ -1631,7 +1704,9 @@ class LinnyRModel {
       if(p instanceof Process) ft_xml.push('" actor-name="', xmlEncoded(p.actor.name));
       ft_xml.push('"></from-to>');
     }
-    for(let i = 0; i < extras.length; i++) extra_xml.push(extras[i].asXML);
+    for(let i = 0; i < extras.length; i++) {
+      extra_xml.push(extras[i].asXML);
+    }
     return ['<copy timestamp="', Date.now(),
         '" model-timestamp="', this.time_created.getTime(),
         '" cluster-name="', xmlEncoded(fc_name),
@@ -1639,7 +1714,8 @@ class LinnyRModel {
         '"><entities>', xml.join(''),
         '</entities><from-tos>', ft_xml.join(''),
         '</from-tos><extras>', extra_xml.join(''),
-        '</extras></copy>'].join('');
+        '</extras><selection>', selected_xml.join(''),
+        '</selection></copy>'].join('');
   }
   
   dropSelectionIntoCluster(c) {
@@ -4375,7 +4451,10 @@ class Actor {
   
   rename(name) {
     // Change the name of this actor
-    name = UI.cleanName(name);
+    // NOTE: since version 1.3.2, colons are prohibited in actor names to
+    // avoid confusion with prefixed entities; they are silently removed
+    // to avoid model compatibility issues
+    name = UI.cleanName(name).replace(':', '');
     if(!UI.validName(name)) {
       UI.warn(UI.WARNING.INVALID_ACTOR_NAME);
       return null;
@@ -5414,6 +5493,7 @@ class Cluster extends NodeBox {
   get asXML() {
     let xml;
     const
+        cmnts = xmlEncoded(this.comments),
         flags = (this.collapsed ? ' collapsed="1"' : '') +
             (this.ignore ? ' ignore="1"' : '') +
             (this.black_box ? ' black-box="1"' : '') +
@@ -5422,7 +5502,8 @@ class Cluster extends NodeBox {
         '</name><owner>', xmlEncoded(this.actor.name),
         '</owner><x-coord>', this.x,
         '</x-coord><y-coord>', this.y,
-        '</y-coord><process-set>'].join('');
+        '</y-coord><comments>', cmnts,
+        '</comments><process-set>'].join('');
     for(let i = 0; i < this.processes.length; i++) {
       let n = this.processes[i].displayName;
       const id = UI.nameToID(n);
@@ -5458,6 +5539,7 @@ class Cluster extends NodeBox {
   initFromXML(node) {
     this.x = safeStrToInt(nodeContentByTag(node, 'x-coord'));
     this.y = safeStrToInt(nodeContentByTag(node, 'y-coord'));
+    this.comments = xmlDecoded(nodeContentByTag(node, 'comments'));
     this.collapsed = nodeParameterValue(node, 'collapsed') === '1';
     this.ignore = nodeParameterValue(node, 'ignore') === '1';
     this.black_box = nodeParameterValue(node, 'black-box') === '1';
@@ -5468,8 +5550,8 @@ class Cluster extends NodeBox {
         name,
         actor;
         
-    // NOTE: to compensate for shameful bug in earlier version, look for
-    // "product-positions" node and for "notes" node in the process-set,
+    // NOTE: to compensate for a shameful bug in an earlier version, look
+    // for "product-positions" node and for "notes" node in the process-set,
     // as it may have been put there instead of in the cluster node itself
     const
         hidden_pp = childNodeByTag(n, 'product-positions'),
@@ -5649,13 +5731,19 @@ class Cluster extends NodeBox {
       addDistinct(this.product_positions[i].product, prods);
     }
     for(let i = 0; i < this.sub_clusters.length; i++) {
-      const ap = this.sub_clusters[i].allProducts; // recursion!
-      for(let j = 0; j < ap.length; j++) {
-        addDistinct(ap[j], prods);
-      }
+      mergeDistinct(this.sub_clusters[i].allProducts, prods); // recursion!
     }
     return prods;
   }
+  
+  get allNotes() {
+    // Return the set of all notes in this cluster and its subclusters
+    let notes = this.notes.slice();
+    for(let i = 0; i < this.sub_clusters.length; i++) {
+      notes = notes.concat(this.sub_clusters[i].allNotes); // recursion!
+    }
+    return notes;
+  }
 
   clearAllProcesses() {
     // Clear `all_processes` property of this cluster AND of all its parent clusters
@@ -6897,7 +6985,7 @@ class Process extends Node {
     // The production level in time T thus corresponds to decision variable
     // X[Math.floor((T-1) / PACE + 1]
     this.pace = 1;
-    this.pace_expression = new Expression(this, 'PACE', '1');
+    this.pace_expression = new Expression(this, 'LCF', '1');
     // NOTE: processes have NO input attributes other than LB, UB and IL
     // for processes, the default bounds are [0, +INF]
     this.equal_bounds = false;

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

@@ -256,8 +256,9 @@ function markFirstDifference(s1, s2) {
 //
 
 function ciCompare(a, b) {
-  // Performs case-insensitive comparison
-  return a.localeCompare(b, undefined, {sensitivity: 'base'});
+  // Performs case-insensitive comparison that does differentiate
+  // between accented characters (as this differentiates between identifiers)
+  return a.localeCompare(b, undefined, {sensitivity: 'accent'});
 }
 
 function endsWithDigits(str) {
@@ -439,6 +440,13 @@ function addDistinct(e, list) {
   if(list.indexOf(e) < 0) list.push(e);
 }
 
+function mergeDistinct(list, into) {
+  // Adds elements of `list` to `into` if not already in `into`
+  for(let i = 0; i < list.length; i++) {
+    addDistinct(list[i], into);
+  }
+}
+
 function setString(sl) {
   // Returns elements of stringlist `sl` in set notation
   return '{' + sl.join(', ') + '}';