linny-r 1.1.12 → 1.1.14

package/package.json

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

package/static/linny-r.css

@@ -2168,8 +2168,8 @@ td.equation-expression {
 
 /* SERIES modal dialog */
 #series-dlg {
-  width: 156px;
-  height: 282px;
+  width: 165px;
+  height: 320px;
 }
 
 #series-default-lbl {
@@ -2182,7 +2182,7 @@ td.equation-expression {
   position: absolute;
   top: 24px;
   left: 79px;
-  width: 73px;
+  width: calc(100% - 83px);
   font-size: 12px;
   margin-bottom: 2px;
 }
@@ -2202,13 +2202,13 @@ td.equation-expression {
 #series-array {
   position: absolute;
   top: 45px;
-  left: 90px; 
+  left: 77px; 
 }
 
 #series-array-lbl {
   position: absolute;
   top: 47px;
-  left: 112px;  
+  left: 99px;  
 }
 
 #series-no-time-msg {
@@ -2216,7 +2216,7 @@ td.equation-expression {
   top: 66px;
   left: 1px;
   width: calc(100% - 2px);
-  height: 27px;
+  height: 30px;
   z-index: 1;
   background-color: inherit;
   font-style: italic;
@@ -2235,7 +2235,7 @@ td.equation-expression {
   position: absolute;
   top: 67px;
   left: 60px;
-  width: 43px;
+  width: 50px;
   font-size: 12px;
   margin-bottom: 2px;
 }
@@ -2243,7 +2243,7 @@ td.equation-expression {
 #series-time-unit {
   position: absolute;
   top: 67px;
-  left: 108px;
+  left: 116px;
   height: 19px;
   width: 45px;
   font-size: 12px;
@@ -2251,40 +2251,43 @@ td.equation-expression {
 
 #series-method-lbl {
   position: absolute;
-  top: 90px;
+  top: 91px;
   left: 2px;
 }
 
 #series-method {
   position: absolute;
-  top: 88px;
-  left: 49px;
-  height: 19px;
-  width: 105px;
-  font-size: 11px;
+  top: 89px;
+  left: 50px;
+  height: 21px;
+  width: 111px;
+  font-size: 12px;
 }
 
 #series-remote {
   position: absolute;
-  top: 110px;
-  left: 2px;  
+  top: 113px;
+  left: 3px;
+  width: calc(100% - 8px);
 }
 
 #series-url {
-  width: 150px;
+  width: 100%;
   font-size: 12px;
 }
 
 #series-data-lbl {
   position: absolute;
-  top: 129px;
+  top: 133px;
   left: 2px;
 }
 
 #series-data {
-  width: 150px;
-  height: 120px;
-  margin: 125px 3px;
+  position: absolute;
+  bottom: 13px;
+  width: calc(100% - 6px);
+  height: calc(100% - 165px);
+  margin: 3px;
 }
 
 #series-line {

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

@@ -140,7 +140,7 @@ class Controller {
         'scale_unit', 'equal_bounds', 'price', 'is_source', 'is_sink', 'is_buffer',
         'is_data', 'integer_level', 'no_slack'],
       DATASET_PROPS: ['comments', 'default_value', 'time_scale', 'time_unit',
-        'method', 'periodic', 'array', 'url'],
+        'method', 'periodic', 'array', 'url', 'default_selector'],
       LINK_PROPS: ['comments', 'multiplier', 'relative_rate', 'share_of_cost',
         'flow_delay'],
       CONSTRAINT_PROPS: ['comments', 'no_slack', 'share_of_cost'],

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

@@ -1471,7 +1471,7 @@ class Paper {
         // achieved by multiplying the "gap" being (lengths - heights)/2 by
         // (1 - |dy/l|). NOTE: we re-use the values of `th` and `tw`
         // computed in the previous block!
-        shift += th/2;
+        shift += th / 2;
         s = VM.sig4Dig(luc.share_of_cost * 100) + '%';
         bb = this.numberSize(s, 7);
         const sgap = (tw + bb.width + 3 - th - bb.height) / 2; 
@@ -1631,7 +1631,8 @@ class Paper {
           if(cp <= VM.MINUS_INFINITY || cp >= VM.PLUS_INFINITY) {
             s = VM.sig4Dig(cp);
           } else if(Math.abs(cp) <= VM.SIG_DIF_FROM_ZERO) {
-            s = '0';
+            // DO not display CP when it is "propagated" NO_COST
+            s = (cp === VM.NO_COST ? '' : '0');
           } else {
             // NOTE: use the absolute value of the flow, as cost is not affected by direction
             s = VM.sig4Dig(Math.abs(af) * soc * cp);
@@ -8832,7 +8833,7 @@ class GUIDatasetManager extends DatasetManager {
       if(d === sd) sdid += i;
       dl.push(['<tr id="dstr', i, '" class="dataset',
           (d === sd ? ' sel-set' : ''),
-          '" onclick="DATASET_MANAGER.selectDataset(\'',
+          '" onclick="DATASET_MANAGER.selectDataset(event, \'',
           dnl[i], '\');" onmouseover="DATASET_MANAGER.showInfo(\'', dnl[i],
           '\', event.shiftKey);"><td', cls, '>', d.displayName,
           '</td></tr>'].join(''));
@@ -8906,14 +8907,19 @@ class GUIDatasetManager extends DatasetManager {
     for(let i = 0; i < msl.length; i++) {
       const
           m = sd.modifiers[UI.nameToID(msl[i])],
-          clk = '" onclick="DATASET_MANAGER.selectModifier(\'' +
+          defsel = (m.selector === sd.default_selector),
+          clk = '" onclick="DATASET_MANAGER.selectModifier(event, \'' +
               m.selector + '\'';
       if(m === sm) smid += i;
       ml.push(['<tr id="dsmtr', i, '" class="dataset-modif',
           (m === sm ? ' sel-set' : ''),
           '"><td class="dataset-selector',
           (m.hasWildcards ? ' wildcard' : ''),
+          '" title="Shift-click to ', (defsel ? 'clear' : 'set as'),
+          ' default modifier',
           clk, ', false);">',
+          (defsel ? '<img src="images/solve.png" style="height: 14px;' +
+              ' width: 14px; margin: 0 1px -3px -1px;">' : ''),
           m.selector, '</td><td class="dataset-expression',
           clk, ');">', m.expression.text, '</td></tr>'].join(''));
     }
@@ -8960,46 +8966,54 @@ class GUIDatasetManager extends DatasetManager {
     this.updateDialog();
   }
   
-  selectDataset(id) {
-    // Select dataset, or edit it when double-clicked
+  selectDataset(event, id) {
+    // Select dataset, or edit it when Alt- or double-clicked
     const
-        d = MODEL.datasets[id],
+        d = MODEL.datasets[id] || null,
         now = Date.now(),
-        dt = now - this.last_time_selected;
+        dt = now - this.last_time_selected,
+        // Consider click to be "double" if it occurred less than 300 ms ago
+        edit = event.altKey || (d === this.selected_dataset && dt < 300);
+    this.selected_dataset = d;
     this.last_time_selected = now;
-    if(d === this.selected_dataset) {
-      // Consider click to be "double" if it occurred less than 300 ms ago
-      if(dt < 300) {
-        this.last_time_selected = 0;
-        this.editData();
-        return;
-      }
+    if(d && edit) {
+      this.last_time_selected = 0;
+      this.editData();
+      return;
     }
-    this.selected_dataset = MODEL.datasets[id];
     this.updateDialog();
   }
   
-  selectModifier(id, x=true) {
+  selectModifier(event, id, x=true) {
     // Select modifier, or when double-clicked, edit its expression or the
     // name of the modifier
     if(this.selected_dataset) {
       const m = this.selected_dataset.modifiers[UI.nameToID(id)],
             now = Date.now(),
-            dt = now - this.last_time_selected;
+            dt = now - this.last_time_selected,
+            // NOTE: Alt-click and double-click indicate: edit
+            // Consider click to be "double" if the same modifier was clicked
+            // less than 300 ms ago
+            edit = event.altKey || (m === this.selected_modifier && dt < 300);
       this.last_time_selected = now;
-      if(m === this.selected_modifier) {
-        // Consider click to be "double" if it occurred less than 300 ms ago
-        if(dt < 300) {
-          this.last_time_selected = 0;
-          if(x) {
-            this.editExpression();
-          } else {
-            this.promptForSelector('rename');
-          }
-          return;
+      if(event.shiftKey) {
+        // Toggle dataset default selector
+        if(m.selector === this.selected_dataset.default_selector) {
+          this.selected_dataset.default_selector = '';
+        } else {
+          this.selected_dataset.default_selector = m.selector;
         }
       }
       this.selected_modifier = m;
+      if(edit) {
+        this.last_time_selected = 0;
+        if(x) {
+          this.editExpression();
+        } else {
+          this.promptForSelector('rename');
+        }
+        return;
+      }
     } else {
       this.selected_modifier = null;
     }
@@ -9166,6 +9180,10 @@ class GUIDatasetManager extends DatasetManager {
         m = this.selected_dataset.addModifier(sel);
     // NULL can result when new name is invalid
     if(!m) return;
+    // If selected modifier was the dataset default selector, update it
+    if(oldm.selector === this.selected_dataset.default_selector) {
+      this.selected_dataset.default_selector = m.selector;
+    }
     // If only case has changed, just update the selector
     // NOTE: normal dataset selector, so remove all invalid characters
     if(m === oldm) {
@@ -9247,8 +9265,14 @@ class GUIDatasetManager extends DatasetManager {
   }
 
   deleteModifier() {
+    // Delete modifier from selected dataset
     const m = this.selected_modifier;
     if(m) {
+      // If it was the dataset default modifier, clear the default
+      if(m.selector === this.selected_dataset.default_selector) {
+        this.selected_dataset.default_selector = '';
+      }
+      // Then simply remove the object
       delete this.selected_dataset.modifiers[UI.nameToID(m.selector)];
       this.selected_modifier = null;
       this.updateModifiers();
@@ -9417,7 +9441,7 @@ class EquationManager {
       const
           m = ed.modifiers[UI.nameToID(msl[i])],
           mp = (m.parameters ? '\\' + m.parameters.join('\\') : ''),
-          clk = '" onclick="EQUATION_MANAGER.selectModifier(\'' +
+          clk = '" onclick="EQUATION_MANAGER.selectModifier(event, \'' +
               m.selector + '\'';
       if(m === sm) smid += i;
       ml.push(['<tr id="eqmtr', i, '" class="dataset-modif',
@@ -9443,28 +9467,27 @@ class EquationManager {
     // @@TO DO: Display documentation for the equation => extra comments field?
   }
   
-  selectModifier(id, x=true) {
-    // Select modifier, or when double-clicked, edit its expression or the
-    // name of the modifier
+  selectModifier(event, id, x=true) {
+    // Select modifier, or when Alt- or double-clicked, edit its expression
+    // or the equation name (= name of the modifier)
     if(MODEL.equations_dataset) {
       const
-          m = MODEL.equations_dataset.modifiers[UI.nameToID(id)],
+          m = MODEL.equations_dataset.modifiers[UI.nameToID(id)] || null,
           now = Date.now(),
-          dt = now - this.last_time_selected;
+          dt = now - this.last_time_selected,
+          // Consider click to be "double" if it occurred less than 300 ms ago
+          edit = event.altKey || (m === this.selected_modifier && dt < 300);
       this.last_time_selected = now;
-      if(m === this.selected_modifier) {
-        // Consider click to be "double" if it occurred less than 300 ms ago
-        if(dt < 300) {
-          this.last_time_selected = 0;
-          if(x) {
-            this.editEquation();
-          } else {
-            this.promptForName();
-          }
-          return;
+      this.selected_modifier = m;
+      if(m && edit) {
+        this.last_time_selected = 0;
+        if(x) {
+          this.editEquation();
+        } else {
+          this.promptForName();
         }
+        return;
       }
-      this.selected_modifier = m;
     } else {
       this.selected_modifier = null;
     }

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

@@ -168,15 +168,6 @@ class LinnyRModel {
     return olist;
   }
   
-  get legacyVersion() {
-    // Return TRUE if the model as it has been loaded was not saved by
-    // JavaScript Linny-R
-    const
-        vnl = this.version.split('.'),
-        legacy = vnl[0] === '0' || (vnl[0] === '1' && vnl.length > 3);
-    return legacy;
-  }
-  
   get newProcessCode() {
     // Return the next unused process code
     const n = this.next_process_number;
@@ -1994,6 +1985,15 @@ class LinnyRModel {
     // 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 
+    this.legacy_datasets = false;
     if(!IO_CONTEXT) {
       this.reset();
       this.next_process_number = safeStrToInt(
@@ -2019,8 +2019,8 @@ class LinnyRModel {
       this.timeout_period = Math.max(0,
           safeStrToInt(nodeContentByTag(node, 'timeout-period')));
       // Legacy models have tag "optimization-period" instead of "block-length"
-      const bl_tag = (this.legacyVersion ?
-          'optimization-period' : 'block-length');
+      const bl_tag = nodeContentByTag(node, 'block-length') ||
+          nodeContentByTag(node, 'optimization-period'); 
       this.block_length = Math.max(1,
           safeStrToInt(nodeContentByTag(node, bl_tag)));
       this.start_period = Math.max(1,
@@ -2177,7 +2177,7 @@ class LinnyRModel {
     }
     // Clear the default (empty) equations dataset, or it will block adding it
     if(!IO_CONTEXT) {
-      this.datasets = {};
+      if(!this.legacy_datasets) this.datasets = {};
       this.equations_dataset = null;
     }
     // NOTE: keep track of datasets that load from URL or file
@@ -2322,7 +2322,7 @@ class LinnyRModel {
       // NOTE: links in legacy Linny-R models by default have 100% share-of-cost;
       // to minimize conversion effort, set SoC for SINGLE links OUT of processes
       // to 100%
-      if(this.legacyVersion) {
+      if(legacy_model) {
         for(let l in this.links) if(this.links.hasOwnProperty(l)) {
           l = this.links[l];
           // NOTE: preserve non-zero SoC values, as these have been specified
@@ -2707,6 +2707,36 @@ class LinnyRModel {
         links = [],
         constraints = [],
         can_calculate = true;
+    const
+        // NOTE: define local functions as constants
+        costAffectingConstraints = (p) => {
+            // Returns number of relevant contraints (see below) that
+            // can affect the cost price of product or process `p`
+            let n = 0;
+            for(let i = 0; i < constraints.length; i++) {
+              const c = constraints[i];
+              if((c.to_node === p && c.soc_direction === VM.SOC_X_Y) ||
+                  (c.from_node === p && c.soc_direction === VM.SOC_Y_X)) n++;
+            }
+            return n;
+          },
+        inputsFromProcesses = (p, t) => {
+            // Returns a tuple {n, nosoc, nz} where n is the number of input links
+            // from processes, nosoc the number of these that carry no cost,
+            // and nz the number of links having actual flow > 0
+            let tuple = {n: 0, nosoc: 0, nz: 0};
+            for(let i = 0; i < p.inputs.length; i++) {
+              const l = p.inputs[i];
+              // NOTE: only process --> product links can carry cost
+              if(l.from_node instanceof Process) {
+                tuple.n++;
+                if(l.share_of_cost === 0) tuple.nosoc++;
+                if(l.actualFlow(t) > VM.NEAR_ZERO) tuple.nz++;
+              }
+            }
+            return tuple;
+          };
+
     // First scan constraints X --> Y: these must have SoC > 0 and moreover
     // the level of both X and Y must be non-zero, or they transfer no cost
     for(let k in this.constraints) if(this.constraints.hasOwnProperty(k) &&
@@ -2741,12 +2771,7 @@ class LinnyRModel {
         break;
       }
       // Count constraints that affect CP of this process
-      let n = 0;
-      for(let i = 0; i < constraints.length; i++) {
-        const c = constraints[i];
-        if((c.to_node === p && c.soc_direction === VM.SOC_X_Y) ||
-            (c.from_node === p && c.soc_direction === VM.SOC_Y_X)) n++;
-      }
+      let n = costAffectingConstraints(p);
       if(n || p.inputs.length) {
         // All inputs can affect the CP of a process
         p.cost_price[t] = VM.UNDEFINED;
@@ -2765,65 +2790,38 @@ class LinnyRModel {
           if(pr < 0) negpr -= pr * l.relative_rate.result(dt);
         }
         p.cost_price[t] = negpr;
+        // Done, so not add to `processes` list 
       }
     }
     // Then scan the products
     for(let k in this.products) if(this.products.hasOwnProperty(k) &&
         !MODEL.ignored_entities[k]) {
       const p = this.products[k];
-      let n = 0,
-          nc = 0,
-          cp = 0;
-      // Count number of (potential) cost-carrying product flows
-      for(let i = 0; i < p.inputs.length; i++) {
-        const l = p.inputs[i];
-        // NOTE: only process --> product links can carry cost
-        if(l.share_of_cost > 0 && l.from_node instanceof Process) n++;
-      }
-      if(p.is_buffer) {
-        // Stocks often introduce cycles; those having only zero-flow
-        // links in/out have stockprice of t-1
+      let ifp = inputsFromProcesses(p, t),
+          nc = costAffectingConstraints(p);
+      if(p.is_buffer && !ifp.nz) {
+        // Stocks for which all INput links have flow = 0 have the same
+        // stock price as in t-1
         // NOTE: it is not good to check for zero stock, as that may be
         // the net result of in/outflows
-        let nz = 0;
-        for(let i = 0; i < p.inputs.length && !nz; i++) {
-          if(p.inputs[i].actualFlow(t) > VM.NEAR_ZERO) nz++;
-        }
-        for(let i = 0; i < p.outputs.length && !nz; i++) {
-          if(p.outputs[i].actualFlow(t) > VM.NEAR_ZERO) nz++;
-        }
-        if(!nz) {
-          n = 0;
-          cp = p.stockPrice(t - 1);
-        }
-      } else if(n > 1) {
-        // NOTE: products having no storage, and *multiple* cost-carrying
-        // input links that all are zero-flow have CP=0
-        let nz = 0;
-        for(let i = 0; i < p.inputs.length && !nz; i++) {
-          if(p.inputs[i].actualFlow(t) > VM.NEAR_ZERO) nz++;
-        }
-        if(!nz) n = 0;
-      }
-      // Add number of cost-transferring constraints
-      for(let i = 0; i < constraints.length; i++) {
-        const c = constraints[i];
-        if(c.to_node === p && c.soc_direction === VM.SOC_X_Y ||
-           (c.from_node === p && c.soc_direction === VM.SOC_Y_X)) nc++;
-      }
-      if(n + nc) {
+        p.cost_price[t] = p.stockPrice(t - 1);
+        p.stock_price[t] = p.cost_price[t];
+      } else if(!nc && (ifp.n === ifp.nosoc || (!ifp.nz && ifp.n > ifp.nosoc + 1))) {
+        // For products having only input links that carry no cost,
+        // CP = 0 but coded as NO_COST so that this can propagate.
+        // Furthermore, for products having no storage and *multiple*
+        // cost-carrying input links that all are zero-flow, the cost
+        // price cannot be inferred unambiguously => set to 0
+        p.cost_price[t] = (ifp.n && ifp.n === ifp.nosoc ? VM.NO_COST : 0);
+      } else {
         // Cost price must be calculated
         p.cost_price[t] = VM.UNDEFINED;
-        p.stock_price[t] = VM.UNDEFINED;
         products.push(p);
-      } else {
-        // Cost price is zero (for stocks: CP[t-1])
-        p.cost_price[t] = cp;
-        p.stock_price[t] = cp;
       }
+      p.cost_price[t] = p.cost_price[t];
     }
-    // Finally, scan all links, and likewise retain only those for which
-    // the CP can not already be inferred from their FROM node
+    // Finally, scan all links, and retain only those for which the CP
+    // can not already be inferred from their FROM node
     for(let k in this.links) if(this.links.hasOwnProperty(k) &&
         !MODEL.ignored_entities[k]) {
       const
@@ -2831,15 +2829,8 @@ class LinnyRModel {
           ld = l.actualDelay(t),
           fn = l.from_node,
           fncp = fn.costPrice(t - ld),
-          tn = l.to_node,
-          tncp = tn.costPrice(t - ld);
-      if(fncp !== VM.UNDEFINED && fncp !== VM.NOT_COMPUTED) {
-        // Links that are output of a node having CP defined have UCP = CP
-        l.unit_cost_price = fncp;
-      } else if(tncp !== VM.UNDEFINED && tncp !== VM.NOT_COMPUTED) {
-        // Links that are input of a node having CP defined have UCP = CP
-        l.unit_cost_price = 0;
-      } else if(fn instanceof Product && fn.price.defined) {
+          tn = l.to_node;
+      if(fn instanceof Product && fn.price.defined) {
         // Links from products having a market price have this price
         // multiplied by their relative rate as unit CP
         l.unit_cost_price = fn.price.result(t) * l.relative_rate.result(t);
@@ -2848,6 +2839,9 @@ class LinnyRModel {
         // Process output links that do not carry cost and product-to-
         // product links have unit CP = 0
         l.unit_cost_price = 0;
+      } else if(fncp !== VM.UNDEFINED && fncp !== VM.NOT_COMPUTED) {
+        // Links that are output of a node having CP defined have UCP = CP
+        l.unit_cost_price = fncp * l.relative_rate.result(t);
       } else {
         l.unit_cost_price = VM.UNDEFINED;
         // Do not push links related to processes having level < 0
@@ -3001,14 +2995,15 @@ class LinnyRModel {
             cp_sccp = VM.COMPUTING;
         for(let j = 0; j < p.inputs.length; j++) {
           const l = p.inputs[j];
-          if(l.from_node instanceof Process && l.share_of_cost > 0) {
+          if(l.from_node instanceof Process) {
             cp = l.from_node.costPrice(t - l.actualDelay(t));
-            if(cp === VM.UNDEFINED) {
+            if(cp === VM.UNDEFINED && l.share_of_cost > 0) {
+              // Contibuting CP still unknown => break from FOR loop
               break;
             } else {
               if(cp_sccp === VM.COMPUTING) {
                 // First CC process having a defined CP => use this CP
-                cp_sccp = cp;
+                cp_sccp = cp * l.share_of_cost;
               } else {
                 // Multiple CC processes => set CP to 0
                 cp_sccp = 0;
@@ -3034,7 +3029,7 @@ class LinnyRModel {
         if(cp === VM.UNDEFINED) continue;
         // CP of product is 0 if no new production UNLESS it has only
         // one cost-carrying production input, as then its CP equals
-        // the CP of the producing process;
+        // the CP of the producing process times the link SoC;
         // if new production > 0 then CP = cost / quantity
         if(cp_sccp !== VM.COMPUTING) {
           cp = (qnp > 0 ? cnp / qnp : cp_sccp);
@@ -6306,6 +6301,37 @@ class Node extends NodeBox {
     }
     return cac;
   }
+  
+  convertLegacyBoundData(lb_data, ub_data) {
+    // Convert time series data for LB and UB in legacy models to datasets,
+    // and replace attribute expressions by references to these datasets
+    if(!lb_data && !ub_data) return;
+    const same = lb_data === ub_data;
+    if(lb_data) {
+      const
+          dsn = this.displayName + (same ? '' : ' LOWER') + ' BOUND DATA',
+          ds = MODEL.addDataset(dsn);
+      // Use the LB attribute as default value for the dataset
+      ds.default_value = parseFloat(this.lower_bound.text);
+      ds.data = stringToFloatArray(lb_data);
+      ds.computeVector();
+      ds.computeStatistics();
+      this.lower_bound.text = `[${dsn}]`;
+      if(same) this.equal_bounds = true;
+      MODEL.legacy_datasets = true;
+    }
+    if(ub_data && !same) {
+      const
+          dsn = this.displayName + ' UPPER BOUND DATA',
+          ds = MODEL.addDataset(dsn);
+      ds.default_value = parseFloat(this.upper_bound.text);
+      ds.data = stringToFloatArray(ub_data);
+      ds.computeVector();
+      ds.computeStatistics();
+      this.upper_bound.text = `[${dsn}]`;
+      MODEL.legacy_datasets = true;
+    }
+  }
 
   actualLevel(t) {
     // Returns the production level c.q. stock level for this node in time step t
@@ -6464,11 +6490,21 @@ class Process extends Node {
     this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
     this.lower_bound.text = xmlDecoded(nodeContentByTag(node, 'lower-bound'));
     this.upper_bound.text = xmlDecoded(nodeContentByTag(node, 'upper-bound'));
-    this.initial_level.text = xmlDecoded(nodeContentByTag(node, 'initial-level'));
-    // NOTE: until version 1.0.16, pace was stored as a node parameter
-    const legacy_pace = nodeParameterValue(node, 'pace');
-    this.pace_expression.text = legacy_pace +
+    // legacy models can have LB and UB hexadecimal data strings
+    this.convertLegacyBoundData(nodeContentByTag(node, 'lower-bound-data'),
+        nodeContentByTag(node, 'upper-bound-data'));
+    if(nodeParameterValue(node, 'reversible') === '1') {
+      // For legacy "reversible" processes, the LB is set to -UB 
+      this.lower_bound.text = '-' + this.upper_bound.text;
+    }
+    // NOTE: legacy models have no initial level field => default to 0 
+    const ilt = xmlDecoded(nodeContentByTag(node, 'initial-level'));
+    this.initial_level.text = ilt || '0';
+    // NOTE: until version 1.0.16, pace was stored as a node parameter; 
+    const pace_text = nodeParameterValue(node, 'pace') + 
         xmlDecoded(nodeContentByTag(node, 'pace'));
+    // NOTE: legacy models have no pace field => default to 1 
+    this.pace_expression.text = pace_text || '1';
     // NOTE: immediately evaluate pace expression as integer
     this.pace = Math.max(1, Math.floor(this.pace_expression.result(1)));
     this.x = safeStrToInt(nodeContentByTag(node, 'x-coord'));
@@ -6873,18 +6909,25 @@ class Product extends Node {
     this.equal_bounds = nodeParameterValue(node, 'equal-bounds') === '1';
     this.integer_level = nodeParameterValue(node, 'integer-level') === '1';
     this.no_slack = nodeParameterValue(node, 'no-slack') === '1';
-    // legacy models have tag "hidden" instead of "no-links"
-    const no_links_tag = (MODEL.legacyVersion ? 'hidden' : 'no-links');
-    this.no_links = nodeParameterValue(node, no_links_tag) === '1';
+    // Legacy models have tag "hidden" instead of "no-links"
+    this.no_links = (nodeParameterValue(node, 'no-links') ||
+        nodeParameterValue(node, 'hidden')) === '1';
     this.scale_unit = MODEL.addScaleUnit(
         xmlDecoded(nodeContentByTag(node, 'unit')));
-    // legacy models have tag "profit" instead of "price"
-    const price_tag = (MODEL.legacyVersion ? 'profit' : 'price');
-    this.price.text = xmlDecoded(nodeContentByTag(node, price_tag));
+    // Legacy models have tag "profit" instead of "price"
+    let pp = nodeContentByTag(node, 'price');
+    if(!pp) pp = nodeContentByTag(node, 'profit');
+    this.price.text = xmlDecoded(pp);
+    // Legacy models can have price time series data as hexadecimal string
+    this.convertLegacyPriceData(nodeContentByTag(node, 'profit-data'));
     this.lower_bound.text = xmlDecoded(nodeContentByTag(node, 'lower-bound'));
     this.upper_bound.text = xmlDecoded(nodeContentByTag(node, 'upper-bound'));
-    this.initial_level.text = xmlDecoded(
-        nodeContentByTag(node, 'initial-level'));
+    // legacy models can have LB and UB hexadecimal data strings
+    this.convertLegacyBoundData(nodeContentByTag(node, 'lower-bound-data'),
+        nodeContentByTag(node, 'upper-bound-data'));
+    // NOTE: legacy models have no initial level field => default to 0 
+    const ilt = xmlDecoded(nodeContentByTag(node, 'initial-level'));
+    this.initial_level.text = ilt || '0';
     this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
     this.x = safeStrToInt(nodeContentByTag(node, 'x-coord'));
     this.y = safeStrToInt(nodeContentByTag(node, 'y-coord'));
@@ -6900,6 +6943,23 @@ class Product extends Node {
     this.resize();
   }
 
+  convertLegacyPriceData(data) {
+    // Convert time series data for prices in legacy models to a dataset,
+    // and replace the price expression by a reference to this dataset
+    if(data) {
+      const
+          dsn = this.displayName + ' PRICE DATA',
+          ds = MODEL.addDataset(dsn);
+      // Use the price attribute as default value for the dataset
+      ds.default_value = parseFloat(this.price.text);
+      ds.data = stringToFloatArray(data);
+      ds.computeVector();
+      ds.computeStatistics();
+      this.price.text = `[${dsn}]`;
+      MODEL.legacy_datasets = true;
+    }
+  }
+
   get defaultAttribute() {
     return 'L';
   }
@@ -7190,13 +7250,14 @@ class Link {
     this.is_feedback = nodeParameterValue(node, 'is-feedback') === '1';
     this.relative_rate.text = xmlDecoded(
         nodeContentByTag(node, 'relative-rate'));
-    this.flow_delay.text = xmlDecoded(nodeContentByTag(node, 'delay'));
+    // NOTE: legacy models have no flow delay field => default to 0
+    const fd_text = xmlDecoded(nodeContentByTag(node, 'delay'));
+    this.flow_delay.text = fd_text || '0';
     this.share_of_cost = safeStrToFloat(
         nodeContentByTag(node, 'share-of-cost'), 0);
-    if(MODEL.legacyVersion) {
+    if(!fd_text) {
     // NOTE: default share-of-cost for links in legacy Linny-R was 100%;
     //       this is dysfunctional in JS Linny-R => set to 0 if equal to 1
-      this.flow_delay.text = '0';
       if(this.share_of_cost == 1) this.share_of_cost = 0;
     }
     this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
@@ -7368,6 +7429,8 @@ class Dataset {
     // *model* time step t = 0
     this.vector = [];
     this.modifiers = {};
+    // Selector to be used when model is run normally, i.e., no experiment
+    this.default_selector = '';
   }
 
   get type() {
@@ -7753,7 +7816,8 @@ class Dataset {
         '</method><url>', xmlEncoded(this.url),
         '</url><data>', xmlEncoded(this.dataString),
         '</data><modifiers>', ml.join(''),
-        '</modifiers></dataset>'].join('');
+        '</modifiers><default-selector>', xmlEncoded(this.default_selector),
+        '</default-selector></dataset>'].join('');
     return xml;
   }
 
@@ -7784,6 +7848,12 @@ class Dataset {
         }
       }
     }
+    const ds = xmlDecoded(nodeContentByTag(node, 'default-selector'));
+    if(ds && !this.modifiers[ds]) {
+      UI.warn(`Dataset <tt>${this.name}</tt> has no selector <tt>${ds}</tt>`);
+    } else {
+      this.default_selector = ds;      
+    }
   }
   
   rename(name) {

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

@@ -554,6 +554,34 @@ function nameToLines(name, actor_name = '') {
   return lines.join('\n');
 }
 
+//
+// Linny-R legacy model conversion functions
+//
+
+function hexToFloat(s) {
+  const n = parseInt('0x' + s, 16);
+  if(isNaN(n)) return 0;
+  const
+      sign = (n >> 31 ? -1 : 1),
+      exp = Math.pow(2, ((n >> 23) & 0xFF) - 127);
+      f = sign * (n & 0x7fffff | 0x800000) * 1.0 / Math.pow(2, 23) * exp;
+  // NOTE: must consider precision of 32-bit floating point numbers!
+  return parseFloat(f.toPrecision(7));
+}
+
+function stringToFloatArray(s) {
+  let i = 8,
+      a = [];
+  while(i <= s.length) {
+    const
+        h = s.substr(i - 8, 8),
+        r = h.substr(6, 2) + h.substr(4, 2) + h.substr(2, 2) + h.substr(0, 2);
+    a.push(hexToFloat(r));
+    i += 8;
+  }
+  return a;
+}
+
 //
 // Encryption-related functions
 //

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

@@ -714,8 +714,11 @@ class ExpressionParser {
         return [x, anchor1, offset1, anchor2, offset2];
       }
     }
+    
+    //
     // NOTE: for experiment results, the method will ALWAYS have returned
     // a result, so what follows does not apply to experiment results
+    //
     
     // Attribute name (optional) follows object-attribute separator
     s = name.split(UI.OA_SEPARATOR);
@@ -725,7 +728,7 @@ class ExpressionParser {
       // ... so restore name if itself contains other vertical bars
       name = s.join(UI.OA_SEPARATOR).trim();
       if(!attr) {
-        // Explicit empty attribute, e.g., [name|]
+        // Explicit *empty* attribute, e.g., [name|]
         // NOTE: this matters for datasets having specifiers: the vertical
         // bar indicates "do not infer a modifier from a running experiment,
         // but use the data"
@@ -817,8 +820,12 @@ class ExpressionParser {
           (attr ? ' and have attribute ' + attr : '');
       return false;
     }
+    
+    //
     // NOTE: for statistics, the method will ALWAYS have returned a result,
     // so what follows does not apply to statistics results
+    //
+    
     let by_reference = false;
     if(name === '.') {
       // NOTE: when name is a single dot, it refers to the data of a dataset
@@ -1407,6 +1414,10 @@ class VirtualMachine {
     // NOTE: below the "near zero" limit, a number is considered zero
     // (this is to timely detect division-by-zero errors)
     this.NEAR_ZERO = 1e-10;
+    // Use a specific constant smaller than near-zero to denote "no cost"
+    // to differentiate "no cost" form cost prices that really are 0
+    this.NO_COST = 0.987654321e-10;
+
     // NOTE: allow for an accuracy margin: stocks may differ 0.1%  from their
     // target without displaying them in red or blue to signal shortage or surplus
     this.SIG_DIF_LIMIT = 0.001;
@@ -1714,6 +1725,7 @@ class VirtualMachine {
     if(n >= this.NOT_COMPUTED) return [true, '\u2297']; // Circled X
     if(n >= this.UNDEFINED) return [true, '\u2047']; // Double question mark ??
     if(n >= this.PLUS_INFINITY) return [true, '\u221E'];
+    if(n === this.NO_COST) return [true, '\u00A2']; // c-slash (cent symbol)
     return [false, n];
   }
   
@@ -5222,15 +5234,26 @@ function VMI_push_dataset_modifier(x, args) {
         MODEL.end_period - MODEL.start_period + MODEL.look_ahead + 1, t));
   }
   if(ms) {
-    // If modifier selector is specified, use the associated expression ...
+    // If modifier selector is specified, use the associated expression
     obj = mx;
-    // ... else check whether an experiment is running UNLESS "use data" is TRUE
-  } else if(MODEL.running_experiment && !ud) {
-    // If so, check if dataset modifiers match the combination of selectors
-    // for the active run
-    const mm = ds.matchingModifiers(MODEL.running_experiment.activeCombination);
-    // If so, use the first match
-    if(mm.length > 0) obj = mm[0].expression;
+  } else if(!ud) {
+    if(MODEL.running_experiment) {
+      // If an experiment is running, check if dataset modifiers match the
+      // combination of selectors for the active run
+      const mm = ds.matchingModifiers(MODEL.running_experiment.activeCombination);
+      // If so, use the first match
+      if(mm.length > 0) obj = mm[0].expression;
+    } else if(ds.default_selector) {
+      // If no expriment (so "normal" run), use default selector if specified
+      const dm = ds.modifiers[ds.default_selector];
+      if(dm) {
+        obj = dm.expression;
+      } else {
+        // Exception should never occur, but check anyway and log it 
+        console.log('WARNING: Dataset "' + ds.name +
+            `" has no default selector "${ds.default_selector}"`);
+      }
+    }
   }
   // By default, use the dataset default value
   let v = ds.defaultValue,