linny-r 1.1.23 → 1.2.0

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

@@ -54,7 +54,8 @@ class LinnyRModel {
     this.currency_unit = CONFIGURATION.default_currency_unit;
     this.default_unit = CONFIGURATION.default_scale_unit;
     this.decimal_comma = CONFIGURATION.decimal_comma;
-    this.scale_units = [this.default_unit];
+    // NOTE: Default scale unit list comprises only the primitive base unit
+    this.scale_units = {'1': new ScaleUnit('1', '1', '1')};
     this.actors = {};
     this.products = {};
     this.processes = {};
@@ -735,8 +736,9 @@ class LinnyRModel {
     }
     // Then infer dimensions from the datasets (which have been changed)
     this.inferDimensions();
-    // Find dimension that has been removed or (only reduced)
-    let removed = null, reduced = null;
+    // Find dimension that has been removed (or only reduced)
+    let removed = null,
+        reduced = null;
     if(od.length > this.dimensions.length) {
       // Dimension removed => find out which one
       let rd = null;
@@ -781,7 +783,14 @@ class LinnyRModel {
       UI.updateControllerDialogs('X');
     }
   }
-  
+
+  renameSelectorInExperiments(olds, news) {
+    // Replace all occurrences of `olds` in dimension strings by `news`
+    for(let i = 0; i < this.experiments.length; i++) {
+      this.experiments[i].renameSelectorInDimensions(olds, news);
+    }
+  }
+
   ignoreClusterInThisRun(c) {
     // Returns TRUE iff an experiment is running and cluster `c` is in the
     // clusters-to-ignore list and its selectors in this list overlap with the
@@ -823,16 +832,183 @@ class LinnyRModel {
     return this.actors[id];
   }
 
-  addScaleUnit(name) {
+  addScaleUnit(name, scalar='1', base_unit='1') {
+    // Add a scale unit to the model, and return its symbol
+    //  (1) To permit things like 1 kWh = 3.6 MJ, and 1 GJ = 1000 MJ,
+    //      scale units have a multiplier and a base unit; by default,
+    //      multiplier = 1 and base unit = '1' to denote "atomic unit"
+    //  (2) Linny-R remains agnostic about physics, SI standards etc.
+    //      so modelers can do anything they like
+    //  (3) Linny-R may in the future be extended with a unit consistency
+    //      check
     name = UI.cleanName(name);
-    if(name === '' || name === ' ') return this.default_unit;
-    // scale units (case sensitive!) are assumed to be universal 
-    if(this.scale_units.indexOf(name) === -1) {
-      this.scale_units.push(name);
+    // NOTE: empty string denotes default unit, so test this first to
+    // avoid a warning 
+    if(!name) return this.default_unit;
+    // NOTE: do not replace or modify an existing scale unit
+    if(!this.scale_units.hasOwnProperty(name)) {
+      this.scale_units[name] = new ScaleUnit(name, scalar, base_unit);
+      UI.updateScaleUnitList();
     }
     return name;
   }
   
+  addPreconfiguredScaleUnits() {
+    // Add scale units defined in file `config.js` (by default: none)
+    for(let i = 0; i < CONFIGURATION.scale_units.length; i++) {
+      const su = CONFIGURATION.scale_units[i];
+      this.addScaleUnit(...su);
+    }
+  }
+  
+  cleanUpScaleUnits() {
+    // Remove all scale units that are not used and have base unit '1'
+    const suiu = {};
+    // Collect all non-empty product units
+    for(let p in this.products) if(this.products.hasOwnProperty(p)) {
+      const su = this.products[p].scale_unit;
+      if(su) suiu[su] = true;
+    }
+    // Likewise collect all non-empty dataset units
+    for(let ds in this.datasets) if(this.datasets.hasOwnProperty(ds)) {
+      const su = this.datasets[ds].scale_unit;
+      if(su) suiu[su] = true;
+    }
+    // Also collect base units and units having base unit other than '1'
+    for(let su in this.scale_units) if(this.scale_units.hasOwnProperty(su)) {
+      const u = this.scale_units[su];
+      suiu[u.base_unit] = true;
+      if(u.base_unit !== '1') suiu[u.name] = true;
+    }
+    // Now all scale units NOT in `suiu` can be removed
+    for(let su in this.scale_units) if(this.scale_units.hasOwnProperty(su)) {
+      if(!suiu.hasOwnProperty(su)) {
+        delete this.scale_units[su];
+      }
+    }
+  }
+  
+  renameScaleUnit(oldu, newu) {
+    let nr = 0;
+    // Update the default product unit
+    if(MODEL.default_unit === oldu) {
+      MODEL.default_unit = newu;
+      nr++;
+    }
+    // Rename product scale units
+    for(let p in MODEL.products) if(MODEL.products.hasOwnProperty(p)) {
+      if(MODEL.products[p].scale_unit === oldu) {
+        MODEL.products[p].scale_unit = newu;
+        nr++;
+      }
+    }
+    // Rename product and dataset units
+    for(let ds in MODEL.datasets) if(MODEL.datasets.hasOwnProperty(ds)) {
+      if(MODEL.datasets[ds].scale_unit === oldu) {
+        MODEL.datasets[ds].scale_unit = newu;
+        nr++;
+      }
+    }
+    // Also rename conversion units in note fields
+    for(let k in MODEL.clusters) if(MODEL.clusters.hasOwnProperty(k)) {
+      const c = MODEL.clusters[k];
+      for(let i = 0; i < c.notes.length; i++) {
+        const
+            n = c.notes[i],
+            tags = n.contents.match(/\[\[[^\]]+\]\]/g);
+        if(tags) {
+          for(let i = 0; i < tags.length; i++) {
+            const
+                ot = tags[i],
+                parts = ot.split('->'), 
+                last = parts.pop().trim();
+            if(last === oldu + ']]') {
+              const nt = parts.join('->') + `->${newu}]]`; 
+              n.contents = n.contents.replace(ot, nt);
+            }
+          }
+          n.parsed = false;
+        }
+      }
+    }
+    // Also rename scale units in expressions (quoted if needed)
+    oldu = UI.nameAsConstantString(oldu);
+    newu = UI.nameAsConstantString(newu);
+    const ax = MODEL.allExpressions;
+    if(oldu.startsWith("'")) {
+      // Simple case: replace quoted old unit by new
+      for(let i = 0; i < ax.length; i++) {
+        let parts = ax[i].text.split(oldu);
+        nr += parts.length - 1;
+        ax[i].text = parts.join(newu);
+      }
+    } else {
+      // Old unit is not enclosed in quotes; then care must be taken
+      // not to replace partial matches, e.g., kton => ktonne when 'ton'
+      // is renamed to 'tonne'; solution is to ensure that old unit must
+      // have a separator character on both sides, or it is not replaced
+      const
+          sep = SEPARATOR_CHARS + "]'",
+          esep = escapeRegex(sep),
+          eou = escapeRegex(oldu),
+          raw = `\[[^\[]*\]|(^|\s|[${esep}])(${eou})($|\s|[${esep}])`;
+      const
+          // NOTE: this will match anything within brackets, and the unit
+          re = new RegExp(raw, 'g');
+      // Iterate over all expressions
+      for(let i = 0; i < ax.length; i++) {
+        let ot = ax[i].text,
+            nt = '',
+            m = re.exec(ot);
+        while (m !== null) {
+          // NOTE: A match with the unit name will have 3 groups, and the
+          // middle one (so element with index 2) should then be equal to
+          // the unit name; other matches will be bracketed text that
+          // should be ignored
+          if(m.length > 2 && m[2] === oldu) {
+            // NOTE: lastIndex points right after the complete match,
+            // and this match m[0] can have separator characters on both
+            // sides which should not be removed
+            const
+                parts = m[0].split(oldu),
+                left = parts[0].split('').pop(),
+                right = (parts[1] ? parts[1].split('')[0] : '');
+            // NOTE: if one separator is a single quote, the the other
+            // must also be a single quote (to avoid 'ton/m3' to be
+            // renamed when 'ton' is renamed)
+            if(!((left === "'" || right === "'") && left !== right) &&
+                sep.indexOf(left) >= 0 && sep.indexOf(right) >= 0) {
+              // Separator chars on both side =>
+              nt += ot.slice(0, re.lastIndex - m[0].length) + parts.join(newu);
+              ot = ot.slice(re.lastIndex);
+            }
+          }
+          m = re.exec(ot);
+        }
+        if(nt) {
+          ax[i].text = nt + ot;
+          nr++;
+        }
+      }
+    }
+    if(nr) {
+      UI.notify(pluralS(nr, 'scale unit') + ' renamed');
+      UI.drawDiagram(MODEL);
+    }
+  }
+  
+  unitConversionMultiplier(from, to) {
+    // Compute and return the FROM : TO unit conversion rate
+    // NOTE: no conversion if TO is the primitive unit
+    if(from === to || to === '1' || to === '') return 1;
+    const fsu = this.scale_units[from];
+    if(fsu) { 
+       const fcr = fsu.conversionRates();
+       if(fcr.hasOwnProperty(to)) return fcr[to];
+    }
+    return VM.UNDEFINED;
+  }
+  
   addNote(node=null) {
     // Add a note to the focal cluster
     let n = new Note(this.focal_cluster);
@@ -840,7 +1016,7 @@ class LinnyRModel {
     this.focal_cluster.notes.push(n);
     return n;
   }
-  
+
   addCluster(name, actor_name, node=null) {
     // NOTE: Adapt XML saved by legacy Linny-R software
     if(name === UI.FORMER_TOP_CLUSTER_NAME ||
@@ -1006,7 +1182,7 @@ class LinnyRModel {
     const id = UI.nameToID(name);
     let d = this.namedObjectByID(id);
     if(d) {
-      if(IO_CONTEXT) {
+      if(IO_CONTEXT && d !== this.equations_dataset) {
         IO_CONTEXT.supersede(d);
       } else {
         // Preserve name uniqueness
@@ -1015,11 +1191,27 @@ class LinnyRModel {
       }
     }
     d = new Dataset(name);
-    // NOTE: when equations dataset is added, recognize it as such, or its
-    // modifier selectors may be rejected while initializing from XML
-    if(name === UI.EQUATIONS_DATASET_NAME) this.equations_dataset = d;
+    let eqds = null;
+    if(name === UI.EQUATIONS_DATASET_NAME) {
+      // When including a module, the current equations must be saved,
+      // then the newly parsed dataset must have its modifiers prefixed,
+      // and then be merged with the original equations dataset
+      if(IO_CONTEXT) eqds = this.equations_dataset;
+      // When equations dataset is added, recognize it as such, or its
+      // modifier selectors may be rejected while initializing from XML
+      this.equations_dataset = d;
+    }
     if(node) d.initFromXML(node);
-    this.datasets[id] = d;
+    if(eqds) {
+      // Restore pointer to original equations dataset
+      this.equations_dataset = eqds;
+      // Add included equations with prefixed names
+console.log('HERE', d);
+      // Return the extended equations dataset
+      return eqds;
+    } else {
+      this.datasets[id] = d;
+    }
     return d;
   }
   
@@ -1269,8 +1461,8 @@ class LinnyRModel {
 
   setSelection() {
     // Set selection to contain all selected entities in the focal cluster
-    // NOTE: to be called after loading a model, and after UNDO/REDO (and then
-    // before drawing the diagram)
+    // NOTE: to be called after loading a model, and after UNDO/REDO (and
+    // then before drawing the diagram)
     const fc = this.focal_cluster;
     this.selection.length = 0;
     this.selection_related_arrows.length = 0;
@@ -1835,67 +2027,90 @@ class LinnyRModel {
     }
   }
   
-  replaceEntityInExpressions(en1, en2) {
-    // Replace entity name `en1` by `en2` in all variables in all expressions
-    // (provided that they are not identical)
-    if(en1 === en2) return;
-    // NOTE: ignore case and multiple spaces in `en1`, but conserve those in
-    // new name `en2` (except for leading and trailing spaces)
-    en1 = en1.trim().replace(/\s+/g, ' ').toLowerCase();
-    en2 = en2.trim();
-    // NOTE: Neither entity name may be empty
-    if(!en1 || !en2) return;
-    // NOTE: use the `rewrite` method of class IOContext; this will keep track
-    // of the number of replacements made
-    const ioc = new IOContext();
-    // Check all actor weight expressions
+  get allExpressions() {
+    // Returns list of all Expression objects
+    // NOTE: start with dataset expressions, so that when recompiling
+    // their `level-based` property is set before recompiling the
+    // other expressions
+    const x = [];
+    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);
+      }
+    }
     for(let k in this.actors) if(this.actors.hasOwnProperty(k)) {
-      ioc.rewrite(this.actors[k].weight, en1, en2);
+      x.push(this.actors[k].weight);
     }
-    // Check all process attribute expressions
     for(let k in this.processes) if(this.processes.hasOwnProperty(k)) {
       const p = this.processes[k];
-      ioc.rewrite(p.lower_bound, en1, en2);
-      ioc.rewrite(p.upper_bound, en1, en2);
-      ioc.rewrite(p.initial_level, en1, en2);
-      ioc.rewrite(p.pace_expression, en1, en2);
+      x.push(p.lower_bound, p.upper_bound, p.initial_level, p.pace_expression);
     }
-    // Check all product attribute expressions
     for(let k in this.products) if(this.products.hasOwnProperty(k)) {
       const p = this.products[k];
-      ioc.rewrite(p.lower_bound, en1, en2);
-      ioc.rewrite(p.upper_bound, en1, en2);
-      ioc.rewrite(p.initial_level, en1, en2);
-      ioc.rewrite(p.price, en1, en2);
+      x.push(p.lower_bound, p.upper_bound, p.initial_level, p.price);
     }
-    // Check all notes in clusters for their color expressions and fields
     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];
-        ioc.rewrite(n.color, en1, en2);
-        // Also rename entities in note fields
-        n.rewriteFields(en1, en2);
+        x.push(n.color);
       }
     }
-    // Check all link rate & delay expressions
     for(let k in this.links) if(this.links.hasOwnProperty(k)) {
-      ioc.rewrite(this.links[k].relative_rate, en1, en2);
-      ioc.rewrite(this.links[k].flow_delay, en1, en2);
+      const l = this.links[k];
+      x.push(l.relative_rate, l.flow_delay);
     }
-    // Check all dataset modifier expressions
-    for(let k in this.datasets) if(this.datasets.hasOwnProperty(k)) {
-      const ds = this.datasets[k];
-      for(let m in ds.modifiers) if(ds.modifiers.hasOwnProperty(m)) {
-        ioc.rewrite(ds.modifiers[m].expression, en1, en2);
+    return x;
+  }
+
+  replaceEntityInExpressions(en1, en2) {
+    // Replace entity name `en1` by `en2` in all variables in all expressions
+    // (provided that they are not identical)
+    if(en1 === en2) return;
+    // NOTE: ignore case and multiple spaces in `en1`, but conserve those in
+    // new name `en2` (except for leading and trailing spaces)
+    en1 = en1.trim().replace(/\s+/g, ' ').toLowerCase();
+    en2 = en2.trim();
+    // NOTE: Neither entity name may be empty
+    if(!en1 || !en2) return;
+    // NOTE: use the `rewrite` method of class IOContext; this will keep track
+    // of the number of replacements made
+    const ioc = new IOContext();
+    // Iterate over all expressions
+    const ax = this.allExpressions;
+    for(let i = 0; i < ax.length; i++) {
+      ioc.rewrite(ax[i], en1, en2);
+    }
+    // Iterate over all notes in clusters to rename entities in note fields
+    for(let k in this.clusters) if(this.clusters.hasOwnProperty(k)) {
+      const cn = this.clusters[k].notes;
+      for(let i = 0; i < cn.length; i++) {
+        cn[i].rewriteFields(en1, en2);
       }
     }
     if(ioc.replace_count) {
       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++) {
+      const sp = this.sensitivity_parameters[i].split('|');
+      if(sp[0].toLowerCase() === en1) {
+        sp[0] = en2;
+        this.sensitivity_parameters[i] = sp.join('|');
+      }
+    }
+    for(let i = 0; i < this.sensitivity_outcomes.length; i++) {
+      const so = this.sensitivity_outcomes[i].split('|');
+      if(so[0].toLowerCase() === en1) {
+        so[0] = en2;
+        this.sensitivity_outcomes[i] = so.join('|');
+      }
+    }
     // Name was changed, so update controller dialogs to display the new name
-    UI.updateControllerDialogs('CDEFX');
+    UI.updateControllerDialogs('CDEFJX');
   }
 
   replaceAttributeInExpressions(ena, a) {
@@ -1905,58 +2120,40 @@ class LinnyRModel {
     // or in the new attribute `a` (except for leading and trailing spaces)
     a = a.trim();
     ena = ena.split('|');
-    // Double-check that `a` is no empty and `ena` contains a vertical bar
+    // Double-check that `a` is not empty and `ena` contains a vertical bar
     if(!a || ena.length < 2) return;
     // Prepare regex to match [entity|attribute] including brackets, but case-
     // tolerant and spacing-tolerant
     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(`\[\s*${raw}\s*(\@[^\]]+)?\s*\]`, 'gi');
     // Count replacements made
     let n = 0;
-    // Check all actor weight expressions
-    for(let k in this.actors) if(this.actors.hasOwnProperty(k)) {
-      n += this.actors[k].weight.replaceAttribute(re, at, a);
-    }
-    // Check all process attribute expressions
-    for(let k in this.processes) if(this.processes.hasOwnProperty(k)) {
-      const p = this.processes[k];
-      n += p.lower_bound.replaceAttribute(re, at, a);
-      n += p.upper_bound.replaceAttribute(re, at, a);
-      n += p.initial_level.replaceAttribute(re, at, a);
-      n += p.pace_expression.replaceAttribute(re, at, a);
-    }
-    // Check all product attribute expressions
-    for(let k in this.products) if(this.products.hasOwnProperty(k)) {
-      const p = this.products[k];
-      n += p.lower_bound.replaceAttribute(re, at, a);
-      n += p.upper_bound.replaceAttribute(re, at, a);
-      n += p.initial_level.replaceAttribute(re, at, a);
-      n += p.price.replaceAttribute(re, at, a);
+    // Iterate over all expressions
+    const ax = this.allExpressions;
+    for(let i = 0; i < ax.length; i++) {
+      n += ax[i].replaceAttribute(re, at, a);
     }
-    // Check all notes in clusters for their color expressions and fields
-    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++) {
-        n += c.notes[i].color.replaceAttribute(re, at, a);
+    // Also rename attributes in parameters and outcomes of sensitivity analysis
+    let sa_cnt = 0;
+    const enat = en + '|' + at;
+    for(let i = 0; i < this.sensitivity_parameters.length; i++) {
+      const sp = this.sensitivity_parameters[i];
+      if(sp.toLowerCase() === enat) {
+        this.sensitivity_parameters[i] = sp.split('|')[0] + '|' + a;
+        sa_cnt++;
       }
     }
-    // Check all link rate and delay expressions
-    for(let k in this.links) if(this.links.hasOwnProperty(k)) {
-      n += this.links[k].relative_rate.replaceAttribute(re, at, a);
-      n += this.links[k].flow_delay.replaceAttribute(re, at, a);
-    }
-    // Check all dataset modifier expressions
-    for(let k in this.datasets) if(this.datasets.hasOwnProperty(k)) {
-      const ds = this.datasets[k];
-      for(let m in ds.modifiers) if(ds.modifiers.hasOwnProperty(m)) {
-        n += ds.modifiers[m].expression.replaceAttribute(re, at, a);
+    for(let i = 0; i < this.sensitivity_outcomes.length; i++) {
+      const so = this.sensitivity_outcomes[i];
+      if(so.toLowerCase() === enat) {
+        this.sensitivity_outcomes[i] = so.split('|')[0] + '|' + a;
+        sa_cnt++;
       }
     }
+    if(sa_cnt > 0) SENSITIVITY_ANALYSIS.updateDialog();
     return n;
   }
 
@@ -2056,7 +2253,9 @@ class LinnyRModel {
       for(i = 0; i < n.childNodes.length; i++) {
         c = n.childNodes[i];
         if(c.nodeName === 'scaleunit') {
-          this.addScaleUnit(xmlDecoded(nodeContentByTag(c, 'name')));
+          this.addScaleUnit(xmlDecoded(nodeContentByTag(c, 'name')),
+              nodeContentByTag(c, 'scalar'),
+              xmlDecoded(nodeContentByTag(c, 'base-unit')));
         }
       }
     }
@@ -2196,14 +2395,14 @@ class LinnyRModel {
           // will then add the module prefix to the selector
           if(IO_CONTEXT) {
             if(name === UI.EQUATIONS_DATASET_NAME) {
-              const mn = childNodeByTag(node, 'modifiers');
+              const mn = childNodeByTag(c, 'modifiers');
               if(mn && mn.childNodes) {
                 for(let j = 0; j < mn.childNodes.length; j++) {
-                  const c = mn.childNodes[j];
-                  if(c.nodeName === 'modifier') {
+                  const cc = mn.childNodes[j];
+                  if(cc.nodeName === 'modifier') {
                     this.equations_dataset.addModifier(
-                        xmlDecoded(nodeContentByTag(c, 'selector')),
-                        c, IO_CONTEXT);
+                        xmlDecoded(nodeContentByTag(cc, 'selector')),
+                        cc, IO_CONTEXT);
                   }
                 }
               }              
@@ -2367,12 +2566,11 @@ class LinnyRModel {
         '</end-period><look-ahead-period>', this.look_ahead,
         '</look-ahead-period><round-sequence>', this.round_sequence,
         '</round-sequence><scaleunits>'].join('');
-    for(let i = 0; i < this.scale_units.length; i++) {
-      xml += '<scaleunit><name>' + xmlEncoded(this.scale_units[i]) +
-          '</name></scaleunit>';
+    let obj;
+    for(obj in this.scale_units) if(this.scale_units.hasOwnProperty(obj)) {
+      xml += this.scale_units[obj].asXML;
     }
     xml += '</scaleunits><actors>';
-    let obj;
     for(obj in this.actors) {
       // NOTE: do not to save "(no actor)"
       if(this.actors.hasOwnProperty(obj) && obj != UI.nameToID(UI.NO_ACTOR)) {
@@ -2589,6 +2787,10 @@ class LinnyRModel {
       this.cleanVector(p.cash_flow, 0, 0);
       this.cleanVector(p.cash_in, 0, 0);
       this.cleanVector(p.cash_out, 0, 0);
+      // NOTE: note fields also must be reset
+      for(let i = 0; i < p.notes.length; i++) {
+        p.notes[i].parsed = false;
+      }
     }
     for(obj in this.processes) if(this.processes.hasOwnProperty(obj)) {
       p = this.processes[obj];
@@ -2679,30 +2881,9 @@ class LinnyRModel {
 
   compileExpressions() {
     // Compile all expression attributes of all model entities
-    let obj,
-        p;
-    // NOTE: start with dataset expressions, so that their level-based
-    // property is set before compiling the other expressions
-    for(obj in this.datasets) if(this.datasets.hasOwnProperty(obj)) {
-      this.datasets[obj].compileExpressions();
-    }
-    for(obj in this.actors) if(this.actors.hasOwnProperty(obj)) {
-      this.actors[obj].weight.compile();
-    }
-    for(obj in this.processes) if(this.processes.hasOwnProperty(obj)) {
-      p = this.processes[obj];
-      p.lower_bound.compile();
-      p.upper_bound.compile();
-    }
-    for(obj in this.products) if(this.products.hasOwnProperty(obj)) {
-      p = this.products[obj];
-      p.lower_bound.compile();
-      p.upper_bound.compile();
-      p.price.compile();
-    }
-    for(obj in this.links) if(this.links.hasOwnProperty(obj)) {
-      this.links[obj].relative_rate.compile();
-      this.links[obj].flow_delay.compile();
+    const ax = this.allExpressions;
+    for(let i = 0; i < ax.length; i++) {
+      ax[i].compile();
     }
   }
   
@@ -3344,17 +3525,6 @@ class LinnyRModel {
     // Start with the Linny-R model properties
     let diff = differences(this, m, Object.keys(UI.MC.SETTINGS_PROPS));
     if(Object.keys(diff).length > 0) d.settings = diff;
-    // Then check for differences in scale unit lists
-    diff = {};
-    for(let i = 0; i < this.scale_units.length; i++) {
-      const su = this.scale_units[i];
-      if(m.scale_units.indexOf(su) < 0) diff[su] = [UI.MC.ADDED, su];
-    }
-    for(let i = 0; i < m.scale_units.length; i++) {
-      const su = m.scale_units[i];
-      if(this.scale_units.indexOf(su) < 0) diff[su] = [UI.MC.DELETED, su];
-    }
-    if(Object.keys(diff).length > 0) d.units = diff;
     // NOTE: dataset differences will also detect equation differences
     for(let i = 0; i < UI.MC.ENTITY_PROPS.length; i++) {
       const ep = UI.MC.ENTITY_PROPS[i]; 
@@ -3691,8 +3861,8 @@ class IOContext {
   }
 
   bind(fn, an) {
-    // Binds the formal name `n` of an entity in a module to the actual name
-    // `an` it will have in the current model
+    // Binds the formal name `fn` of an entity in a module to the actual
+    // name `an` it will have in the current model
     const id = UI.nameToID(fn);
     if(this.bindings.hasOwnProperty(id)) {
       this.bindings[id].bind(an);
@@ -3712,7 +3882,6 @@ class IOContext {
     // (and for processes and clusters: with actor name `an` if specified and
     // not "(no actor)")
     // NOTE: do not modify (no actor), nor the "dataset dot"
-    // @@TO DO: correctly handle equations!
     if(n === UI.NO_ACTOR || n === '.') return n;
     // NOTE: the top cluster of the included model has the prefix as its name
     if(n === UI.TOP_CLUSTER_NAME || n === UI.FORMER_TOP_CLUSTER_NAME) {
@@ -3847,7 +4016,7 @@ class IOContext {
         a,
         stat;
     while(true) {
-      p = x.text.indexOf('[', p + 1);
+      p = x.text.indexOf('[', q + 1);
       if(p < 0) {
         // No more '[' => add remaining part of text, and quit
         s += x.text.slice(q + 1);
@@ -3952,6 +4121,79 @@ class IOContext {
 } // END of class IOContext
 
 
+// CLASS ScaleUnit
+class ScaleUnit {
+  constructor(name, scalar, base_unit) {
+    this.name = name;
+    // NOTES:
+    // (1) Undefined or empty strings default to '1'
+    // (2) Multiplier is stored as string to preserve modeler's notation
+    this.scalar = scalar || '1';
+    this.base_unit = base_unit || '1';
+  }
+  
+  get multiplier() {
+    // Returns scalar as number
+    return safeStrToFloat(this.scalar, 1);
+  }
+  
+  conversionRates() {
+    // Returns a "dictionary" {U1: R1, U2: R2, ...} such that Ui is a
+    // scale unit that can be converted to *this* scaleunit U at rate Ri
+    const cr = {};
+    let p = 0, // previous count of entries
+        n = 1;
+    // At least one conversion: U -> U with rate 1
+    cr[this.name] = 1; 
+    if(this.base_unit !== '1') {
+      // Second conversion: U -> base of U with modeler-defined rate
+      cr[this.base_unit] = this.multiplier;
+      n++;
+    }
+    // Keep track of the number of keys; terminate as no new keys
+    while(p < n) {
+      p = n;
+      // Iterate over all convertible scale units discovered so far
+      for(let u in cr) if(cr.hasOwnProperty(u)) {
+        // Look for conversions to units NOT yet detected
+        for(let k in MODEL.scale_units) if(k != '1' &&
+            MODEL.scale_units.hasOwnProperty(k)) {
+          const
+              su = MODEL.scale_units[k],
+              b = su.base_unit;
+          if(b === '1') continue;
+          if(!cr.hasOwnProperty(k) && cr.hasOwnProperty(b)) {
+            // Add unit if new while base unit is convertible
+            cr[k] = cr[b] / su.multiplier;
+            n++;
+          } else if(cr.hasOwnProperty(k) && !cr.hasOwnProperty(b)) {
+            // Likewise, add base unit if new while unit is convertible
+            cr[b] = cr[k] * su.multiplier;
+            n++;
+          }
+        }
+      }
+    }
+    return cr;
+  }
+
+  get asXML() {
+    return ['<scaleunit><name>', xmlEncoded(this.name),
+        '</name><scalar>', this.scalar,
+        '</scalar><base-unit>', xmlEncoded(this.base_unit),
+        '</base-unit></scaleunit>'].join('');
+  }
+  
+  // NOTE: NO initFromXML because scale units are added directly
+
+  differences(u) {
+    // Return "dictionary" of differences, or NULL if none
+    const d = differences(this, u, UI.MC.UNIT_PROPS);
+    if(Object.keys(d).length > 0) return d;
+    return null;
+  }
+}
+
 // CLASS Actor
 class Actor {
   constructor(name) {
@@ -4107,35 +4349,45 @@ class ObjectWithXYWH {
 
 // CLASS NoteField: numeric value of "field" [[dataset]] in note text 
 class NoteField {
-  constructor(f, o) {
-    // `f` holds the unmodified tag string [[dataset]] to be replaced by the
-    // value of vector or expression `o` for the current time step
+  constructor(f, o, u='1', m=1) {
+    // `f` holds the unmodified tag string [[dataset]] to be replaced by
+    // the value of vector or expression `o` for the current time step;
+    // if specified, `u` is the unit of the value to be displayed, and
+    // `m` is the multiplier for the value to be displayed
     this.field = f;
     this.object = o;
+    this.unit = u;
+    this.multiplier = m;
   }
   
   get value() {
-    // Returns the numeric value of this note field
+    // Returns the numeric value of this note field as a numeric string
+    // followed by its unit (unless this is 1)
+    let v = VM.UNDEFINED;
     const t = MODEL.t;
     if(Array.isArray(this.object)) {
       // Object is a vector
-      if(t < this.object.length) {
-        return this.object[t];
-      } else {
-        return VM.UNDEFINED;
-      }
-    } else if(this.object.hasOwnProperty('c') && this.object.hasOwnProperty('u')) {
+      if(t < this.object.length) v = this.object[t];
+    } else if(this.object.hasOwnProperty('c') &&
+        this.object.hasOwnProperty('u')) {
       // Object holds link lists for cluster balance computation
-      return MODEL.flowBalance(this.object, t);
+      v = MODEL.flowBalance(this.object, t);
     } else if(this.object instanceof Expression) {
       // Object is an expression
-      return this.object.result(t);
+      v = this.object.result(t);
     } else if(typeof this.object === 'number') {
-      return this.object;
+      v = this.object;
+    } else {
+      // NOTE: this fall-through should not occur
+      console.log('Note field value issue:', this.object);
     }
-    // NOTE: this fall-through should not occur
-    console.log('Note field value issue:', this.object);
-    return VM.UNDEFINED;
+    if(Math.abs(this.multiplier - 1) > VM.NEAR_ZERO &&
+        v > VM.MINUS_INFINITY && v < VM.PLUS_INFINITY) {
+      v *= this.multiplier;
+    }
+    v = VM.sig4Dig(v);
+    if(this.unit !== '1') v += ' ' + this.unit;
+    return v;
   }
   
 } // END of class NoteField
@@ -4198,6 +4450,13 @@ class Note extends ObjectWithXYWH {
     this.width = safeStrToInt(nodeContentByTag(node, 'width'));
     this.height = safeStrToInt(nodeContentByTag(node, 'height'));
     this.color.text = xmlDecoded(nodeContentByTag(node, 'color'));
+    if(IO_CONTEXT) {
+      const fel = this.fieldEntities;
+      for(let i = 0; i < fel.length; i++) {
+        this.rewriteTags(fel[i], IO_CONTEXT.actualName(fel[i]));
+      }
+      IO_CONTEXT.rewrite(this.color);
+    }
   }
 
   setCluster(c) {
@@ -4223,24 +4482,93 @@ class Note extends ObjectWithXYWH {
       for(let i = 0; i < tags.length; i++) {
         const
             tag = tags[i],
-            ena = tag.slice(2, tag.length - 2).trim().split('|');
+            inner = tag.slice(2, tag.length - 2).trim(),
+            bar = inner.lastIndexOf('|'),
+            arrow = inner.lastIndexOf('->');
+        // Check if a unit conversion scalar was specified
+        let ena,
+            from_unit = '1',
+            to_unit = '',
+            multiplier = 1;
+        if(arrow > bar) {
+          // Now for sure it is entity->unit or entity|attr->unit
+          ena = inner.split('->');
+          // As example, assume that unit = 'kWh' (so the value of the
+          // field should be displayed in kilowatthour)
+          // NOTE: use .trim() instead of UI.cleanName(...) here;
+          // this forces the modeler to be exact, and that permits proper
+          // renaming of scale units in note fields
+          to_unit = ena[1].trim();
+          ena = ena[0].split('|');
+          if(!MODEL.scale_units.hasOwnProperty(to_unit)) {
+            UI.warn(`Unknown scale unit "${to_unit}"`);
+            to_unit = '1';
+          }
+        } else {
+          ena = inner.split('|');
+        }
         // Look up entity for name and attribute
-        const obj = MODEL.objectByName(ena[0]);
+        const obj = MODEL.objectByName(ena[0].trim());
         if(obj instanceof DatasetModifier) {
-          this.fields.push(new NoteField(tag, obj.expression));
+          // NOTE: equations are (for now) dimensionless => unit '1'
+          if(obj.dataset !== MODEL.equations_dataset) {
+            from_unit = obj.dataset.scale_unit;
+            multiplier = MODEL.unitConversionMultiplier(from_unit, to_unit);
+          }
+          this.fields.push(new NoteField(tag, obj.expression, to_unit, multiplier));
         } else if(obj) {
           // If attribute omitted, use default attribute of entity type
           const attr = (ena.length > 1 ? ena[1].trim() : obj.defaultAttribute);
-          // Variable may specify a vector-type attribute
-          let val = obj.attributeValue(attr);
+          let val = null;
+          // NOTE: for datasets, use the active modifier
+          if(!attr && obj instanceof Dataset) {
+            val = obj.activeModifierExpression;
+          } else {
+            // Variable may specify a vector-type attribute
+            val = obj.attributeValue(attr);
+          }
           // If not, it may be a cluster unit balance
           if(!val && attr.startsWith('=') && obj instanceof Cluster) {
             val = {c: obj, u: attr.substring(1).trim()};
+            from_unit = val.u;
+          }
+          if(obj instanceof Dataset) {
+            from_unit = obj.scale_unit;
+          } else if(obj instanceof Product) {
+            if(attr === 'L') {
+              from_unit = obj.scale_unit;
+            } else if(attr === 'CP' || attr === 'HCP') {
+              from_unit = MODEL.currency_unit;
+            }
+          } else if(obj instanceof Link) {
+            const node = (obj.from_node instanceof Process ?
+                obj.to_node : obj.from_node);
+            if(attr === 'F') {
+              if(obj.multiplier <= VM.LM_MEAN) {
+                from_unit = node.scale_unit;
+              } else {
+                from_unit = '1';
+              }
+            }
+          } else if(attr === 'CI' || attr === 'CO' || attr === 'CF') {
+            from_unit = MODEL.currency_unit;
           }
           // If not, it may be an expression-type attribute
-          if(!val) val = obj.attributeExpression(attr);
+          if(!val) {
+            val = obj.attributeExpression(attr);
+            if(obj instanceof Product) {
+              if(attr === 'IL' || attr === 'LB' || attr === 'UB') {
+                from_unit = obj.scale_unit;
+              } else if(attr === 'P') {
+                from_unit = MODEL.currency_unit + '/' + obj.scale_unit;
+              }
+            }
+          }
+          // If no TO unit, add the FROM unit 
+          if(to_unit === '') to_unit = from_unit;
           if(val) {
-            this.fields.push(new NoteField(tag, val));
+            multiplier = MODEL.unitConversionMultiplier(from_unit, to_unit);
+            this.fields.push(new NoteField(tag, val, to_unit, multiplier));
           } else {
             UI.warn(`Unknown ${obj.type.toLowerCase()} attribute "${attr}"`);
           }
@@ -4251,10 +4579,48 @@ class Note extends ObjectWithXYWH {
     }
     this.parsed = true;
   }
+
+  get fieldEntities() {
+    // Return a list with names of entities used in fields
+    const
+        fel = [],
+        tags = this.contents.match(/\[\[[^\]]+\]\]/g);
+    for(let i = 0; i < tags.length; i++) {
+      const
+          tag = tags[i],
+          inner = tag.slice(2, tag.length - 2).trim(),
+          vb = inner.lastIndexOf('|'),
+          ua = inner.lastIndexOf('->');
+      if(vb >= 0) {
+        addDistinct(inner.slice(0, vb), fel);
+      } else if(ua >= 0 &&
+          MODEL.scale_units.hasOwnProperty(inner.slice(ua + 2))) {
+        addDistinct(inner.slice(0, ua), fel);
+      } else {
+        addDistinct(inner, fel);
+      }
+    }
+    return fel;    
+  }
+  
+  rewriteTags(en1, en2) {
+    // Rewrite tags that reference entity name `en1` to reference `en2` instead
+    if(en1 === en2) return;
+    const
+        raw = en1.split(/\s+/).join('\\\\s+'),
+        re = new RegExp('\\[\\[\\s*' + raw + '\\s*(\\->|\\||\\])', 'g'),
+        tags = this.contents.match(re);
+    if(tags) {
+      for(let i = 0; i < tags.length; i++) {
+        this.contents = this.contents.replace(tags[i], tags[i].replace(en1, en2));
+      }
+    }
+  }
   
   rewriteFields(en1, en2) {
     // Rename fields that reference entity name `en1` to reference `en2` instead
     // NOTE: this does not affect the expression code
+    if(en1 === en2) return;
     for(let i = 0; i < this.fields.length; i++) {
       const
           f = this.fields[i],
@@ -4263,12 +4629,17 @@ class Note extends ObjectWithXYWH {
       // Separate tag into variable and attribute + offset string (if any)
       let e = tag,
           a = '',
-          vb = tag.lastIndexOf('|');
+          vb = tag.lastIndexOf('|'),
+          ua = tag.lastIndexOf('->');
       if(vb >= 0) {
         e = tag.slice(0, vb);
         // NOTE: attribute string includes the vertical bar '|'
         a = tag.slice(vb);
-      }            
+      } else if(ua >= 0 && MODEL.scale_units.hasOwnProperty(tag.slice(ua + 2))) {
+        e = tag.slice(0, ua);
+        // NOTE: attribute string includes the unit conversion arrow '->'
+        a = tag.slice(ua);
+      }
       // Check for match
       const r = UI.replaceEntity(e, en1, en2);
       if(r) {
@@ -4284,7 +4655,7 @@ class Note extends ObjectWithXYWH {
     let txt = this.contents;
     for(let i = 0; i < this.fields.length; i++) {
       const nf = this.fields[i];
-      txt = txt.replace(nf.field, VM.sig4Dig(nf.value));
+      txt = txt.replace(nf.field, nf.value);
     }
     return txt;
   }
@@ -4441,7 +4812,7 @@ class NodeBox extends ObjectWithXYWH {
         delete MODEL.products[old_id];
       } else if(this instanceof Cluster) {
         MODEL.clusters[new_id] = this;
-        delete MODEL.products[old_id];
+        delete MODEL.clusters[old_id];
       } else {
         // NOTE: this should never happen => report an error
         UI.alert('Can only rename processes, products and clusters');
@@ -4706,7 +5077,7 @@ class Arrow {
     } else {
       if(p[0] && p[1]) {
         console.log('ERROR: Two distinct flows on monodirectional arrow',
-            this, sum);
+            this, sum, p);
         return [0, 0, 0, false, false];
       }
       status = 1;
@@ -6322,6 +6693,8 @@ class Node extends NodeBox {
           ds = MODEL.addDataset(dsn);
       // Use the LB attribute as default value for the dataset
       ds.default_value = parseFloat(this.lower_bound.text);
+      // UB data has same unit as product
+      ds.scale_unit = this.scale_unit;
       ds.data = stringToFloatArray(lb_data);
       ds.computeVector();
       ds.computeStatistics();
@@ -6334,6 +6707,8 @@ class Node extends NodeBox {
           dsn = this.displayName + ' UPPER BOUND DATA',
           ds = MODEL.addDataset(dsn);
       ds.default_value = parseFloat(this.upper_bound.text);
+      // UB data has same unit as product
+      ds.scale_unit = this.scale_unit;
       ds.data = stringToFloatArray(ub_data);
       ds.computeVector();
       ds.computeStatistics();
@@ -6961,6 +7336,8 @@ class Product extends Node {
           ds = MODEL.addDataset(dsn);
       // Use the price attribute as default value for the dataset
       ds.default_value = parseFloat(this.price.text);
+      // NOTE: dataset unit then is a currency
+      ds.scale_unit = MODEL.currency_unit;
       ds.data = stringToFloatArray(data);
       ds.computeVector();
       ds.computeStatistics();
@@ -7343,12 +7720,10 @@ class Link {
 
 // CLASS DatasetModifier
 class DatasetModifier {
-  constructor(dataset, selector, params=false) {
+  constructor(dataset, selector) {
     this.dataset = dataset;
     this.selector = selector;
     this.expression = new Expression(dataset, selector, '');
-    // Equations may have parameters
-    this.parameters = params;
     this.expression_cache = {};
   }
   
@@ -7379,17 +7754,12 @@ class DatasetModifier {
     // NOTE: for some reason, selector may become empty string, so prevent
     // saving such unidentified modifiers
     if(this.selector.trim().length === 0) return '';
-    let pstr = (Array.isArray(this.parameters) ?
-        this.parameters.join('\\').trim() : '');
-    if(pstr) pstr = ' parameters="' + xmlEncoded(pstr) + '"';
-    return ['<modifier', pstr, '><selector>', xmlEncoded(this.selector),
+    return ['<modifier><selector>', xmlEncoded(this.selector),
       '</selector><expression>', xmlEncoded(this.expression.text),
       '</expression></modifier>'].join('');
   }
 
   initFromXML(node) {
-    const pstr = nodeParameterValue(node, 'parameters').trim();
-    this.parameters = (pstr ? xmlDecoded(pstr).split('\\'): false);
     this.expression.text = xmlDecoded(nodeContentByTag(node, 'expression'));
     if(IO_CONTEXT) {
       // Contextualize the included expression
@@ -7421,6 +7791,7 @@ class Dataset {
     this.name = name;
     this.comments = '';
     this.default_value = 0;
+    this.scale_unit = '1';
     this.time_scale = 1;
     this.time_unit = CONFIGURATION.default_time_unit;
     this.method = 'nearest';
@@ -7519,6 +7890,14 @@ class Dataset {
     }
     return this.default_value * MODEL.timeStepDuration / this.timeStepDuration;
   }
+
+  changeScaleUnit(name) {
+    let su = MODEL.addScaleUnit(name);
+    if(su !== this.scale_unit) {
+      this.scale_unit = su;
+      MODEL.cleanUpScaleUnits();
+    }
+  }
   
   matchingModifiers(l) {
     // Returns the list of selectors of this dataset (in order: from most to
@@ -7655,47 +8034,45 @@ class Dataset {
     }
     return null;
   }
+
+  get activeModifierExpression() { 
+    if(MODEL.running_experiment) {
+      // If an experiment is running, check if dataset modifiers match the
+      // combination of selectors for the active run
+      const mm = this.matchingModifiers(MODEL.running_experiment.activeCombination);
+      // If so, use the first match
+      if(mm.length > 0) return mm[0].expression;
+    }
+    if(this.default_selector) {
+      // If no experiment (so "normal" run), use default selector if specified
+      const dm = this.modifiers[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}"`);
+    }
+    // Fall-through: return vector instead of expression
+    return this.vector;
+  }
   
   addModifier(selector, node=null, ioc=null) {
-    let s = selector,
-        params = false;
+    let s = selector;
     // Firstly, sanitize the selector
     if(this === MODEL.equations_dataset) {
       // Equation identifiers cannot contain characters that have special
       // meaning in a variable identifier
-      s = s.replace(/[\*\?\|\[\]\{\}\:\@\#]/g, '');
+      s = s.replace(/[\*\?\|\[\]\{\}\@\#]/g, '');
       if(s !== selector) {
-        UI.warn('Equation name cannot contain [, ], {, }, |, :, @, #, * or ?');
+        UI.warn('Equation name cannot contain [, ], {, }, |, @, #, * or ?');
         return null;
       }
-      // Check whether equation has parameters
-      const ss = s.split('\\');
-      if(ss.length > 1) {
-        s = ss.shift();
-        // Store parameter names in lower case
-        for(let i = 0; i < ss.length; i++) {
-          ss[i] = ss[i].toLowerCase();
-        }
-        params = ss;
-      }
+      // Reduce inner spaces to one, and trim outer spaces
+      s = s.replace(/\s+/g, ' ').trim();
+    // Then prefix it when the IO context argument is defined 
+    if(ioc) s = ioc.actualName(s);
       // If equation already exists, return its modifier
       const id = UI.nameToID(s);
-      if(this.modifiers.hasOwnProperty(id)) {
-        const exm = this.modifiers[id];
-        if(params) {
-          if(!exm.parameters) {
-            UI.warn(`Existing equation ${exm.displayName} has no parameters`);
-          } else {
-            const
-                newp = params.join('\\'),
-                oldp = exm.parameters.join('\\');
-            if(newp !== oldp) {
-              UI.warn(`Parameter mismatch: expected \\${oldp}, not \\${newp}`);
-            }
-          }
-        }
-        return exm;
-      }
+      if(this.modifiers.hasOwnProperty(id)) return this.modifiers[id];
       // New equation identifier must not equal some entity ID
       const obj = MODEL.objectByName(s);
       if(obj) {
@@ -7703,8 +8080,6 @@ class Dataset {
         UI.warningEntityExists(obj);
         return null;
       }
-      // Also reduce inner spaces to one, and trim outer spaces
-      s = s.replace(/\s+/g, ' ').trim();
     } else {
       // Standard dataset modifier selectors are much more restricted, but
       // to be user-friendly, special chars are removed automatically
@@ -7722,12 +8097,10 @@ class Dataset {
       UI.warn(UI.WARNING.INVALID_SELECTOR);
       return null;
     }
-    // Then prefix it when the IO context argument is defined 
-    if(ioc) s = ioc.actualName(s);
     // Then add a dataset modifier to this dataset
     const id = UI.nameToID(s);
     if(!this.modifiers.hasOwnProperty(id)) {
-      this.modifiers[id] = new DatasetModifier(this, s, params);
+      this.modifiers[id] = new DatasetModifier(this, s);
     }
     // Finally, initialize it when the XML node argument is defined
     if(node) this.modifiers[id].initFromXML(node);
@@ -7762,7 +8135,8 @@ class Dataset {
     const xml = ['<dataset', p, '><name>', xmlEncoded(n),
         '</name><notes>', cmnts,
         '</notes><default>', this.default_value,
-        '</default><time-scale>', this.time_scale,
+        '</default><unit>', xmlEncoded(this.scale_unit),
+        '</unit><time-scale>', this.time_scale,
         '</time-scale><time-unit>', this.time_unit,
         '</time-unit><method>', this.method,
         '</method><url>', xmlEncoded(this.url),
@@ -7776,10 +8150,11 @@ class Dataset {
   initFromXML(node) {
     this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
     this.default_value = safeStrToFloat(nodeContentByTag(node, 'default'));
+    this.scale_unit = xmlDecoded(nodeContentByTag(node, 'unit')) || '1';
     this.time_scale = safeStrToFloat(nodeContentByTag(node, 'time-scale'), 1);
-    this.time_unit = nodeContentByTag(node, 'time-unit');
-    if(!this.time_unit) this.time_unit = CONFIGURATION.default_time_unit;
-    this.method = nodeContentByTag(node, 'method');
+    this.time_unit = nodeContentByTag(node, 'time-unit') ||
+        CONFIGURATION.default_time_unit;
+    this.method = nodeContentByTag(node, 'method') || 'nearest';
     this.periodic = nodeParameterValue(node, 'periodic') === '1';
     this.array = nodeParameterValue(node, 'array') === '1';
     this.black_box = nodeParameterValue(node, 'black-box') === '1';
@@ -9619,8 +9994,13 @@ class Experiment {
     this.variables = [];
     this.configuration_dims = 0;
     this.column_scenario_dims = 0;
+    this.iterator_ranges = [[0,0], [0,0], [0,0]];
+    this.iterator_dimensions = [];
     this.settings_selectors = [];
     this.settings_dimensions = [];
+    this.combination_selectors = [];
+    this.combination_dimensions = [];
+    this.available_dimensions = [];
     this.actor_selectors = [];
     this.actor_dimensions = [];
     this.excluded_selectors = '';
@@ -9680,6 +10060,56 @@ class Experiment {
     return this.combinations[this.active_combination_index];
   }
   
+  get iteratorRangeString() {
+    // Returns the iterator ranges as "from,to" pairs separated by |
+    const ir = [];
+    for(let i = 0; i < 3; i++) {
+      ir.push(this.iterator_ranges[i].join(','));
+    }
+    return ir.join('|');
+  }
+  
+  parseIteratorRangeString(s) {
+    // Parses `s` as "from,to" pairs, ignoring syntax errors
+    if(s) {
+      const ir = s.split('|');
+      // Add 2 extra substrings to have at least 3
+      ir.push('', '');
+      for(let i = 0; i < 3; i++) {
+        const r = ir[i].split(',');
+        // Likewise add extra substring to have at least 2
+        r.push('');
+        // Parse integers, defaulting to 0
+        this.iterator_ranges[i] = [safeStrToInt(r[0], 0), safeStrToInt(r[1], 0)];
+      }
+    }
+  }
+  
+  updateIteratorDimensions() {
+    // Create iterator selectors for each index variable having a relevant range
+    this.iterator_dimensions = [];
+    const il = ['i', 'j', 'k'];
+    for(let i = 0; i < 3; i++) {
+      const r = this.iterator_ranges[i];
+      if(r[0] || r[1]) {
+        const
+            sel = [],
+            k = il[i] + '=';
+        // NOTE: iterate from FROM to TO limit also when FROM > TO
+        if(r[0] <= r[1]) {
+          for(let j = r[0]; j <= r[1]; j++) {
+            sel.push(k + j);
+          }
+        } else {
+          for(let j = r[0]; j >= r[1]; j--) {
+            sel.push(k + j);
+          }          
+        }
+        this.iterator_dimensions.push(sel);
+      }
+    }
+  }
+  
   matchingCombinationIndex(sl) {
     // Returns index of combination with most selectors in common wilt `sl`
     let high = 0,
@@ -9715,6 +10145,16 @@ class Experiment {
           `<sdim>${xmlEncoded(this.settings_dimensions[i].join(','))}</sdim>`;
       if(sd.indexOf(dim) < 0) sd += dim;
     }
+    let cs = '';
+    for(let i = 0; i < this.combination_selectors.length; i++) {
+      cs += `<csel>${xmlEncoded(this.combination_selectors[i])}</csel>`;
+    }
+    let cd = '';
+    for(let i = 0; i < this.combination_dimensions.length; i++) {
+      const dim =
+          `<cdim>${xmlEncoded(this.combination_dimensions[i].join(','))}</cdim>`;
+      if(cd.indexOf(dim) < 0) cd += dim;
+    }
     let as = '';
     for(let i = 0; i < this.actor_selectors.length; i++) {
       as += this.actor_selectors[i].asXML;
@@ -9733,6 +10173,7 @@ class Experiment {
     return ['<experiment configuration-dims="', this.configuration_dims,
       '" column_scenario-dims="', this.column_scenario_dims,
       (this.completed ? '" completed="1' : ''),
+      '" iterator-ranges="', this.iteratorRangeString,
       '" started="', this.time_started,
       '" stopped="', this.time_stopped,
       '" variables="', this.download_settings.variables,
@@ -9749,7 +10190,9 @@ class Experiment {
       '</dimensions><chart-titles>', ct,
       '</chart-titles><settings-selectors>', ss,
       '</settings-selectors><settings-dimensions>', sd,
-      '</settings-dimensions><actor-selectors>', as,
+      '</settings-dimensions><combination-selectors>', cs,
+      '</combination-selectors><combination-dimensions>', cd,
+      '</combination-dimensions><actor-selectors>', as,
       '</actor-selectors><excluded-selectors>',
       xmlEncoded(this.excluded_selectors),
       '</excluded-selectors><clusters-to-ignore>', cti,
@@ -9762,6 +10205,7 @@ class Experiment {
       nodeParameterValue(node, 'configuration-dims'));
     this.column_scenario_dims = safeStrToInt(
       nodeParameterValue(node, 'column-scenario-dims'));
+    this.parseIteratorRangeString(nodeParameterValue(node, 'iterator-ranges'));
     this.completed = nodeParameterValue(node, 'completed') === '1';
     this.time_started = safeStrToInt(nodeParameterValue(node, 'started'));
     this.time_stopped = safeStrToInt(nodeParameterValue(node, 'stopped'));
@@ -9817,6 +10261,24 @@ class Experiment {
         }
       }
     }
+    n = childNodeByTag(node, 'combination-selectors');
+    if(n && n.childNodes) {
+      for(let i = 0; i < n.childNodes.length; i++) {
+        c = n.childNodes[i];
+        if(c.nodeName === 'csel') {
+          this.combination_selectors.push(xmlDecoded(nodeContent(c)));
+        }
+      }
+    }
+    n = childNodeByTag(node, 'combination-dimensions');
+    if(n && n.childNodes) {
+      for(let i = 0; i < n.childNodes.length; i++) {
+        c = n.childNodes[i];
+        if(c.nodeName === 'cdim') {
+          this.combination_dimensions.push(xmlDecoded(nodeContent(c)).split(','));
+        }
+      }
+    }
     n = childNodeByTag(node, 'actor-selectors');
     if(n && n.childNodes) {
       for(let i = 0; i < n.childNodes.length; i++) {
@@ -9865,7 +10327,9 @@ class Experiment {
     // Returns dimension index if any dimension contains any selector in
     // dimension `d`, or -1 otherwise
     for(let i = 0; i < this.dimensions.length; i++) {
-      if(intersection(this.dimensions[i], d).length > 0) return i;
+      const xd = this.dimensions[i].slice();
+      this.expandCombinationSelectors(xd);
+      if(intersection(xd, d).length > 0) return i;
     }
     return -1;
   }
@@ -9874,7 +10338,7 @@ class Experiment {
     // Removes dimension `d` from list and returns its old index
     for(let i = 0; i < this.dimensions.length; i++) {
       if(intersection(this.dimensions[i], d).length > 0) {
-        this.dimensions.splice(i);
+        this.dimensions.splice(i, 1);
         return i;
       }
     }
@@ -9911,7 +10375,170 @@ class Experiment {
       if(adi >= 0) this.dimensions[adi] = d;
     }
   }
+  
+  get allDimensionSelectors() {
+    const sl = Object.keys(MODEL.listOfAllSelectors);
+    // Add selectors of actor, iterator and settings dimensions
+    return sl;
+  }
 
+  orthogonalSelectors(c) {
+    // Returns TRUE iff the selectors in set `c` all are elements of
+    // different experiment dimensions
+    const
+        // Make a copy of `c` so it can be safely expanded
+        xc = c.slice(),
+        // Start with a copy of all model dimensions
+        dl = MODEL.dimensions.slice(),
+        issues = [];
+    // Add dimensions defined for this experiment
+    for(let i = 0; i < this.settings_dimensions.length; i++) {
+      dl.push(this.settings_dimensions[i]);
+    }
+    for(let i = 0; i < this.actor_dimensions.length; i++) {
+      dl.push(this.actor_dimensions[i]);
+    }
+    // Expand `c` as it may contain combination selectors
+    this.expandCombinationSelectors(xc);
+    // Check for all these dimensions that `c` contains known selectors
+    // and that no two or more selectors occur in the same dimension
+    let unknown = xc.slice();
+    for(let i = 0; i < dl.length; i++) {
+      const idc = intersection(dl[i], xc);
+      unknown = complement(unknown, idc);
+      if(idc.length > 1) {
+        const pair = idc.join(' & ');
+        if(issues.indexOf(pair) < 0) issues.push(pair);
+      }
+    }
+    if(unknown.length > 0) {
+      UI.warn('Combination contains ' +
+          pluralS(unknown.length, 'undefined selector') +
+          ' (' + unknown.join(', ') + ')');
+      return false;
+    }
+    if(issues.length > 0) {
+      UI.warn('Combination contains multiple selectors from same dimension (' +
+          issues.join(', ') + ')');
+      return false;
+    }
+    return true;
+  }
+  
+  expandCombinationSelectors(cs) {
+    // Expansion of combination selectors in a selector set `cs` means
+    // that if, for example, `cs` = (A, C1) where C1 is a combination
+    // selector defined as C1 = (B, C2) with A and B being "normal"
+    // selectors, then C1 must be removed from `cs`, while B and the
+    // expansion of C2 must be appended to `cs`.
+    // NOTE: the original selectors C1 and C2 must be removed because
+    // *dimension* selectors cannot be a used as "normal" selectors
+    // (e.g., for dataset modifiers, actor settings or model setting)
+    // NOTE: traverse `cs` in reverse order to ensure that deleting and
+    // appending produce the intended result
+    for(let i = cs.length - 1; i >= 0; i--) {
+      const s = cs[i];
+      // Check whether selector `s` defines a combination
+      for(let j = 0; j < this.combination_selectors.length; j++) {
+        const tuple = this.combination_selectors[j].split('|');
+        if(tuple[0] === s) {
+          // First remove `s` from the original set...
+          cs.splice(i, 1);
+          // Let `xs` be the selector set to replace `s`
+          const xs = tuple[1].split(' ');
+          // Recursively expand `xs`, as it may contain combination selectors
+          this.expandCombinationSelectors(xs);
+          // ... and append its expansion
+          cs.push(...xs);
+        }
+      }
+    }
+  }
+  
+  orthogonalCombinationDimensions(sl) {
+    // Returns TRUE iff the expansions of the selectors in set `sl`
+    // are mutually exclusive
+    const
+        xl = {},
+        issues = {};
+    for(let i = 0; i < sl.length; i++) {
+      const s = sl[i];
+      xl[s] = [s];
+      this.expandCombinationSelectors(xl[s]);
+      issues[s] = [];
+    }
+    let ok = true;
+    for(let i = 0; i < sl.length; i++) {
+      const s1 = sl[i];
+      for(let j = i + 1; j < sl.length; j++) {
+        const
+            s2 = sl[j],
+            shared = intersection(xl[s1], xl[s2]);
+        if(shared.length > 0) {
+          issues[s1].push(`${s2}: ${shared.join(', ')}`);
+          ok = false;
+        }
+      }
+    }
+    if(!ok) {
+      const il = [];
+      for(let i = 0; i < sl.length; i++) {
+        const s = sl[i];
+        if(issues[s].length > 0) {
+          il.push(`${s} (${issues[s].join('; ')})`);
+        }
+      }
+      UI.warn('Combination dimension is not orthogonal: ' + il.join(', '));
+    }
+    return ok;
+  }
+  
+  inferAvailableDimensions() {
+    // Creates list of dimensions that are orthogonal to those already
+    // selected for this experiment
+    this.available_dimensions.length = 0;
+    // For efficiency, do not use hasDimension but expand the dimensions
+    // that are already selected once, and define a lookup function that
+    // checks for orthogonality
+    const
+        axes = [],
+        orthogonal = (d) => {
+            for(let i = 0; i < axes.length; i++) {
+              if(intersection(axes[i], d).length > 0) return false;
+            }
+            return true;
+          };
+    for(let i = 0; i < this.dimensions.length; i++) {
+      axes.push(this.dimensions[i].slice());
+      this.expandCombinationSelectors(axes[i]);
+    }
+    for(let i = 0; i < MODEL.dimensions.length; i++) {
+      const d = MODEL.dimensions[i];
+      if(orthogonal(d)) this.available_dimensions.push(d);
+    }
+    for(let i = 0; i < this.settings_dimensions.length; i++) {
+      const d = this.settings_dimensions[i];
+      if(orthogonal(d)) this.available_dimensions.push(d);
+    }
+    for(let i = 0; i < this.iterator_dimensions.length; i++) {
+      const d = this.iterator_dimensions[i];
+      if(orthogonal(d)) this.available_dimensions.push(d);
+    }
+    for(let i = 0; i < this.actor_dimensions.length; i++) {
+      const d = this.actor_dimensions[i];
+      if(orthogonal(d)) this.available_dimensions.push(d);
+    }
+    for(let i = 0; i < this.combination_dimensions.length; i++) {
+      // NOTE: combination dimensions must be expanded before checking...
+      const
+          d = this.combination_dimensions[i],
+          xd = d.slice();
+      this.expandCombinationSelectors(xd);
+      // ... but the original combination dimension must be added
+      if(orthogonal(xd)) this.available_dimensions.push(d);
+    }
+  }
+  
   inferActualDimensions() {
     // Creates list of dimensions without excluded selectors
     this.actual_dimensions.length = 0;
@@ -9928,6 +10555,9 @@ class Experiment {
     if(n >= this.actual_dimensions.length) {
       // NOTE: do not push an empty selector list (can occur if no dimensions)
       if(s.length > 0) this.combinations.push(s);
+      // NOTE: combinations may include *dimension* selectors
+      // These then must be "expanded"
+      this.expandCombinationSelectors(s);
       return;
     }
     const d = this.actual_dimensions[n];
@@ -9939,14 +10569,33 @@ class Experiment {
     }
   }
   
+  renameSelectorInDimensions(olds, news) {
+    // Update the combination dimensions that contain `olds`
+    for(let i = 0; i < this.settings_dimensions.length; i++) {
+      const si = this.settings_dimensions[i].indexOf(olds);
+      if(si >= 0) this.settings_dimensions[i][si] = news;
+    }
+    for(let i = 0; i < this.combination_selectors.length; i++) {
+      const
+          c = this.combination_selectors[i].split('|'),
+          sl = c[1].split(' '),
+          si = sl.indexOf(olds);
+      if(si >= 0) {
+        sl[si] = news;
+        c[1] = sl.join(' ');
+        this.combination_selectors[i] = c.join('|');
+      }
+    }
+  }
+
   mayBeIgnored(c) {
-    // Returns TRUE iff `c` is on the list to be ignored
+    // Returns TRUE iff cluster `c` is on the list to be ignored
     for(let i = 0; i < this.clusters_to_ignore.length; i++) {
       if(this.clusters_to_ignore[i].cluster === c) return true;
     }
     return false;
   }
-  
+
   inferVariables() {
     // Create list of distinct variables in charts
     this.variables.length = 0;