linny-r 1.1.23 → 1.2.0

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

@@ -589,7 +589,7 @@ class Paper {
   }
 
   numberSize(number, fsize=8, fweight=400) {
-    // Returns the boundingbox {width: ..., height: ...} of a numerical
+    // Returns the boundingbox {width: ..., height: ...} of a numeric
     // string (in pixels)
     // NOTE: this routine is about 500x faster than textSize because it
     // does not use the DOM tree
@@ -939,6 +939,8 @@ class Paper {
     }
     // Resize paper if necessary
     this.extend();
+    // Display model name in browser
+    document.title = mdl.name || 'Linny-R';
   }
   
   drawSelection(mdl, dx=0, dy=0) {
@@ -2965,6 +2967,10 @@ class GUIController extends Controller {
     // NOTE: responding to `mouseenter` is needed to update the cursor position
     // after closing a modal dialog
     this.cc.addEventListener('mouseenter', (event) => UI.mouseMove(event));
+    // Products can be dragged from the Finder to add a placeholder for
+    // it to the focal cluster
+    this.cc.addEventListener('dragover', (event) => UI.dragOver(event));
+    this.cc.addEventListener('drop', (event) => UI.drop(event));
 
     // Disable dragging on all images
     const
@@ -3123,6 +3129,10 @@ class GUIController extends Controller {
             // Ensure that model documentation can no longer be edited
             DOCUMENTATION_MANAGER.clearEntity([MODEL]);
           });
+    // Make the scale units button of the settings dialog responsive
+    this.modals.settings.element('scale-units-btn').addEventListener('click',
+        // Open the scale units modal dialog on top of the settings dialog 
+        () => SCALE_UNIT_MANAGER.show());
 
     // Modals related to vertical toolbar buttons
     this.modals['add-process'].ok.addEventListener('click',
@@ -3265,7 +3275,7 @@ class GUIController extends Controller {
     if(letters.indexOf('C') >= 0) CHART_MANAGER.updateDialog();
     if(letters.indexOf('D') >= 0) DATASET_MANAGER.updateDialog();
     if(letters.indexOf('E') >= 0) EQUATION_MANAGER.updateDialog();
-    if(letters.indexOf('F') >= 0) FINDER.changeFilter();
+    if(letters.indexOf('F') >= 0) FINDER.updateDialog();
     if(letters.indexOf('I') >= 0) DOCUMENTATION_MANAGER.updateDialog();
     if(letters.indexOf('J') >= 0) SENSITIVITY_ANALYSIS.updateDialog();
     if(letters.indexOf('X') >= 0) EXPERIMENT_MANAGER.updateDialog();
@@ -3276,6 +3286,7 @@ class GUIController extends Controller {
     const loaded = MODEL.parseXML(xml);
     // If not a valid Linny-R model, ensure that the current model is clean 
     if(!loaded) MODEL = new LinnyRModel();
+    this.updateScaleUnitList();
     this.drawDiagram(MODEL);
     // Cursor may have been set to `waiting` when decrypting
     this.normalCursor();
@@ -3798,15 +3809,26 @@ class GUIController extends Controller {
   //
   // Handlers for mouse/cursor events
   //
-
-  mouseMove(e) {
-    // Responds to mouse cursor moving over Linny-R diagram area
-    this.on_node = null;
+  
+  updateCursorPosition(e) {
+    // Updates the cursor coordinates and displays them on the status bar
     const cp = this.paper.cursorPosition(e.pageX, e.pageY);
     this.mouse_x = cp[0];
     this.mouse_y = cp[1];
     document.getElementById('pos-x').innerHTML = 'X = ' + this.mouse_x;
-    document.getElementById('pos-y').innerHTML = 'Y = ' + this.mouse_y;
+    document.getElementById('pos-y').innerHTML = 'Y = ' + this.mouse_y;    
+    this.on_note = null;
+    this.on_node = null;
+    this.on_cluster = null;
+    this.on_cluster_edge = false;
+    this.on_arrow = null;
+    this.on_link = null;
+    this.on_constraint = false;
+  }
+
+  mouseMove(e) {
+    // Responds to mouse cursor moving over Linny-R diagram area
+    this.updateCursorPosition(e);
     
     // NOTE: check, as MODEL might still be undefined
     if(!MODEL) return;
@@ -3829,8 +3851,6 @@ class GUIController extends Controller {
         }
       }
     }
-    this.on_arrow = null;
-    this.on_link = null;
     for(let i = 0; i < fc.arrows.length; i++) {
       const arr = fc.arrows[i];
       if(arr) {
@@ -3853,8 +3873,6 @@ class GUIController extends Controller {
         }
       }
     }
-    this.on_cluster = null;
-    this.on_cluster_edge = false;
     for(let i = fc.sub_clusters.length-1; i >= 0; i--) {
       const obj = fc.sub_clusters[i];
       // NOTE: ignore cluster that is being dragged, so that a cluster it is
@@ -3874,7 +3892,6 @@ class GUIController extends Controller {
       // NOTE: element is persistent, so semi-transparency must also be undone
       c.shape.element.setAttribute('opacity', 1);
     }
-    this.on_note = null;
     for(let i = fc.notes.length-1; i >= 0; i--) {
       const obj = fc.notes[i];
       if(obj.containsPoint(this.mouse_x, this.mouse_y)) {
@@ -4294,6 +4311,29 @@ class GUIController extends Controller {
     this.start_sel_y = -1;
     this.updateButtons();
   }
+  
+  dragOver(e) {
+    // Accepts products that are dragged from the Finder and do not have
+    // a placeholder in the focal cluster
+    this.updateCursorPosition(e);
+    const p = MODEL.products[e.dataTransfer.getData('text')];
+    if(p && MODEL.focal_cluster.indexOfProduct(p) < 0) e.preventDefault();
+  }
+
+  drop(e) {
+    // Adds a product that is dragged from the Finder to the focal cluster
+    // at the cursor position if it does not have a placeholder yet
+    const p = MODEL.products[e.dataTransfer.getData('text')];
+    if(p && MODEL.focal_cluster.indexOfProduct(p) < 0) {
+      e.preventDefault();
+      MODEL.focal_cluster.addProductPosition(p, this.mouse_x, this.mouse_y);
+      UNDO_STACK.push('add', p);
+      this.selectNode(p);
+      this.drawDiagram(MODEL);
+    }
+    // NOTE: update afterwards, as the modeler may target a precise (X, Y)
+    this.updateCursorPosition(e);
+  }
 
   //
   // Handler for keyboard events
@@ -4632,7 +4672,18 @@ class GUIController extends Controller {
     if(name === 'initial level') x.is_static = true; 
     return true;
   }
-
+  
+  updateScaleUnitList() {
+    // Update the HTML datalist element to reflect all scale units
+    const
+        ul = [],
+        keys = Object.keys(MODEL.scale_units).sort(ciCompare);
+    for(let i = 0; i < keys.length; i++) {
+      ul.push(`<option value="${MODEL.scale_units[keys[i]].name}">`);
+    }
+    document.getElementById('units-data').innerHTML = ul.join('');
+  }
+  
   //
   // Navigation in the cluster hierarchy
   //
@@ -4824,6 +4875,7 @@ class GUIController extends Controller {
     // Create a brand new model with (optionally) specified name and author
     MODEL = new LinnyRModel(
         md.element('name').value.trim(), md.element('author').value.trim());
+    MODEL.addPreconfiguredScaleUnits();
     md.hide();
     this.updateTimeStep(MODEL.simulationTimeStep);
     this.drawDiagram(MODEL);
@@ -5135,9 +5187,15 @@ class GUIController extends Controller {
       md.element('time-limit').focus();
       return false;
     }
+    const
+        e = md.element('product-unit'),
+        dsu = UI.cleanName(e.value) || '1';
     model.name = md.element('name').value.trim();
+    // Display model name in browser unless blank
+    document.title = model.name || 'Linny-R';
     model.author = md.element('author').value.trim();
-    model.default_unit = md.element('product-unit').value.trim();
+    if(!model.scale_units.hasOwnProperty(dsu)) model.addScaleUnit(dsu);
+    model.default_unit = dsu;
     model.currency_unit = md.element('currency-unit').value.trim();
     model.encrypt = UI.boxChecked('settings-encrypt');
     model.decimal_comma = UI.boxChecked('settings-decimal-comma');
@@ -5312,9 +5370,11 @@ class GUIController extends Controller {
     this.setBox('product-sink', p.is_sink);
     this.setBox('product-data', p.is_data);
     this.setBox('product-stock', p.is_buffer);
+    // NOTE: price label includes the currency unit and the product unit,
+    // e.g., EUR/ton
     md.element('P').value = p.price.text;
     md.element('P-unit').innerHTML =
-        (p.scale_unit === '1' ? '' : p.scale_unit);
+        (p.scale_unit === '1' ? '' : '/' + p.scale_unit);
     md.element('currency').innerHTML = MODEL.currency_unit;
     md.element('IL').value = p.initial_level.text;
     this.setBox('product-integer', p.integer_level);
@@ -5395,7 +5455,7 @@ class GUIController extends Controller {
       }
     }
     // Update other properties
-    p.scale_unit = md.element('unit').value.trim();
+    p.changeScaleUnit(md.element('unit').value);
     p.equal_bounds = this.getEqualBounds('product-UB-equal');
     p.is_source = this.boxChecked('product-source');
     p.is_sink = this.boxChecked('product-sink');
@@ -5851,8 +5911,12 @@ class GUIMonitor {
     document.getElementById('call-stack-error').innerHTML =
         `ERROR at t=${t}: ` + VM.errorMessage(err);
     for(let i = 0; i < csl; i++) {
-      const x = VM.call_stack[i];
-      vlist.push(x.object.displayName + '|' + x.attribute);
+      const
+          x = VM.call_stack[i],
+          // For equations, only show the attribute
+          ons = (x.object === MODEL.equations_dataset ? '' :
+              x.object.displayName + '|');
+      vlist.push(ons + x.attribute);
       // Trim spaces around all object-attribute separators in the expression
       xlist.push(x.text.replace(/\s*\|\s*/g, '|'));
     }
@@ -6010,24 +6074,30 @@ class GUIMonitor {
     return false;
   }
 
-  submitBlockToSolver(bcode) {
+  submitBlockToSolver() {
     let top = MODEL.timeout_period;
     if(VM.max_solver_time && top > VM.max_solver_time) {
       top = VM.max_solver_time;
       UI.notify('Solver time limit for this server is ' +
           VM.max_solver_time + ' seconds');
     }
-    const bwr = VM.blockWithRound;
+UI.logHeapSize(`BEFORE creating post data`);
+    const
+        bwr = VM.blockWithRound,
+        pd = postData({
+            action: 'solve',
+            user: VM.solver_user,
+            token: VM.solver_token,
+            block: VM.block_count,
+            round: VM.round_sequence[VM.current_round],
+            data: VM.lines,
+            timeout: top
+          });
+UI.logHeapSize(`AFTER creating post data`);
+    // Immediately free the memory taken up by VM.lines
+    VM.lines = '';
     UI.logHeapSize(`BEFORE submitting block #${bwr} to solver`);
-    fetch('solver/', postData({
-          action: 'solve',
-          user: VM.solver_user,
-          token: VM.solver_token,
-          block: VM.block_count,
-          round: VM.round_sequence[VM.current_round],
-          data: bcode,
-          timeout: top
-        }))
+    fetch('solver/', pd)
       .then((response) => {
           if(!response.ok) {
             const msg = `ERROR ${response.status}: ${response.statusText}`;
@@ -6039,6 +6109,7 @@ class GUIMonitor {
       .then((data) => {
           try {
             VM.processServerResponse(JSON.parse(data));
+            UI.logHeapSize('After processing results for block #' + this.block_count);
             // If no errors, solve next block (if any)
             // NOTE: use setTimeout so that this calling function returns,
             // and browser can update its DOM to display progress
@@ -6063,6 +6134,8 @@ class GUIMonitor {
           UI.alert(msg);
           VM.stopSolving();
         });
+    pd.body = '';
+UI.logHeapSize(`after calling FETCH and clearing POST data body`);
     VM.logMessage(VM.block_count,
         `POSTing block #${bwr} took ${VM.elapsedTime} seconds.`);
     UI.logHeapSize(`AFTER posting block #${bwr} to solver`);
@@ -6466,20 +6539,24 @@ Attributes, however, are case sensitive!">[Actor X|CF]</code> for cash flow.
   <code title="Number of rounds in the sequence">nr</code>,
   <code title="Number of current experiment run (starts at 0)">x</code>,
   <code title="Number of runs in the experiment">nx</code>,
+  <span title="Index variables of iterator dimensions)">
+    <code>i</code>, <code>j</code>, <code>k</code>,
+  </span>
   <code title="Number of time steps in 1 year)">yr</code>,
   <code title="Number of time steps in 1 week)">wk</code>,
   <code title="Number of time steps in 1 day)">d</code>,
   <code title="Number of time steps in 1 hour)">h</code>,
   <code title="Number of time steps in 1 minute)">m</code>,
   <code title="Number of time steps in 1 second)">s</code>,
-  <code title="A random number from the uniform distribution U(0, 1)">random</code>)
-  and constants (<code title="Mathematical constant &pi; = ${Math.PI}">pi</code>,
+  <code title="A random number from the uniform distribution U(0, 1)">random</code>),
+  constants (<code title="Mathematical constant &pi; = ${Math.PI}">pi</code>,
   <code title="Logical constant true = 1
 NOTE: any non-zero value evaluates as true">true</code>,
   <code title="Logical constant false = 0">false</code>,
   <code title="The value used for &lsquo;unbounded&rsquo; variables (` +
-    VM.PLUS_INFINITY.toExponential() + `)">infinity</code>)
-    are <strong><em>not</em></strong> enclosed by brackets.
+    VM.PLUS_INFINITY.toExponential() + `)">infinity</code>) and scale units
+    are <strong><em>not</em></strong> enclosed by brackets. Scale units
+    may be enclosed by single quotes.
 </p>
 <h4>Operators</h4>
 <p><em>Monadic:</em>
@@ -6542,7 +6619,8 @@ considers X0, &hellip;, Xn as a variable cash flow time series.">npv</code><br>
   <em>Grouping:</em>
   <code title="X ; Y evaluates as a group or &ldquo;tuple&rdquo; (X, Y)
 NOTE: Grouping groups results in a single group, e.g., (1;2);(3;4;5) evaluates as (1;2;3;4;5)">X ; Y</code>
-  (use only in combination with <code>max</code>, <code>min</code> and probabilistic operators)<br>
+  (use only in combination with <code>max</code>, <code>min</code>, <code>npv</code>
+  and probabilistic operators)<br>
 </p>
 <p>
   Monadic operators take precedence over dyadic operators.
@@ -6574,7 +6652,7 @@ NOTE: Grouping groups results in a single group, e.g., (1;2);(3;4;5) evaluates a
       UI.edited_object = UI.dbl_clicked_node;
       this.edited_input_id = 'note-C';
       if(UI.edited_object) {
-        this.edited_expression = UI.edited_object.attributeExpression('C');
+        this.edited_expression = UI.edited_object.color;
       } else {
         this.edited_expression = null;
       }
@@ -6702,7 +6780,7 @@ NOTE: Grouping groups results in a single group, e.g., (1;2);(3;4;5) evaluates a
     // is passed to differentiate between the DOM elements to be used
     const
         type = document.getElementById(prefix + 'variable-obj').value,
-        n_list = this.namesByType(VM.object_types[type]).sort(),
+        n_list = this.namesByType(VM.object_types[type]).sort(ciCompare),
         vn = document.getElementById(prefix + 'variable-name'),
         options = [];
     // Add "empty" as first and initial option, but disable it.
@@ -6744,7 +6822,7 @@ NOTE: Grouping groups results in a single group, e.g., (1;2);(3;4;5) evaluates a
           slist.push(d.modifiers[m].selector);
         }
         // Sort to present equations in alphabetical order
-        slist.sort();
+        slist.sort(ciCompare);
         for(let i = 0; i < slist.length; i++) {
           options.push(`<option value="${slist[i]}">${slist[i]}</option>`);
         }
@@ -7029,6 +7107,218 @@ class ModelAutoSaver {
 } // END of class ModelAutoSaver
 
 
+// CLASS ScaleUnitManager (modal dialog!)
+class ScaleUnitManager {
+  constructor() {
+    // Add the scale units modal
+    this.dialog = new ModalDialog('scale-units');
+    this.dialog.close.addEventListener('click',
+        () => SCALE_UNIT_MANAGER.dialog.hide());
+    // Make the add, edit and delete buttons of this modal responsive
+    this.dialog.element('new-btn').addEventListener('click',
+        () => SCALE_UNIT_MANAGER.promptForScaleUnit());
+    this.dialog.element('edit-btn').addEventListener('click',
+        () => SCALE_UNIT_MANAGER.editScaleUnit());
+    this.dialog.element('delete-btn').addEventListener('click',
+        () => SCALE_UNIT_MANAGER.deleteScaleUnit());
+    // Add the scale unit definition modal
+    this.new_scale_unit_modal = new ModalDialog('new-scale-unit');
+    this.new_scale_unit_modal.ok.addEventListener(
+        'click', () => SCALE_UNIT_MANAGER.addNewScaleUnit());
+    this.new_scale_unit_modal.cancel.addEventListener(
+        'click', () => SCALE_UNIT_MANAGER.new_scale_unit_modal.hide());
+    this.scroll_area = this.dialog.element('scroll-area');
+    this.table = this.dialog.element('table');
+  }
+  
+  get selectedUnitIsBaseUnit() {
+    // Returns TRUE iff selected unit is used as base unit for some unit
+    for(let u in this.scale_units) if(this.scale_units.hasOwnProperty(u)) {
+      if(this.scale_units[u].base_unit === this.selected_unit) return true;
+    }
+    return false;
+  }
+
+  show() {
+    // Show the user-defined scale units for the current model
+    // NOTE: add/edit/delete actions operate on this list, so changes
+    // take immediate effect
+    MODEL.cleanUpScaleUnits();
+    // NOTE: unit name is key in the scale units object
+    this.selected_unit = '';
+    this.last_time_selected = 0;
+    this.updateDialog();
+    this.dialog.show();
+  }
+  
+  updateDialog() {
+    // Create the HTML for the scale units table and update the state
+    // of the action buttons
+    if(!MODEL.scale_units.hasOwnProperty(this.selected_unit)) {
+      this.selected_unit = '';
+    }
+    const
+        keys = Object.keys(MODEL.scale_units).sort(ciCompare),
+        sl = [],
+        ss = this.selected_unit;
+    let ssid = 'scntr';
+    if(keys.length <= 1) {
+      // Only one key => must be the default '1'
+      sl.push('<tr><td><em>No units defined</em></td></tr>');
+    } else {
+      for(let i = 1; i < keys.length; i++) {
+        const
+            s = keys[i],
+            clk = '" onclick="SCALE_UNIT_MANAGER.selectScaleUnit(event, \'' +
+                s + '\'';
+        if(s === ss) ssid += i;
+        sl.push(['<tr id="scntr', i, '" class="dataset-modif',
+            (s === ss ? ' sel-set' : ''),
+            '"><td class="dataset-selector', clk, ');">',
+            s, '</td><td class="dataset-selector', clk, ', \'scalar\');">',
+            MODEL.scale_units[s].scalar, '</td><td class="dataset-selector',
+            clk, ', \'base\');">', MODEL.scale_units[s].base_unit,
+            '</td></tr>'].join(''));
+      }
+    }
+    this.table.innerHTML = sl.join('');
+    if(ss) UI.scrollIntoView(document.getElementById(ssid));
+    let btns = 'scale-units-edit';
+    if(!this.selectedUnitIsBaseUnit) btns += ' scale-units-delete';
+    if(ss) {
+      UI.enableButtons(btns);
+    } else {
+      UI.disableButtons(btns);
+    }
+  }
+
+  selectScaleUnit(event, symbol, focus) {
+    // Select scale unit, and when double-clicked, allow to edit it
+    const
+        ss = this.selected_unit,
+        now = Date.now(),
+        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 || (symbol === ss && dt < 300);
+    this.selected_unit = symbol;
+    this.last_time_selected = now;
+    if(edit) {
+      this.last_time_selected = 0;
+      this.promptForScaleUnit('Edit', focus);
+      return;
+    }
+    this.updateDialog();
+  }
+  
+  promptForScaleUnit(action='Define new', focus='name') {
+    // Show the Add/Edit scale unit dialog for the indicated action 
+    const md = this.new_scale_unit_modal;
+    // NOTE: by default, let name and base unit be empty strings, not '1'
+    let sv = {name: '', scalar: '1', base_unit: '' };
+    if(action === 'Edit' && this.selected_unit) {
+      sv = MODEL.scale_units[this.selected_unit];
+    }
+    md.element('action').innerText = action;
+    md.element('name').value = sv.name;
+    md.element('scalar').value = sv.scalar;
+    md.element('base').value = sv.base_unit;
+    UI.updateScaleUnitList();
+    this.new_scale_unit_modal.show(focus);
+  }
+
+  addNewScaleUnit() {
+    // Add the new scale unit or update the one being edited 
+    const
+        md = this.new_scale_unit_modal,
+        edited = md.element('action').innerText === 'Edit',
+        // NOTE: unit name cannot contain single quotes
+        s = UI.cleanName(md.element('name').value).replace("'", ''),
+        v = md.element('scalar').value.trim(),
+        // NOTE: accept empty base unit to denote '1'
+        b = md.element('base').value.trim() || '1';
+    if(!s) {
+      // Do not accept empty string as name
+      UI.warn('Scale unit must have a name');
+      md.element('name').focus();
+      return;
+    }
+    if(MODEL.scale_units.hasOwnProperty(s) && !edited) {
+      // Do not accept existing unit as name for new unit
+      UI.warn(`Scale unit "${s}" is already defined`);
+      md.element('name').focus();
+      return;      
+    }
+    if(b !== s && !MODEL.scale_units.hasOwnProperty(b)) {
+      UI.warn(`Base unit "${b}" is undefined`);
+      md.element('base').focus();
+      return;
+    }
+    if(UI.validNumericInput('new-scale-unit-scalar', 'scalar')) {
+      const ucs = Math.abs(safeStrToFloat(v));
+      if(ucs < VM.NEAR_ZERO) {
+        UI.warn(`Unit conversion scalar cannot be zero`);
+        md.element('scalar').focus();
+        return;
+      }
+      if(b === s && ucs !== 1) {
+        UI.warn(`When base unit = scale unit, scalar must equal 1`);
+        md.element('scalar').focus();
+        return;
+      }      
+      const selu = this.selected_unit;
+      if(edited && b !== s) {
+        // Prevent inconsistencies across scalars
+        const cr = MODEL.scale_units[b].conversionRates();
+        if(cr.hasOwnProperty(s)) {
+          UI.warn(`Defining ${s} in terms of ${b} introduces a circular reference`);
+          md.element('base').focus();
+          return;
+        }
+      }
+      if(edited && s !== selu) {
+         // First rename base units
+        for(let u in MODEL.scale_units) if(MODEL.scale_units.hasOwnProperty(u)) {
+          if(MODEL.scale_units[u].base_unit === selu) {
+            MODEL.scale_units[u].base_unit = s;
+          }
+        }
+        // NOTE: renameScaleUnit replaces references to `s`, not the entry
+        MODEL.renameScaleUnit(selu, s);
+        delete MODEL.scale_units[this.selected_unit];
+      }
+      MODEL.scale_units[s] = new ScaleUnit(s, v, b);
+      MODEL.selected_unit = s;
+      this.new_scale_unit_modal.hide();
+      UI.updateScaleUnitList();
+      this.updateDialog();
+    }
+  }
+  
+  editScaleUnit() {
+    // Allow user to edit name and/or value
+    if(this.selected_unit) this.promptForScaleUnit('Edit', 'scalar');
+  }
+  
+  deleteScaleUnit() {
+    // Allow user to delete
+    // @@@TO DO: check whether scale unit is used in the model
+    if(this.selected_unit && !this.selectedUnitIsBaseUnit) {
+      delete MODEL.scale_units[this.selected_unit];
+      this.updateDialog();
+    }
+  }
+  
+  updateScaleUnits() {
+    // Replace scale unit definitions of model by the new definitions
+    UI.updateScaleUnitList();
+    this.dialog.hide();
+  }
+  
+} // END of class ScaleUnitManager
+
+
 // CLASS ActorManager (modal dialog!)
 class ActorManager {
   constructor() {
@@ -8833,21 +9123,26 @@ class GUIDatasetManager extends DatasetManager {
         dnl.push(d);
       }
     }
-    dnl.sort();
+    dnl.sort(ciCompare);
     let sdid = 'dstr';
     for(let i = 0; i < dnl.length; i++) {
       const d = MODEL.datasets[dnl[i]];
       let cls = ioclass[MODEL.ioType(d)];
       if(d.outcome) {
-        cls = (cls + ' outcome').trim();
+        cls += ' outcome';
       } else if(d.array) {
-        cls = (cls + ' array').trim();
+        cls += ' array';
+      } else if(d.data.length > 0) {
+        cls += ' series';
       }
-      if(d.black_box) cls = (cls + ' blackbox').trim();
+      if(Object.keys(d.modifiers).length > 0) cls += ' modif';
+      if(d.black_box) cls += ' blackbox';
+      cls = cls.trim();
       if(cls) cls = ' class="'+ cls + '"';
       if(d === sd) sdid += i;
       dl.push(['<tr id="dstr', i, '" class="dataset',
           (d === sd ? ' sel-set' : ''),
+          (d.default_selector ? ' def-sel' : ''),
           '" onclick="DATASET_MANAGER.selectDataset(event, \'',
           dnl[i], '\');" onmouseover="DATASET_MANAGER.showInfo(\'', dnl[i],
           '\', event.shiftKey);"><td', cls, '>', d.displayName,
@@ -8859,7 +9154,8 @@ class GUIDatasetManager extends DatasetManager {
       this.table.innerHTML = dl.join('');
       this.properties.style.display = 'block';
       document.getElementById('dataset-default').innerHTML =
-          VM.sig4Dig(sd.default_value);
+          VM.sig4Dig(sd.default_value) +
+              (sd.scale_unit === '1' ? '' : '&nbsp;' + sd.scale_unit);
       document.getElementById('dataset-count').innerHTML = sd.data.length;
       document.getElementById('dataset-special').innerHTML = sd.propertiesString;
       if(sd.data.length > 0) {
@@ -9012,11 +9308,16 @@ class GUIDatasetManager extends DatasetManager {
             edit = event.altKey || (m === this.selected_modifier && dt < 300);
       this.last_time_selected = now;
       if(event.shiftKey) {
+        // NOTE: prepare to update HTML class of selected dataset
+        const el = document.getElementById('dataset-table')
+            .getElementsByClassName('sel-set')[0];
         // Toggle dataset default selector
         if(m.selector === this.selected_dataset.default_selector) {
           this.selected_dataset.default_selector = '';
+          el.classList.remove('def-sel');
         } else {
           this.selected_dataset.default_selector = m.selector;
+          el.classList.add('def-sel');
         }
       }
       this.selected_modifier = m;
@@ -9094,6 +9395,7 @@ class GUIDatasetManager extends DatasetManager {
       // Copy properties of d to nd
       nd.comments = `${d.comments}`;
       nd.default_value = d.default_value;
+      nd.scale_unit = d.scale_unit;
       nd.time_scale = d.time_scale;
       nd.time_unit = d.time_unit;
       nd.method = d.method;
@@ -9189,6 +9491,8 @@ class GUIDatasetManager extends DatasetManager {
     const
         hw = this.selected_modifier.hasWildcards,
         sel = this.rename_selector_modal.element('name').value,
+        // NOTE: normal dataset selector, so remove all invalid characters
+        clean_sel = sel.replace(/[^a-zA-z0-9\%\+\-]/g, ''),
         // Keep track of old name
         oldm = this.selected_modifier,
         // NOTE: addModifier returns existing one if selector not changed
@@ -9199,10 +9503,10 @@ class GUIDatasetManager extends DatasetManager {
     if(oldm.selector === this.selected_dataset.default_selector) {
       this.selected_dataset.default_selector = m.selector;
     }
+    MODEL.renameSelectorInExperiments(oldm.selector, clean_sel);
     // If only case has changed, just update the selector
-    // NOTE: normal dataset selector, so remove all invalid characters
     if(m === oldm) {
-      m.selector = sel.replace(/[^a-zA-z0-9\%\+\-]/g, '');
+      m.selector = clean_sel;
       this.updateDialog();
       return;
     }
@@ -9238,12 +9542,8 @@ class GUIDatasetManager extends DatasetManager {
     if(msg.length) {
       UI.notify('Updated ' +  msg.join(' and '));
       // Also update these stay-on-top dialogs, as they may display a
-      // variable name for this dataset + modifier 
-      CHART_MANAGER.updateDialog();
-      DATASET_MANAGER.updateDialog();
-      EQUATION_MANAGER.updateDialog();
-      EXPERIMENT_MANAGER.updateDialog();
-      FINDER.changeFilter();
+      // variable name for this dataset + modifier
+      UI.updateControllerDialogs('CDEFX');
     }
     // NOTE: update dimensions only if dataset now has 2 or more modifiers
     // (ignoring those with wildcards)
@@ -9312,6 +9612,7 @@ class GUIDatasetManager extends DatasetManager {
         cover = md.element('no-time-msg');
     if(ds) {
       md.element('default').value = ds.default_value;
+      md.element('unit').value = ds.scale_unit;
       cover.style.display = (ds.array ? 'block' : 'none');
       md.element('time-scale').value = VM.sig4Dig(ds.time_scale);
       // Add options for time unit selector
@@ -9376,6 +9677,7 @@ class GUIDatasetManager extends DatasetManager {
     }
     // Save the data
     ds.default_value = dv;
+    ds.changeScaleUnit(this.series_modal.element('unit').value);
     ds.time_scale = ts;
     ds.time_unit = this.series_modal.element('time-unit').value;
     ds.method = this.series_modal.element('method').value;
@@ -9455,7 +9757,6 @@ class EquationManager {
     for(let i = 0; i < msl.length; i++) {
       const
           m = ed.modifiers[UI.nameToID(msl[i])],
-          mp = (m.parameters ? '\\' + m.parameters.join('\\') : ''),
           clk = '" onclick="EQUATION_MANAGER.selectModifier(event, \'' +
               m.selector + '\'';
       if(m === sm) smid += i;
@@ -9464,7 +9765,7 @@ class EquationManager {
           '"><td class="equation-selector',
           (m.expression.isStatic ? '' : ' it'),
           clk, ', false);">',
-          m.selector, mp, '</td><td class="equation-expression',
+          m.selector, '</td><td class="equation-expression',
           clk, ');">', m.expression.text, '</td></tr>'].join(''));
     }
     this.table.innerHTML = ml.join('');
@@ -9590,7 +9891,6 @@ class EquationManager {
     } else {
       // When a new modifier has been added, more actions are needed
       m.expression = oldm.expression;
-      m.parameters = oldm.parameters;
       this.deleteEquation();
       this.selected_modifier = m;
     }
@@ -9618,11 +9918,7 @@ class EquationManager {
       UI.notify('Updated ' +  msg.join(' and '));
       // Also update these stay-on-top dialogs, as they may display a
       // variable name for this dataset + modifier
-      CHART_MANAGER.updateDialog();
-      DATASET_MANAGER.updateDialog();
-      EQUATION_MANAGER.updateDialog();
-      EXPERIMENT_MANAGER.updateDialog();
-      FINDER.changeFilter();
+      UI.updateControllerDialogs('CDEFX');
     }
     // Always close the name prompt dialog, and update the equation manager
     this.rename_modal.hide();
@@ -9925,6 +10221,11 @@ class GUIChartManager extends ChartManager {
         u_btn = 'chart-variable-up ',
         d_btn = 'chart-variable-down ',
         ed_btns = 'chart-edit-variable chart-delete-variable ';
+    // Just in case variable index has not been adjusted after some
+    // variables have been deleted
+    if(this.variable_index >= c.variables.length) {
+      this.variable_index = -1;
+    }
     if(this.variable_index < 0) {
       UI.disableButtons(ed_btns + u_btn + d_btn);
     } else {
@@ -9942,7 +10243,7 @@ class GUIChartManager extends ChartManager {
       // If the Edit variable dialog is showing, update its header
       if(this.variable_index >= 0 && !UI.hidden('variable-dlg')) {
         document.getElementById('variable-dlg-name').innerHTML =
-            c.variables[this.variable_index].displayName;
+              c.variables[this.variable_index].displayName;
       }
     }
     this.add_variable_modal.element('obj').value = 0;
@@ -10047,8 +10348,7 @@ class GUIChartManager extends ChartManager {
         if(c.show_title) this.drawChart();
       }
       // Update experiment viewer in case its current experiment uses this chart
-      EXPERIMENT_MANAGER.updateDialog();
-      FINDER.changeFilter();
+      UI.updateControllerDialogs('CFX');
     }
     this.rename_chart_modal.hide();
   }
@@ -10098,10 +10398,8 @@ class GUIChartManager extends ChartManager {
         MODEL.charts.splice(this.chart_index, 1);
         this.chart_index = -1;
       }
-      this.updateDialog();
       // Also update the experiment viewer (charts define the output variables)
-      EXPERIMENT_MANAGER.updateDialog();
-      FINDER.changeFilter();
+      UI.updateControllerDialogs('CFX');
     }
   }
   
@@ -10176,12 +10474,11 @@ class GUIChartManager extends ChartManager {
       this.variable_index = MODEL.charts[this.chart_index].addVariable(o, a);
       if(this.variable_index >= 0) {
         this.add_variable_modal.hide();
-        this.updateDialog();
         // Also update the experiment viewer (charts define the output variables)
         if(EXPERIMENT_MANAGER.selected_experiment) {
           EXPERIMENT_MANAGER.selected_experiment.inferVariables();
-          EXPERIMENT_MANAGER.updateDialog();
         }
+        UI.updateControllerDialogs('CFX');
       }
     }
   }
@@ -10317,10 +10614,7 @@ class GUIChartManager extends ChartManager {
       this.updateDialog();
       // Also update the experiment viewer (charts define the output variables)
       // and finder dialog
-      if(EXPERIMENT_MANAGER.selected_experiment) {
-        EXPERIMENT_MANAGER.updateDialog();
-        FINDER.changeFilter();
-      }
+      if(EXPERIMENT_MANAGER.selected_experiment) UI.updateControllerDialogs('FX');
     }
     this.variable_modal.hide();
   }
@@ -10710,12 +11004,12 @@ class GUISensitivityAnalysis extends SensitivityAnalysis {
       this.showBaseCaseInfo();
       return;
     }
-    // Otherwise, display list of all database selectors in docu-viewer
+    // Otherwise, display list of all dataset selectors in docu-viewer
     if(DOCUMENTATION_MANAGER.visible) {
       const
           ds_dict = MODEL.listOfAllSelectors,
           html = [],
-          sl = Object.keys(ds_dict).sort();
+          sl = Object.keys(ds_dict).sort(ciCompare);
       for(let i = 0; i < sl.length; i++) {
         const
             s = sl[i],
@@ -11131,7 +11425,7 @@ class GUISensitivityAnalysis extends SensitivityAnalysis {
     }
     this.table.innerHTML = html.join('');
     if(this.selected_run >= 0) document.getElementById(
-          `sa-r${this.selected_run}c0`).parent().classList.add('sa-p-sel');
+          `sa-r${this.selected_run}c0`).parentNode.classList.add('sa-p-sel');
     this.updateData();
   }
   
@@ -11194,7 +11488,7 @@ class GUISensitivityAnalysis extends SensitivityAnalysis {
     } else if(n < MODEL.sensitivity_runs.length) {
       this.selected_run = n;
       if(n >= 0) document.getElementById(
-          `sa-r${n}c0`).parent().classList.add('sa-p-sel');
+          `sa-r${n}c0`).parentNode.classList.add('sa-p-sel');
     }
     VM.setRunMessages(this.selected_run);
   }
@@ -11294,6 +11588,10 @@ class GUIExperimentManager extends ExperimentManager {
         'click', () => EXPERIMENT_MANAGER.moveDimension(1));
     document.getElementById('xp-d-settings-btn').addEventListener(
         'click', () => EXPERIMENT_MANAGER.editSettingsDimensions());
+    document.getElementById('xp-d-iterator-btn').addEventListener(
+        'click', () => EXPERIMENT_MANAGER.editIteratorRanges());
+    document.getElementById('xp-d-combination-btn').addEventListener(
+        'click', () => EXPERIMENT_MANAGER.editCombinationDimensions());
     document.getElementById('xp-d-actor-btn').addEventListener(
         'click', () => EXPERIMENT_MANAGER.editActorDimension());
     document.getElementById('xp-d-delete-btn').addEventListener(
@@ -11354,6 +11652,12 @@ class GUIExperimentManager extends ExperimentManager {
     this.parameter_modal.cancel.addEventListener(
         'click', () => EXPERIMENT_MANAGER.parameter_modal.hide());
 
+    this.iterator_modal = new ModalDialog('xp-iterator');
+    this.iterator_modal.ok.addEventListener(
+        'click', () => EXPERIMENT_MANAGER.modifyIteratorRanges());
+    this.iterator_modal.cancel.addEventListener(
+        'click', () => EXPERIMENT_MANAGER.iterator_modal.hide());
+
     this.settings_modal = new ModalDialog('xp-settings');
     this.settings_modal.close.addEventListener(
         'click', () => EXPERIMENT_MANAGER.closeSettingsDimensions());
@@ -11374,6 +11678,26 @@ class GUIExperimentManager extends ExperimentManager {
     this.settings_dimension_modal.cancel.addEventListener(
         'click', () => EXPERIMENT_MANAGER.settings_dimension_modal.hide());
 
+    this.combination_modal = new ModalDialog('xp-combination');
+    this.combination_modal.close.addEventListener(
+        'click', () => EXPERIMENT_MANAGER.closeCombinationDimensions());
+    this.combination_modal.element('s-add-btn').addEventListener(
+        'click', () => EXPERIMENT_MANAGER.editCombinationSelector(-1));
+    this.combination_modal.element('d-add-btn').addEventListener(
+        'click', () => EXPERIMENT_MANAGER.editCombinationDimension(-1));
+
+    this.combination_selector_modal = new ModalDialog('xp-combination-selector');
+    this.combination_selector_modal.ok.addEventListener(
+        'click', () => EXPERIMENT_MANAGER.modifyCombinationSelector());
+    this.combination_selector_modal.cancel.addEventListener(
+        'click', () => EXPERIMENT_MANAGER.combination_selector_modal.hide());
+
+    this.combination_dimension_modal = new ModalDialog('xp-combination-dimension');
+    this.combination_dimension_modal.ok.addEventListener(
+        'click', () => EXPERIMENT_MANAGER.modifyCombinationDimension());
+    this.combination_dimension_modal.cancel.addEventListener(
+        'click', () => EXPERIMENT_MANAGER.combination_dimension_modal.hide());
+
     this.actor_dimension_modal = new ModalDialog('xp-actor-dimension');
     this.actor_dimension_modal.close.addEventListener(
         'click', () => EXPERIMENT_MANAGER.closeActorDimension());
@@ -11423,6 +11747,7 @@ class GUIExperimentManager extends ExperimentManager {
     this.selected_parameter = '';
     this.edited_selector_index = -1;
     this.edited_dimension_index = -1;
+    this.edited_combi_selector_index = -1;
     this.color_scale = new ColorScale('no');
     this.designMode();
   }
@@ -11448,7 +11773,7 @@ class GUIExperimentManager extends ExperimentManager {
     for(let i = 0; i < MODEL.experiments.length; i++) {
       xtl.push(MODEL.experiments[i].title);
     }
-    xtl.sort();
+    xtl.sort(ciCompare);
     for(let i = 0; i < xtl.length; i++) {
       const
           xi = MODEL.indexOfExperiment(xtl[i]),
@@ -11490,24 +11815,25 @@ class GUIExperimentManager extends ExperimentManager {
 
   updateParameters() {
     MODEL.inferDimensions();
-    let n = MODEL.dimensions.length,
-        canview = true;
+    let canview = true;
     const
         dim_count = document.getElementById('experiment-dim-count'),
         combi_count = document.getElementById('experiment-combi-count'),
         header = document.getElementById('experiment-params-header'),
         x = this.selected_experiment;
     if(!x) {
-      dim_count.innerHTML = pluralS(n, ' data dimension') + ' in model';
+      dim_count.innerHTML = pluralS(
+          MODEL.dimensions.length, ' data dimension') + ' in model';
       combi_count.innerHTML = '';
       header.innerHTML = '(no experiment selected)';
       this.params_div.style.display = 'none';
       return;
     }
     x.updateActorDimension();
-    n += x.settings_dimensions.length +
-        x.actor_dimensions.length - x.dimensions.length; 
-    dim_count.innerHTML = pluralS(n, 'more dimension');
+    x.updateIteratorDimensions();
+    x.inferAvailableDimensions(); 
+    dim_count.innerHTML = pluralS(x.available_dimensions.length,
+        'more dimension');
     x.inferActualDimensions();
     x.inferCombinations();
     combi_count.innerHTML = pluralS(x.combinations.length, 'combination');
@@ -11525,11 +11851,10 @@ class GUIExperimentManager extends ExperimentManager {
     }
     document.getElementById('experiment-dim-table').innerHTML = tr.join('');
     // Add button must be enabled only if there still are unused dimensions
-    if(x.dimensions.length >= MODEL.dimensions.length +
-        x.settings_dimensions.length + x.actor_dimensions.length) {
-      document.getElementById('xp-d-add-btn').classList.add('v-disab');
-    } else {
+    if(x.available_dimensions.length > 0) {
       document.getElementById('xp-d-add-btn').classList.remove('v-disab');
+    } else {
+      document.getElementById('xp-d-add-btn').classList.add('v-disab');
     }
     this.updateUpDownButtons();
     tr.length = 0;
@@ -11655,7 +11980,7 @@ class GUIExperimentManager extends ExperimentManager {
       for(let i = 0; i < x.variables.length; i++) {
         vl.push(x.variables[i].displayName); 
       }
-      vl.sort();
+      vl.sort(ciCompare);
       for(let i = 0; i < vl.length; i++) {
         ol.push(['<option value="', vl[i], '"',
             (vl[i] == x.selected_variable ? ' selected="selected"' : ''),
@@ -12250,6 +12575,61 @@ N = ${rr.N}, vector length = ${rr.vector.length}` : '')].join('');
     }
   }
   
+  editIteratorRanges() {
+    // Open dialog for editing iterator ranges
+    const
+        x = this.selected_experiment,
+        md = this.iterator_modal,
+        il = ['i', 'j', 'k'];
+    if(x) {
+      // NOTE: there are always 3 iterators (i, j k) so these have fixed
+      // FROM and TO input fields in the dialog
+      for(let i = 0; i < 3; i++) {
+        const k = il[i];
+        md.element(k + '-from').value = x.iterator_ranges[i][0];
+        md.element(k + '-to').value = x.iterator_ranges[i][1];
+      }
+      this.iterator_modal.show();
+    }
+  }
+
+  modifyIteratorRanges() {
+    const
+        x = this.selected_experiment,
+        md = this.iterator_modal;
+    if(x) {
+      // First validate all input fields (must be integer values)
+      // NOTE: test using a copy so as not to overwrite values until OK
+      const
+          il = ['i', 'j', 'k'],
+          ir = [[0, 0], [0, 0], [0, 0]],
+          re = /^[\+\-]?[0-9]+$/;
+      let el, f, t;
+      for(let i = 0; i < 3; i++) {
+        const k = il[i];
+        el = md.element(k + '-from');
+        f = el.value.trim() || '0';
+        if(f === '' || re.test(f)) {
+          el = md.element(k + '-to');
+          t = el.value.trim() || '0';
+          if(t === '' || re.test(t)) el = null;
+        }
+        // NULL value signals that field inputs are valid
+        if(el === null) {
+          ir[i] = [f, t];
+        } else {
+          el.focus();
+          UI.warn('Iterator range limits must be integers (or default to 0)');
+          return;
+        }
+      }
+      // Input validated, so modify the iterator dimensions
+      x.iterator_ranges = ir;
+      this.updateDialog();
+    }
+    md.hide();
+  }
+ 
   editSettingsDimensions() {
     // Open dialog for editing model settings dimensions
     const x = this.selected_experiment, rows = [];
@@ -12299,7 +12679,7 @@ N = ${rr.N}, vector length = ${rr.vector.length}` : '')].join('');
     md.element('clear').innerHTML = clear;
     md.element('code').value = sel[0];
     md.element('string').value = sel[1];
-    md.show('string');
+    md.show(sel[0] ? 'string' : 'code');
   }
   
   modifySettingsSelector() {
@@ -12350,10 +12730,7 @@ N = ${rr.N}, vector length = ${rr.vector.length}` : '')].join('');
           // NOTE: rename occurrence of code in dimension (should at most be 1)
           const oc = x.settings_selectors[this.edited_selector_index].split('|')[0];
           x.settings_selectors[this.edited_selector_index] = sel;
-          for(let i = 0; i < x.settings_dimensions.length; i++) {
-            const si = x.settings_dimensions[i].indexOf(oc);
-            if(si >= 0) x.settings_dimensions[i][si] = code;
-          }
+          x.renameSelectorInDimensions(oc, code);
         }
       }
       md.hide();
@@ -12432,6 +12809,190 @@ N = ${rr.N}, vector length = ${rr.vector.length}` : '')].join('');
     this.editSettingsDimensions();
   }
  
+  editCombinationDimensions() {
+    // Open dialog for editing combination dimensions
+    const
+        x = this.selected_experiment,
+        rows = [];
+    if(x) {
+      // Initialize selector list
+      for(let i = 0; i < x.combination_selectors.length; i++) {
+        const sel = x.combination_selectors[i].split('|');
+        rows.push('<tr onclick="EXPERIMENT_MANAGER.editCombinationSelector(', i,
+            ');"><td width="25%">', sel[0], '</td><td>', sel[1], '</td></tr>');
+      }
+      this.combination_modal.element('s-table').innerHTML = rows.join('');
+      // Initialize combination list
+      rows.length = 0;
+      for(let i = 0; i < x.combination_dimensions.length; i++) {
+        const dim = x.combination_dimensions[i];
+        rows.push('<tr onclick="EXPERIMENT_MANAGER.editCombinationDimension(', i,
+            ');"><td>', setString(dim), '</td></tr>');
+      }
+      this.combination_modal.element('d-table').innerHTML = rows.join('');
+      this.combination_modal.show();
+      // NOTE: clear infoline because dialog can generate warnings that would
+      // otherwise remain visible while no longer relevant
+      UI.setMessage('');
+    }
+  }
+
+  closeCombinationDimensions() {
+    // Hide editor, and then update the experiment manager to reflect changes
+    this.combination_modal.hide();
+    this.updateDialog();
+  }
+  
+  editCombinationSelector(selnr) {
+    const x = this.selected_experiment;
+    if(!x) return;
+    let action = 'Add',
+        clear = '',
+        sel = ['', ''];
+    this.edited_combi_selector_index = selnr;
+    if(selnr >= 0) {
+      action = 'Edit';
+      clear = '(clear to remove)';
+      sel = x.combination_selectors[selnr].split('|');
+    }
+    const md = this.combination_selector_modal;
+    md.element('action').innerHTML = action;
+    md.element('clear').innerHTML = clear;
+    md.element('code').value = sel[0];
+    md.element('string').value = sel[1];
+    md.show(sel[0] ? 'string' : 'code');
+  }
+  
+  modifyCombinationSelector() {
+    // Accepts an "orthogonal" set of selectors
+    let x = this.selected_experiment;
+    if(x) {
+      const
+          md = this.combination_selector_modal,
+          sc = md.element('code'),
+          ss = md.element('string'),
+          // Ignore invalid characters in the combination selector
+          code = sc.value.replace(/[^\w\+\-\%]/g, ''),
+          // Reduce comma's, semicolons and multiple spaces in the
+          // combination string to a single space
+          value = ss.value.trim().replace(/[\,\;\s]+/g, ' '),
+          add =  this.edited_combi_selector_index < 0;
+      // Remove selector if either field has been cleared
+      if(code.length === 0 || value.length === 0) {
+        if(!add) {
+          x.combination_selectors.splice(this.edited_combi_selector_index, 1);
+        }
+      } else {
+        let ok = x.allDimensionSelectors.indexOf(code) < 0;
+        if(ok) {
+          // Check for uniqueness of code
+          for(let i = 0; i < x.combination_selectors.length; i++) {
+            // NOTE: ignore selector being edited, as this selector can be renamed
+            if(i != this.edited_combi_selector_index &&
+                x.combination_selectors[i].startsWith(code + '|')) ok = false;
+          }
+        }
+        if(!ok) {
+          UI.warn(`Combination selector "${code}" already defined`);
+          sc.focus();
+          return;
+        }
+        // Test for orthogonality (and existence!) of the selectors
+        if(!x.orthogonalSelectors(value.split(' '))) {
+          ss.focus();
+          return;
+        }
+        // Combination selector has format code|space-separated selectors 
+        const sel = code + '|' + value;
+        if(add) {
+          x.combination_selectors.push(sel);
+        } else {
+          // NOTE: rename occurrence of code in dimension (should at most be 1)
+          const oc = x.combination_selectors[this.edited_combi_selector_index].split('|')[0];
+          x.combination_selectors[this.edited_combi_selector_index] = sel;
+          for(let i = 0; i < x.combination_dimensions.length; i++) {
+            const si = x.combination_dimensions[i].indexOf(oc);
+            if(si >= 0) x.combination_dimensions[i][si] = code;
+          }
+        }
+      }
+      md.hide();
+    }
+    // Update combination dimensions dialog
+    this.editCombinationDimensions();
+  }
+
+  editCombinationDimension(dimnr) {
+    const x = this.selected_experiment;
+    if(!x) return;
+    let action = 'Add',
+        clear = '',
+        value = '';
+    this.edited_combi_dimension_index = dimnr;
+    if(dimnr >= 0) {
+      action = 'Edit';
+      clear = '(clear to remove)';
+      // NOTE: present to modeler as space-separated string
+      value = x.combination_dimensions[dimnr].join(' ');
+    }
+    const md = this.combination_dimension_modal;
+    md.element('action').innerHTML = action;
+    md.element('clear').innerHTML = clear;
+    md.element('string').value = value;
+    md.show('string');
+  }
+  
+  modifyCombinationDimension() {
+    let x = this.selected_experiment;
+    if(x) {
+      const
+          add = this.edited_combi_dimension_index < 0,
+          // Trim whitespace and reduce inner spacing to a single space
+          dimstr = this.combination_dimension_modal.element('string').value.trim();
+      // Remove dimension if field has been cleared
+      if(dimstr.length === 0) {
+        if(!add) {
+          x.combination_dimensions.splice(this.edited_combi_dimension_index, 1);
+        }
+      } else {
+        // Check for valid selector list
+        const
+            dim = dimstr.split(/\s+/g),
+            ssl = [];
+        // Get this experiment's combination selector list
+        for(let i = 0; i < x.combination_selectors.length; i++) {
+          ssl.push(x.combination_selectors[i].split('|')[0]);
+        }
+        // All selectors in string should have been defined
+        let c = complement(dim, ssl);
+        if(c.length > 0) {
+          UI.warn('Combination dimension contains ' +
+              pluralS(c.length, 'unknown selector') + ': ' + c.join(' '));
+          return;
+        }
+        // All selectors should expand to non-overlapping selector sets
+        if(!x.orthogonalCombinationDimensions(dim)) return;
+        // Do not add when a (setwise) identical combination dimension exists
+        for(let i = 0; i < x.combination_dimensions.length; i++) {
+          const cd = x.combination_dimensions[i];
+          if(intersection(dim, cd).length === dim.length) {
+            UI.notify('Combination already defined: ' + setString(cd));
+            return;
+          }
+        }
+        // OK? Then add or modify
+        if(add) {
+          x.combination_dimensions.push(dim);
+        } else {
+          x.combination_dimensions[this.edited_combi_dimension_index] = dim;
+        }
+      }
+    }
+    this.combination_dimension_modal.hide();
+    // Update combination dimensions dialog
+    this.editCombinationDimensions();
+  }
+ 
   editActorDimension() {
     // Open dialog for editing the actor dimension
     const x = this.selected_experiment, rows = [];
@@ -12655,22 +13216,10 @@ N = ${rr.N}, vector length = ${rr.vector.length}` : '')].join('');
       const ol = [];
       this.parameter_modal.element('type').innerHTML = type;
       if(type === 'dimension') {
-        // Compile a list of data dimensions and settings dimensions
-        // NOTE: slice to avoid adding settings dimensions to the data dimensions
-        const dl = MODEL.dimensions.slice();
-        for(let i = 0; i < x.settings_dimensions.length; i++) {
-          dl.push(x.settings_dimensions[i]);
-        }
-        for(let i = 0; i < x.actor_dimensions.length; i++) {
-          dl.push(x.actor_dimensions[i]);
-        }
-        for(let i = 0; i < dl.length; i++) {
-          const d = dl[i];
-          // NOTE: exclude dimensions already in the selected experiment
-          if (x.hasDimension(d) < 0) {
-            const ds = setString(d);
-            ol.push(`<option value="${ds}">${ds}</option>`);
-          }
+        x.inferAvailableDimensions();
+        for(let i = 0; i < x.available_dimensions.length; i++) {
+          const ds = setString(x.available_dimensions[i]);
+          ol.push(`<option value="${ds}">${ds}</option>`);
         }
       } else { 
         for(let i = 0; i < this.suitable_charts.length; i++) {
@@ -12737,7 +13286,7 @@ N = ${rr.N}, vector length = ${rr.vector.length}` : '')].join('');
     if(x) {
       x.excluded_selectors = this.exclude.value.replace(
           /[\;\,]/g, ' ').trim().replace(
-          /[^a-zA-Z0-9\+\-\%\_\s]/g, '').split(/\s+/).join(' ');
+          /[^a-zA-Z0-9\+\-\=\%\_\s]/g, '').split(/\s+/).join(' ');
       this.exclude.value = x.excluded_selectors;
       this.updateParameters();
     }
@@ -13384,7 +13933,7 @@ class DocumentationManager {
         }
         lis.push(`<li>${dn}</li>`);
       }
-      lis.sort();
+      lis.sort(ciCompare);
       this.viewer.innerHTML = `<ul>${lis.join('')}</ul>`;
     }
   }
@@ -13413,7 +13962,7 @@ class DocumentationManager {
       for(let i = 0; i < iol.length; i++) {
         lis.push(`<li>${iol[i].displayName}</li>`);
       }
-      lis.sort();
+      lis.sort(ciCompare);
       this.viewer.innerHTML = `<ul>${lis.join('')}</ul>`;
     }
   }
@@ -13731,7 +14280,7 @@ class Finder {
           }
         }
       }
-      enl.sort();
+      enl.sort(ciCompare);
     }
     document.getElementById('finder-entity-imgs').innerHTML = imgs;
     let seid = 'etr';
@@ -14584,6 +15133,9 @@ class UndoStack {
     this.undoables.push(ue);
     // Update the GUI buttons
     UI.updateButtons();
+    // NOTE: update the Finder only if needed, and with a delay because
+    // the "prepare for undo" is performed before the actual change 
+    if(action !== 'move') setTimeout(() => { FINDER.updateDialog(); }, 5);
 //console.log('push ' + action);
 //console.log(UNDO_STACK);
   }
@@ -14880,6 +15432,8 @@ if (MODEL.focal_cluster === fc) {
       MODEL.focal_cluster.clearAllProcesses();
       UI.drawDiagram(MODEL);
       UI.updateButtons();
+      // Update the Finder if needed
+      if(ue.action !== 'move') FINDER.updateDialog();
     }
 //console.log('undo');
 //console.log(UNDO_STACK);
@@ -14931,6 +15485,7 @@ if (MODEL.focal_cluster === fc) {
       MODEL.focal_cluster.clearAllProcesses();
       UI.drawDiagram(MODEL);
       UI.updateButtons();
+      if(re.action !== 'move') FINDER.updateDialog();
     } 
   }
 } // END of class UndoStack