linny-r 1.2.1 → 1.3.1

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

@@ -120,6 +120,9 @@ class LinnyRModel {
     // Set the indicator that the model has not been solved yet
     this.set_up = false;
     this.solved = false;
+    // Reset counts of effects of a rename operation
+    this.variable_count = 0;
+    this.expression_count = 0;
   }
   
   // NOTE: a model can also be the entity for the documentation manager,
@@ -557,7 +560,7 @@ class LinnyRModel {
   inferPrefix(obj) {
     // Return the inferred (!) prefixes of `obj` as a list
     if(obj) {
-      const pl = obj.displayName.split(UI.PREFIXER);
+      const pl = UI.prefixesAndName(obj.displayName);
       if(pl.length > 1) {
         pl.pop();
         return pl;
@@ -565,7 +568,7 @@ class LinnyRModel {
     }
     return [];
   }
-
+  
   inferParentCluster(obj) {
     // Find the best "parent" cluster for link or constraint `obj`
     let p, q;
@@ -633,6 +636,14 @@ class LinnyRModel {
     }
     return -1;
   }
+  
+  isDimensionSelector(s) {
+    // Returns TRUE if `s` is a dimension selector in some experiment
+    for(let i = 0; i < this.experiments.length; i++) {
+      if(this.experiments[i].isDimensionSelector(s)) return true;
+    }
+    return false;
+  }
 
   canLink(from, to) {
     // Return TRUE iff FROM-node can feature a "straight" link (i.e., a
@@ -915,7 +926,7 @@ class LinnyRModel {
       for(let i = 0; i < c.notes.length; i++) {
         const
             n = c.notes[i],
-            tags = n.contents.match(/\[\[[^\]]+\]\]/g);
+            tags = n.tagList;
         if(tags) {
           for(let i = 0; i < tags.length; i++) {
             const
@@ -1562,6 +1573,75 @@ class LinnyRModel {
     return true;
   }
   
+  get selectionAsXML() {
+    // Returns XML for the selected entities, and also for the entities
+    // referenced by expressions for their attributes.
+    // NOTE: the name and actor name of the focal cluster are added as
+    // attributes of the main node to permit "smart" renaming of
+    // entities when PASTE would result in name conflicts.
+    if(this.selection.length <= 0) return '';
+    const
+        fc_name = this.focal_cluster.name,
+        fc_actor = this.focal_cluster.actor.name,
+        entities = {
+          Cluster: [],
+          Link: [],
+          Constraint: [],
+          Note: [],
+          Product: [],
+          Process: []
+        },
+        extras = [],
+        from_tos = [],
+        xml = [],
+        ft_xml = [],
+        extra_xml = [];
+    for(let i = 0; i < this.selection.length; i++) {
+      const obj = this.selection[i];
+      entities[obj.type].push(obj);
+    }
+    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);
+    }
+    for(let i = 0; i < entities.Process.length; i++) {
+      xml.push(entities.Process[i].asXML);
+    }
+    for(let i = 0; i < entities.Cluster.length; i++) {
+      xml.push(entities.Cluster[i].asXML);
+    }
+    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);
+      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);
+      xml.push(c.asXML);
+    }
+    for(let i = 0; i < from_tos.length; i++) {
+      const p = from_tos[i];
+      ft_xml.push('<from-to type="', p.type, '" name="', xmlEncoded(p.name));
+      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);
+    return ['<copy timestamp="', Date.now(),
+        '" model-timestamp="', this.time_created.getTime(),
+        '" cluster-name="', xmlEncoded(fc_name),
+        '" cluster-actor="', xmlEncoded(fc_actor),
+        '"><entities>', xml.join(''),
+        '</entities><from-tos>', ft_xml.join(''),
+        '</from-tos><extras>', extra_xml.join(''),
+        '</extras></copy>'].join('');
+  }
+  
   dropSelectionIntoCluster(c) {
     // Move all selected nodes to cluster `c`
     let n = 0,
@@ -2024,46 +2104,74 @@ class LinnyRModel {
       }
     }
   }
+
+  get datasetVariables() {
+    // Returns list with all ChartVariable objects in this model that
+    // reference a regular dataset, i.e., not an equation
+    const vl = [];
+    for(let i = 0; i < MODEL.charts.length; i++) {
+      const c = MODEL.charts[i];
+      for(let j = 0; j < c.variables.length; j++) {
+        const v = c.variables[j];
+        if(v.object instanceof Dataset &&
+            v.object !== MODEL.equations_dataset) vl.push(v);
+      }
+    }
+    return vl;
+  }
+  
+  get notesWithTags() {
+    // Returns a list with all notes having tags [[...]] in this model
+    const nl = [];
+    for(let k in this.clusters) if(this.clusters.hasOwnProperty(k)) {
+      const c = this.clusters[k];
+      for(let i = 0; i < c.notes.length; i++) {
+        const n = c.notes[i];
+        if(n.tagList) nl.push(n);
+      }
+    }
+    return nl;
+  }
   
   get allExpressions() {
-    // Returns list of all Expression objects
+    // Returns list of all Expression objects in this model
     // NOTE: start with dataset expressions, so that when recompiling
     // their `level-based` property is set before recompiling the
     // other expressions
-    const x = [];
+    const xl = [];
     for(let k in this.datasets) if(this.datasets.hasOwnProperty(k)) {
       const ds = this.datasets[k];
       // NOTE: dataset modifier expressions include the equations
       for(let m in ds.modifiers) if(ds.modifiers.hasOwnProperty(m)) {
-        x.push(ds.modifiers[m].expression);
+        xl.push(ds.modifiers[m].expression);
       }
     }
     for(let k in this.actors) if(this.actors.hasOwnProperty(k)) {
-      x.push(this.actors[k].weight);
+      xl.push(this.actors[k].weight);
     }
     for(let k in this.processes) if(this.processes.hasOwnProperty(k)) {
       const p = this.processes[k];
-      x.push(p.lower_bound, p.upper_bound, p.initial_level, p.pace_expression);
+      xl.push(p.lower_bound, p.upper_bound, p.initial_level, p.pace_expression);
     }
     for(let k in this.products) if(this.products.hasOwnProperty(k)) {
       const p = this.products[k];
-      x.push(p.lower_bound, p.upper_bound, p.initial_level, p.price);
+      xl.push(p.lower_bound, p.upper_bound, p.initial_level, p.price);
     }
     for(let k in this.clusters) if(this.clusters.hasOwnProperty(k)) {
       const c = this.clusters[k];
       for(let i = 0; i < c.notes.length; i++) {
         const n = c.notes[i];
-        x.push(n.color);
+        xl.push(n.color);
       }
     }
     for(let k in this.links) if(this.links.hasOwnProperty(k)) {
       const l = this.links[k];
-      x.push(l.relative_rate, l.flow_delay);
+      xl.push(l.relative_rate, l.flow_delay);
     }
-    return x;
+    return xl;
   }
 
-  replaceEntityInExpressions(en1, en2) {
+  replaceEntityInExpressions(en1, en2, notify=true) {
     // Replace entity name `en1` by `en2` in all variables in all expressions
     // (provided that they are not identical)
     if(en1 === en2) return;
@@ -2089,8 +2197,12 @@ class LinnyRModel {
       }
     }
     if(ioc.replace_count) {
-      UI.notify(`Renamed ${pluralS(ioc.replace_count, 'variable')} in ` +
-          pluralS(ioc.expression_count, 'expression'));
+      this.variable_count += ioc.replace_count;
+      this.expression_count += ioc.expression_count; 
+      if(notify) {
+        UI.notify(`Renamed ${pluralS(ioc.replace_count, 'variable')} in ` +
+            pluralS(ioc.expression_count, 'expression'));
+      }
     }
     // Also rename entities in parameters and outcomes of sensitivity analysis
     for(let i = 0; i < this.sensitivity_parameters.length; i++) {
@@ -2125,8 +2237,8 @@ class LinnyRModel {
     const
         en = escapeRegex(ena[0].trim().replace(/\s+/g, ' ').toLowerCase()),
         at = ena[1].trim(),
-        raw = en.replace(/\s/, `\s+`) + `\s*\|\s*` + escapeRegex(at),
-        re = new RegExp(`\[\s*${raw}\s*(\@[^\]]+)?\s*\]`, 'gi');
+        raw = en.replace(/\s/, '\\s+') + '\\s*\\|\\s*' + escapeRegex(at),
+        re = new RegExp(String.raw`\[\s*${raw}\s*(\@[^\]]+)?\s*\]`, 'gi');
     // Count replacements made
     let n = 0;
     // Iterate over all expressions
@@ -4470,12 +4582,17 @@ class Note extends ObjectWithXYWH {
     }
   }
   
+  get tagList() {
+    // Returns a list of matches for [[...]], or NULL if none
+    return this.contents.match(/\[\[[^\]]+\]\]/g);
+  }
+  
   parseFields() {
     // Fills the list of fields by parsing all [[...]] tags in the text
     // NOTE: this does not affect the text itself; tags will be replaced
     // by numerical values only when drawing the note
     this.fields.length = 0;
-    const tags = this.contents.match(/\[\[[^\]]+\]\]/g);
+    const tags = this.tagList;
     if(tags) {
       for(let i = 0; i < tags.length; i++) {
         const
@@ -4582,7 +4699,7 @@ class Note extends ObjectWithXYWH {
     // Return a list with names of entities used in fields
     const
         fel = [],
-        tags = this.contents.match(/\[\[[^\]]+\]\]/g);
+        tags = this.tagList;
     for(let i = 0; i < tags.length; i++) {
       const
           tag = tags[i],
@@ -4606,7 +4723,7 @@ class Note extends ObjectWithXYWH {
     if(en1 === en2) return;
     const
         raw = en1.split(/\s+/).join('\\\\s+'),
-        re = new RegExp('\\[\\[\\s*' + raw + '\\s*(\\->|\\||\\])', 'g'),
+        re = new RegExp('\\[\\[\\s*' + raw + '\\s*(\\->|\\||\\])', 'gi'),
         tags = this.contents.match(re);
     if(tags) {
       for(let i = 0; i < tags.length; i++) {
@@ -4773,7 +4890,7 @@ class NodeBox extends ObjectWithXYWH {
     // and products this is the string of trailing digits (or empty if none)
     // of the node name, or if that does not end with a number, the trailing
     // digits of the first prefix (from right to left) that does
-    const sn = this.name.split(UI.PREFIXER);
+    const sn = UI.prefixesAndName(this.name);
     let nc = endsWithDigits(sn.pop());
     while(!nc && sn.length > 0) {
       nc = endsWithDigits(sn.pop());
@@ -7852,7 +7969,7 @@ class Dataset {
   
   get numberContext() {
     // Returns the string to be used to evaluate # (empty string if undefined)
-    const sn = this.name.split(UI.PREFIXER);
+    const sn = UI.prefixesAndName(this.name);
     let nc = endsWithDigits(sn.pop());
     while(!nc && sn.length > 0) {
       nc = endsWithDigits(sn.pop());
@@ -7887,6 +8004,27 @@ class Dataset {
     return true;
   }
   
+  get inferPrefixableModifiers() {
+    // Returns list of dataset modifiers with expressions that do not
+    // reference any variable and hence could probably better be represented
+    // by a prefixed dataset having the expression value as its default
+    const pml = [];
+    if(this !== this.equations_dataset) {
+      const sl = this.plainSelectors;
+      for(let i = 0; i < sl.length; i++) {
+        if(!MODEL.isDimensionSelector(sl[i])) {
+          const
+              m = this.modifiers[sl[i].toLowerCase()],
+              x = m.expression;
+          // Static expressions without variables can also be used
+          // as dataset default value
+          if(x.isStatic && x.text.indexOf('[') < 0) pml.push(m);
+        }
+      }
+    }
+    return pml;
+  }
+
   get timeStepDuration() {
     // Returns duration of 1 time step on the time scale of this dataset
     return this.time_scale * VM.time_unit_values[this.time_unit];
@@ -8055,11 +8193,11 @@ class Dataset {
     }
     if(this.default_selector) {
       // If no experiment (so "normal" run), use default selector if specified
-      const dm = this.modifiers[this.default_selector];
+      const dm = this.modifiers[UI.nameToID(this.default_selector)];
       if(dm) return dm.expression;
       // Exception should never occur, but check anyway and log it 
       console.log('WARNING: Dataset "' + this.name +
-          `" has no default selector "${this.default_selector}"`);
+          `" has no default selector "${this.default_selector}"`, this.modifiers);
     }
     // Fall-through: return vector instead of expression
     return this.vector;
@@ -8186,15 +8324,17 @@ class Dataset {
       }
     }
     const ds = xmlDecoded(nodeContentByTag(node, 'default-selector'));
-    if(ds && !this.modifiers[ds]) {
+    if(ds && !this.modifiers[UI.nameToID(ds)]) {
       UI.warn(`Dataset <tt>${this.name}</tt> has no selector <tt>${ds}</tt>`);
     } else {
       this.default_selector = ds;      
     }
   }
   
-  rename(name) {
+  rename(name, notify=true) {
     // Change the name of this dataset
+    // When `notify` is FALSE, notifications are suppressed while the
+    // number of affected datasets and expressions are counted
     // NOTE: prevent renaming the equations dataset (just in case...)
     if(this === MODEL.equations_dataset) return;
     name = UI.cleanName(name);
@@ -8214,7 +8354,7 @@ class Dataset {
     this.name = name;
     MODEL.datasets[new_id] = this;
     if(old_id !== new_id) delete MODEL.datasets[old_id];
-    MODEL.replaceEntityInExpressions(old_name, name);
+    MODEL.replaceEntityInExpressions(old_name, name, notify);
     return MODEL.datasets[new_id];
   }
   
@@ -9687,7 +9827,7 @@ class ExperimentRunResult {
     return ['<run-result', (this.x_variable ? ' x-variable="1"' : ''),
       (this.was_ignored ? ' ignored="1"' : ''),
       '><object-id>', xmlEncoded(this.object_id),
-      '</object-id><attribute>', this.attribute,
+      '</object-id><attribute>', xmlEncoded(this.attribute),
       '</attribute><count>', this.N,
       '</count><sum>', this.sum,
       '</sum><mean>', this.mean,
@@ -9705,7 +9845,12 @@ class ExperimentRunResult {
     this.x_variable = nodeParameterValue(node, 'x-variable') === '1';
     this.was_ignored = nodeParameterValue(node, 'ignored') === '1';
     this.object_id = xmlDecoded(nodeContentByTag(node, 'object-id'));
-    this.attribute = nodeContentByTag(node, 'attribute');
+    // NOTE: special check to guarantee upward compatibility to version
+    // 1.3.0 and higher
+    let attr = nodeContentByTag(node, 'attribute');
+    if(this.object_id === UI.EQUATIONS_DATASET_ID &&
+        !earlierVersion(MODEL.version, '1.3.0')) attr = xmlDecoded(attr);
+    this.attribute = attr;
     this.N = safeStrToInt(nodeContentByTag(node, 'count'));
     this.sum = safeStrToFloat(nodeContentByTag(node, 'sum'));
     this.mean = safeStrToFloat(nodeContentByTag(node, 'mean'));
@@ -10136,6 +10281,17 @@ class Experiment {
     return index;
   }
   
+  isDimensionSelector(s) {
+    // Returns TRUE if `s` is a dimension selector in this experiment
+    for(let i = 0; i < this.dimensions.length; i++) {
+      if(this.dimensions[i].indexOf(s) >= 0) return true;
+    }
+    if(this.settings_selectors.indexOf(s) >= 0) return true;
+    if(this.combination_selectors.indexOf(s) >= 0) return true;
+    if(this.actor_selectors.indexOf(s) >= 0) return true;
+    return false;
+  }
+  
   get asXML() {
     let d = '';
     for(let i = 0; i < this.dimensions.length; i++) {

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

@@ -65,8 +65,11 @@ function pluralS(n, s, special='') {
 function safeStrToFloat(str, val=0) {
   // Returns numeric value of floating point string, interpreting both
   // dot and comma as decimal point
-  // NOTE: returns default value val if str is empty, null or undefined
-  const f = (str ? parseFloat(str.replace(',', '.')) : val);
+  // NOTE: returns default value `val` if `str` is empty, null or undefined,
+  // or contains a character that is invalid in a number 
+  if(!str || str.match(/[^0-9eE\.\,\+\-]/)) return val;
+  str = str.replace(',', '.');
+  const f = (str ? parseFloat(str) : val);
   return (isNaN(f) ? val : f);
 }
 
@@ -186,6 +189,20 @@ function ellipsedText(text, n=50, m=10) {
 // Functions used when comparing two Linny-R models
 //
 
+function earlierVersion(v1, v2) {
+  // Compares two version numbers and returns TRUE iff `v1` is earlier
+  // than `v2`
+  v1 = v1.split('.');
+  v2 = v2.split('.');
+  for(let i = 0; i < Math.min(v1.length, v2.length); i++) {
+    // NOTE: for legacy JS models, the major version number evaluates as 0
+    if(safeStrToInt(v1[i]) < safeStrToInt(v2[i])) return true;
+    if(safeStrToInt(v1[i]) > safeStrToInt(v2[i])) return false;
+  }
+  // Fall-through: same version numbers => NOT earlier
+  return false;
+}
+
 function differences(a, b, props) {
   // Compares values of properties (in list `props`) of entities `a` and `b`,
   // and returns a "dictionary" object with differences
@@ -310,18 +327,34 @@ function patternList(str) {
 
 function patternMatch(str, patterns) {
   // Returns TRUE when `str` matches the &|^-pattern
+  // NOTE: if a pattern starts with equals sign = then `str` must
+  // equal the rest of the pattern to match; if it starts with a tilde
+  // ~ then `str` must start with the rest of the pattern to match 
   for(let i = 0; i < patterns.length; i++) {
     const p = patterns[i];
-    let match = true;
+    let pm,
+        match = true;
     for(let j = 0; j < p.plus.length; j++) {
-      match = match && str.indexOf(p.plus[j]) >= 0;
+      pm = p.plus[j];
+      if(pm.startsWith('=')) {
+        match = match && str === pm.substring(1);
+      } else if(pm.startsWith('~')) {
+        match = match && str.startsWith(pm.substring(1));
+      } else {
+        match = match && str.indexOf(pm) >= 0;
+      }
     }
     for(let j = 0; j < p.min.length; j++) {
-      match = match && str.indexOf(p.min[j]) < 0;
-    }
-    if(match) {
-      return true;
+      pm = p.min[j];
+      if(pm.startsWith('=')) {
+        match = match && str !== pm.substring(1);
+      } else if(pm.startsWith('~')) {
+        match = match && !str.startsWith(pm.substring(1));
+      } else {
+        match = match && str.indexOf(pm) < 0;
+      }
     }
+    if(match) return true;
   }
   return false;
 }
@@ -508,9 +541,9 @@ function childNodeByTag(node, tag) {
   // Returns the XML child node of `node` having node name `tag`, or NULL if
   // no such child node exists
   let cn = null;
-  for (let i = 0; i < node.children.length; i++) {
-    if(node.children[i].tagName === tag) {
-      cn = node.children[i];
+  for (let i = 0; i < node.childNodes.length; i++) {
+    if(node.childNodes[i].tagName === tag) {
+      cn = node.childNodes[i];
       break;
     }
   }
@@ -745,16 +778,21 @@ if(NODE) module.exports = {
   pluralS: pluralS,
   safeStrToFloat: safeStrToFloat,
   safeStrToInt: safeStrToInt,
+  rangeToList: rangeToList,
   dateToString: dateToString,
   msecToTime: msecToTime,
   uniformDecimals: uniformDecimals,
   ellipsedText: ellipsedText,
+  earlierVersion: earlierVersion,
   differences: differences,
   markFirstDifference: markFirstDifference,
+  ciCompare: ciCompare,
   endsWithDigits: endsWithDigits,
   indexOfMatchingBracket: indexOfMatchingBracket,
   patternList: patternList,
   patternMatch: patternMatch,
+  compareSelectors: compareSelectors,
+  stringToFloatArray: stringToFloatArray,
   escapeRegex: escapeRegex,
   addDistinct: addDistinct,
   setString: setString,

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

@@ -12,7 +12,7 @@ executed by the VM, construct the Simplex tableau that can be sent to the
 MILP solver.
 */
 /*
-Copyright (c) 2017-2022 Delft University of Technology
+Copyright (c) 2017-2023 Delft University of Technology
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -834,7 +834,7 @@ class ExpressionParser {
         return [stat, list, anchor1, offset1, anchor2, offset2];
       }
       this.error = `No entities that match pattern "${patstr}"` +
-          (attr ? ' and have attribute ' + attr : '');
+          (attr ? ' and have attribute ' + attr : ' when no attribute is specified');
       return false;
     }
     
@@ -1428,6 +1428,8 @@ class VirtualMachine {
     this.lines = '';
     // String specifying a numeric issue (empty if none)
     this.numeric_issue = '';
+    // Warnings are stored in a list to permit browsing through them
+    this.issue_list = [];
     // The call stack tracks evaluation of "nested" expression variables
     this.call_stack = [];
     this.block_count = 0;
@@ -1553,6 +1555,9 @@ class VirtualMachine {
       this.ERROR, this.CYCLIC, this.DIV_ZERO, this.BAD_CALC, this.ARRAY_INDEX,
       this.BAD_REF, this.UNDERFLOW, this.OVERFLOW, this.INVALID, this.PARAMS,
       this.UNKNOWN_ERROR, this.UNDEFINED, this.NOT_COMPUTED, this.COMPUTING];
+    
+    // Prefix for warning messages that are logged in the monitor
+    this.WARNING = '-- Warning: ';
 
     // Solver constants indicating constraint type
     // NOTE: these correspond to the codes used by LP_solve; when generating
@@ -1695,6 +1700,10 @@ class VirtualMachine {
     // Initialize error counters (error count will be reset to 0 for each block)
     this.error_count = 0;
     this.block_issues = 0;
+    // Clear issue list with warnings and hide issue panel
+    this.issue_list.length = 0;
+    this.issue_index = -1;
+    UI.updateIssuePanel();
     // NOTE: special tracking of potential solver license errors
     this.license_expired = 0;
     // Reset solver result arrays
@@ -2085,6 +2094,10 @@ class VirtualMachine {
       this.messages[block - 1] = '';
     }
     this.messages[block - 1] += msg + '\n';
+    if(msg.startsWith(this.WARNING)) {
+      this.error_count++;
+      this.issue_list.push(msg);
+    }
     // Show message on console or in Monitor dialog
     MONITOR.logMessage(block, msg);
   }
@@ -2125,7 +2138,7 @@ class VirtualMachine {
       MONITOR.updateContent('msg');
     }
   }
-
+  
   startTimer() {
     // Record time of this reset
     this.reset_time = new Date().getTime();
@@ -3627,14 +3640,12 @@ class VirtualMachine {
         a.cash_flow[b] = a.cash_in[b] - a.cash_out[b];
         // Count occurrences of a negative cash flow (threshold -0.5 cent)
         if(a.cash_in[b] < -0.005) {
-          this.logMessage(block, `-- Warning: (t=${b}${round}) ` +
+          this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
               a.displayName + ' cash IN = ' + a.cash_in[b].toPrecision(2));
-          this.error_count++;
         }
         if(a.cash_out[b] < -0.005) {
-          this.logMessage(block, `-- Warning: (t=${b}${round}) ` +
+          this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
               a.displayName + ' cash IN = ' + a.cash_out[b].toPrecision(2));
-          this.error_count++;
         }
         // Advance column offset in tableau by the # cols per time step
         j += this.cols;
@@ -3754,7 +3765,7 @@ class VirtualMachine {
                 v[1].constraint.slack_info[b] = v[0];
               }
               if(absl > VM.SIG_DIF_FROM_ZERO) {
-                this.logMessage(block, `-- Warning: (t=${b}${round}) ` +
+                this.logMessage(block, `${this.WARNING}(t=${b}${round}) ` +
                     `${v[1].displayName} ${v[0]} slack = ${this.sig4Dig(slack)}`);
                 if(v[1] instanceof Product) {
                   const ppc = v[1].productPositionClusters;
@@ -3762,7 +3773,6 @@ class VirtualMachine {
                     ppc[ci].usesSlack(b, v[1], v[0]);
                   }
                 }
-                this.error_count++;
               } else if(CONFIGURATION.slight_slack_notices) {
                 this.logMessage(block, '-- Notice: (t=' + b + round + ') ' +
                    v[1].displayName + ' ' + v[0] + ' slack = ' +
@@ -3932,9 +3942,8 @@ class VirtualMachine {
       b = bb;
       for(let i = 0; i < this.chunk_length; i++) {
         if(!MODEL.calculateCostPrices(b)) {
-          this.logMessage(block, '-- Warning: (t=' + b +
-              ') Invalid cost prices due to negative flow(s)');
-          this.error_count++;
+          this.logMessage(block, `${this.WARNING}(t=${b}) ` +
+              'Invalid cost prices due to negative flow(s)');
         }
         // move to the next time step of the block
         b++;
@@ -4729,9 +4738,11 @@ Solver status = ${json.status}`);
       // If experiment is active, signal the manager
       if(MODEL.running_experiment) EXPERIMENT_MANAGER.processRun();
       // Warn modeler if any issues occurred
-      if(this.block_issues) UI.warn('Issues occurred in ' +
-          pluralS(this.block_issues, 'block') +
-          ' -- check messages in monitor');
+      if(this.block_issues) {
+        UI.warn('Issues occurred in ' + pluralS(this.block_issues, 'block') +
+          ' -- details can be viewed in the monitor and by using \u25C1 \u25B7');
+        UI.updateIssuePanel();
+      }
       if(this.license_expired > 0) {
         // Special message to draw attention to this critical error
         UI.alert('SOLVER LICENSE EXPIRED: Please check!');
@@ -4845,11 +4856,12 @@ Solver status = ${json.status}`);
         return;
       } else {
         // Wait no longer, but warn user that data may be incomplete
-        dsl = [];
+        const dsl = [];
         for(let i = 0; i < MODEL.loading_datasets.length; i++) {
           dsl.push(MODEL.loading_datasets[i].displayName);
         }
-        UI.warn(`Loading datasets (${dsl.join(', ')}) takes too long`);
+        UI.warn('Loading of ' + pluralS(dsl.length, 'dataset') + ' (' +
+            dsl.join(', ') + ') takes too long');
       }
     }
     if(MONITOR.connectToServer()) {
@@ -5189,15 +5201,15 @@ function relativeTimeStep(t, anchor, offset, dtm, x) {
   }
   if(anchor === 'c') {
     // Relative to start of current optimization block
-    return VM.block_start + offset;
+    return Math.trunc(t / MODEL.block_length) * MODEL.block_length + offset;
   }
   if(anchor === 'p') {
     // Relative to start of previous optimization block
-    return VM.block_start - MODEL.block_length + offset;
+    return (Math.trunc(t / MODEL.block_length) - 1) * MODEL.block_length + offset;
   }
   if(anchor === 'n') {
     // Relative to start of next optimization block
-    return VM.block_start + MODEL.block_length + offset;
+    return (Math.trunc(t / MODEL.block_length) + 1) * MODEL.block_length + offset;
   }
   if(anchor === 'l') {
     // Last: offset relative to the last index in the vector