linny-r 1.9.3 → 2.0.1

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

@@ -10,7 +10,7 @@ the Linny-R project.
 */
 
 /*
-Copyright (c) 2017-2023 Delft University of Technology
+Copyright (c) 2017-2024 Delft University of Technology
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -56,6 +56,7 @@ class LinnyRModel {
     this.decimal_comma = CONFIGURATION.decimal_comma;
     // NOTE: Default scale unit list comprises only the primitive base unit
     this.scale_units = {'1': new ScaleUnit('1', '1', '1')};
+    this.power_grids = {};
     this.actors = {};
     this.products = {};
     this.processes = {};
@@ -81,7 +82,7 @@ class LinnyRModel {
     this.ignored_entities = {};
     this.black_box = false;
     this.black_box_entities = {};
-
+    
     // Actor related properties
     this.actor_list = [];
     this.rounds = 1;
@@ -96,6 +97,7 @@ class LinnyRModel {
     this.look_ahead = 0;
     this.grid_pixels = 20;
     this.align_to_grid = true;
+    this.with_power_flow = false;
     this.infer_cost_prices = false;
     this.report_results = false;
     this.show_block_arrows = true;
@@ -279,6 +281,32 @@ class LinnyRModel {
     return ok;
   }
   
+  powerGridByID(id) {
+    // Return power grid identified by hex string `id`.
+    if(this.power_grids.hasOwnProperty(id)) return this.power_grids[id];
+    return null;
+  }
+  
+  powerGridByName(n) {
+    // Return power grid identified by name `n`.
+    for(let k in this.power_grids) if(this.power_grids.hasOwnProperty(k)) {
+      const pg = this.power_grids[k];
+      if(ciCompare(pg.name, n) === 0) return pg;
+    }
+    return null;
+  }
+  
+  get powerGridsWithKVL() {
+    // Return list of power grids for which Kirchhoff's voltage law must
+    // be enforced.
+    const pgl = [];
+    for(let k in this.power_grids) if(this.power_grids.hasOwnProperty(k)) {
+      const pg = this.power_grids[k];
+      if(pg.kirchhoff) pgl.push(pg);
+    }
+    return pgl;
+  }
+  
   noteByID(id) {
     // NOTE: Note object identifiers have syntax #cluster name#time stamp#
     const parts = id.split('#');
@@ -812,8 +840,25 @@ class LinnyRModel {
     return -1;
   }
   
+  validSelector(name) {
+    // Return sanitized selector name, or empty string if invalid.
+    const s = name.replace(/[^a-zA-Z0-9\+\-\%\_\*\?]/g, '');
+    let msg = '';
+    if(s !== name) {
+      msg = UI.WARNING.SELECTOR_SYNTAX;
+    } else if(name.indexOf('*') !== name.lastIndexOf('*')) {
+      // A selector can only contain 1 star.
+      msg = UI.WARNING.SINGLE_WILDCARD;
+    }
+    if(msg) {
+      UI.warn(msg);
+      return '';
+    }
+    return s;    
+  }
+  
   isDimensionSelector(s) {
-    // Returns TRUE if `s` is a dimension selector in some experiment
+    // Return TRUE if `s` is a dimension selector in some experiment.
     for(let i = 0; i < this.experiments.length; i++) {
       if(this.experiments[i].isDimensionSelector(s)) return true;
     }
@@ -860,37 +905,51 @@ class LinnyRModel {
     return this.end_period - this.start_period + 1 + this.look_ahead;
   }
   
+  processSelectorList(sl) {
+    // Checke whether selector list `sl` constitutes a new dimension.
+    // Ignore lists of fewer than 2 "plain" selectors.
+    if(sl.length > 1) {
+      let newdim = true;
+      // Merge into dimension if there are shared selectors.
+      for(let i = 0; i < this.dimensions.length; i++) {
+        const c = complement(sl, this.dimensions[i]);
+        if(c.length < sl.length) {
+          if(c.length > 0) this.dimensions[i].push(...c);
+          newdim = false;
+          break;
+        }
+      }
+      // If only new selectors, add the list as a dimension.
+      if(newdim) {
+        this.dimensions.push(sl);
+      }
+    }
+  }
+  
   inferDimensions() {
     // Generate the list of dimensions for experimental design.
     // NOTE: A dimension is a list of one or more relevant selectors.
-    let newdim;
     this.dimensions.length = 0;
     // NOTE: Ignore the equations dataset.
     for(let d in this.datasets) if(this.datasets.hasOwnProperty(d) &&
         this.datasets[d] !== this.equations_dataset) {
+      // Get the selector list for this dataset.
+      const ds = this.datasets[d];
+      // NOTE: Ignore wildcard selectors!
+      this.processSelectorList(ds.plainSelectors);
+    }
+    // Analyze constraint bound lines in the same way.
+    for(let k in this.constraints) if(this.constraints.hasOwnProperty(k)) {
       // Get selector list
-      const
-          ds = this.datasets[d],
-          // NOTE: Ignore wildcard selectors!
-          sl = ds.plainSelectors;
-      // Ignore datasets with fewer than 2 "plain" selectors.
-      if(sl.length > 1) {
-        newdim = true;
-        // Merge into dimension if there are shared selectors
-        for(let i = 0; i < this.dimensions.length; i++) {
-          const c = complement(sl, this.dimensions[i]);
-          if(c.length < sl.length) {
-            if(c.length > 0) this.dimensions[i].push(...c);
-            newdim = false;
-            break;
-          }
-        }
-        // If only new selectors, add the list as a dimension
-        if(newdim) {
-          this.dimensions.push(sl);
-        }
+      const c = this.constraints[k];
+      for(let i = 0; i < c.bound_lines.length; i++) {
+        const sl = c.bound_lines[i].selectorList;
+        // NOTE: Ignore the first selector "(default)".
+        sl.shift();
+        this.processSelectorList(sl);
       }
     }
+
   }
 
   expandDimension(sl) {
@@ -1246,8 +1305,16 @@ class LinnyRModel {
     return VM.UNDEFINED;
   }
   
+  addPowerGrid(id, node=null) {
+    // Add a power grid to the model.
+    let pg = new PowerGrid(id);
+    if(node) pg.initFromXML(node);
+    this.power_grids[id] = pg;
+    return pg;
+  }
+  
   addNote(node=null) {
-    // Add a note to the focal cluster
+    // Add a note to the focal cluster.
     let n = new Note(this.focal_cluster);
     if(node) n.initFromXML(node);
     this.focal_cluster.notes.push(n);
@@ -2667,10 +2734,12 @@ class LinnyRModel {
       this.encrypt = nodeParameterValue(node, 'encrypt') === '1';
       this.decimal_comma = nodeParameterValue(node, 'decimal-comma') === '1';
       this.align_to_grid = nodeParameterValue(node, 'align-to-grid') === '1';
+      this.with_power_flow = nodeParameterValue(node, 'power-flow') === '1';
       this.infer_cost_prices = nodeParameterValue(node, 'cost-prices') === '1';
       this.report_results = nodeParameterValue(node, 'report-results') === '1';
       this.show_block_arrows = nodeParameterValue(node, 'block-arrows') === '1';
-      this.always_diagnose = nodeParameterValue(node, 'diagnose') === '1';
+      // NOTE: Diagnosis option should default to TRUE unless *set* to FALSE.
+      this.always_diagnose = nodeParameterValue(node, 'diagnose') !== '0';
       this.show_notices = nodeParameterValue(node, 'show-notices') === '1';
       this.name = xmlDecoded(nodeContentByTag(node, 'name'));
       this.author = xmlDecoded(nodeContentByTag(node, 'author'));
@@ -2729,6 +2798,16 @@ class LinnyRModel {
         }
       }
     }
+    // Power grids are not "entities", and can be included "as is"
+    n = childNodeByTag(node, 'powergrids');
+    if(n && n.childNodes) {
+      for(i = 0; i < n.childNodes.length; i++) {
+        c = n.childNodes[i];
+        if(c.nodeName === 'grid') {
+          this.addPowerGrid(nodeContentByTag(c, 'id'), c);
+        }
+      }
+    }
     // When including a model, actors may be bound to an existing actor
     n = childNodeByTag(node, 'actors');
     if(n && n.childNodes) {
@@ -3017,14 +3096,18 @@ class LinnyRModel {
         '" current="', this.current_time_step,
         '" rounds="', this.rounds,
         '" no-actor-round-flags="', this.actors[UI.nameToID(UI.NO_ACTOR)].round_flags,
+        // NOTE: Add the diagnosis option *explicitly* to differentiate
+        // between older models saved *without* this option, and newer
+        // models having this option switched off. 
+        '" diagnose="', (this.always_diagnose ? '1' : '0'),
         '"'].join('');
     if(this.encrypt) p += ' encrypt="1"';
     if(this.decimal_comma) p += ' decimal-comma="1"';
     if(this.align_to_grid) p += ' align-to-grid="1"';
+    if(this.with_power_flow) p += ' power-flow="1"';
     if(this.infer_cost_prices) p += ' cost-prices="1"';
     if(this.report_results) p += ' report-results="1"';
     if(this.show_block_arrows) p += ' block-arrows="1"';
-    if(this.always_diagnose) p += ' diagnose="1"';
     if(this.show_notices) p += ' show-notices="1"';
     let xml = this.xml_header + ['<model', p, '><name>',  xmlEncoded(this.name),
         '</name><author>', xmlEncoded(this.author),
@@ -3050,7 +3133,11 @@ class LinnyRModel {
     for(obj in this.scale_units) if(this.scale_units.hasOwnProperty(obj)) {
       xml += this.scale_units[obj].asXML;
     }
-    xml += '</scaleunits><actors>';
+    xml += '</scaleunits><powergrids>';
+    for(obj in this.power_grids) if(this.power_grids.hasOwnProperty(obj)) {
+      xml += this.power_grids[obj].asXML;
+    }
+    xml += '</powergrids><actors>';
     for(obj in this.actors) {
       // NOTE: do not to save "(no actor)"
       if(this.actors.hasOwnProperty(obj) && obj != UI.nameToID(UI.NO_ACTOR)) {
@@ -4765,11 +4852,97 @@ class ScaleUnit {
   }
 }
 
+// CLASS PowerGrid
+class PowerGrid {
+  constructor(id) {
+    // NOTE: PowerGrids are uniquely identified by a hexadecimal string.
+    this.id = id;
+    this.name = '';
+    this.comments = '';
+    // Default color is blue (arbitrary choice).
+    this.color = '#0000ff';
+    // Default voltage is 150 kV (arbitrary choice).
+    this.kilovolts = 150;
+    // Default power unit is MW (will be used as unit of grid nodes)
+    this.power_unit = 'MW';
+    this.kirchhoff = true;
+    // Loss approximation can be 0 (no losses), 1 (linear with load),
+    // 2 (quadratic, approximated with two linear tangents) or
+    // 3 (quadratic, approximated with three linear tangents).
+    this.loss_approximation = 0;
+  }
+
+  get type() {
+    return 'Grid';
+  }
+  
+  get displayName() {
+    return this.name;
+  }
+  
+  get voltage() {
+    // Return the voltage in the most compact human-readable notation.
+    const kv = this.kilovolts;
+    if(kv < 0.5) return Math.round(kv * 1000) + '&thinsp;V';
+    if(kv < 10) return kv.toPrecision(2) + '&thinsp;kV';
+    if(kv >= 999.5) return (kv * 0.001).toPrecision(2) + '&thinsp;MV';
+    return Math.round(kv) + '&thinsp;kV';
+  }
+  
+  // NOTE: The functions below are based on Birchfield et al. (2017)
+  // A Metric-Based Validation Process to Assess the Realism of Synthetic
+  // Power Grids. Energies, 10(1233). DOI: 10.3390/en10081233.
+  // Table 3 in this paper lists for 6 voltage levels (115 - 500 kV) the
+  // median of per unit per km reactance, and Table 4 lists for the same
+  // voltage levels the median of X/R ratios.
+  
+  get reactancePerKm() {
+    // Approximate resistance based on reactance per km and voltage.
+    // The curve 28 * (kV ^ -1.9) fits quite well on the Table 3 data.
+    return 28 * Math.pow(this.kilovolts, -1.9);
+  }
+  
+  get resistancePerKm() {
+    // Approximate resistance based on reactance per km and voltage.
+    // The line 0.032 * kV + 1 fits quite well on the Table 4 data.
+    // NOTE: Scaled by 0.003 because approximation gave unrealistic
+    // high losses. This is a "quick fix" for lack of better knowledge.
+    return 0.003 * this.reactancePerKm / (0.032 * this.kilovolts + 1);
+  }
+
+  get asXML() {
+    let p = ` loss-approximation="${this.loss_approximation}"`;
+    if(this.kirchhoff) p += ' kirchhoff="1"';
+    return ['<grid', p, '><id>', this.id,
+        '</id><name>', xmlEncoded(this.name),
+        '</name><notes>', xmlEncoded(this.comments),
+        '</notes><color>', this.color,
+        '</color><kilovolts>', this.kilovolts,
+        '</kilovolts><power-unit>', this.power_unit,
+        '</power-unit></grid>'].join('');
+  }
+  
+  initFromXML(node) {
+    this.loss_approximation = safeStrToInt(
+        nodeParameterValue(node, 'loss-approximation'), 0);
+    this.name = xmlDecoded(nodeContentByTag(node, 'name'));
+    this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
+    this.kirchhoff = nodeParameterValue(node, 'kirchhoff') === '1';
+    this.color = nodeContentByTag(node, 'color');
+    this.kilovolts = safeStrToFloat(nodeContentByTag(node, 'kilovolts'), 150);
+    this.power_unit = nodeContentByTag(node, 'power-unit') || 'MW';
+  }
+  
+} // END of class PowerGrid
+
+
 // CLASS Actor
 class Actor {
   constructor(name) {
     this.name = name;
     this.comments = '';
+    // By default, actors are labeled in formulas with the letter a.
+    this.TEX_id = 'a';
     // Actors have 1 input attribute: W
     this.weight = new Expression(this, 'W', '1');
     // Actors have 3 result attributes: CF, CI and CO
@@ -4823,11 +4996,13 @@ class Actor {
     return ['<actor round-flags="', this.round_flags,
         '"><name>', xmlEncoded(this.name),
         '</name><notes>', xmlEncoded(this.comments),
-        '</notes><weight>', this.weight.asXML,
+        '</notes><tex-id>', this.TEX_id,
+        '</tex-id><weight>', this.weight.asXML,
         '</weight></actor>'].join('');
   }
   
   initFromXML(node) {
+    this.TEX_id = xmlDecoded(nodeContentByTag(node, 'tex-id') || 'a');
     this.weight.text = xmlDecoded(nodeContentByTag(node, 'weight'));
     if(IO_CONTEXT) IO_CONTEXT.rewrite(this.weight);
     this.comments = nodeContentByTag(node, 'notes');
@@ -5451,12 +5626,12 @@ class NodeBox extends ObjectWithXYWH {
   }
   
   get infoLineName() {
-    // Returns display name plus VM variable indices
+    // Return display name plus VM variable indices when debugging.
     let n = this.displayName;
-    // NOTE: Display nothing if entity is "black-boxed"
+    // NOTE: Display nothing if entity is "black-boxed".
     if(n.startsWith(UI.BLACK_BOX)) return '';
     n = `<em>${this.type}:</em> ${n}`;
-    // For clusters, add how many processes and products they contain
+    // For clusters, add how many processes and products they contain.
     if(this instanceof Cluster) {
       let d = '';
       if(this.all_processes) {
@@ -5467,7 +5642,19 @@ class NodeBox extends ObjectWithXYWH {
       }
       if(d) n += `<span class="node-details">${d}</span>`;
     }
-    if(DEBUGGING && MODEL.solved) {
+    if(!MODEL.solved) return n;
+    const g = this.grid;
+    if(g) {
+      const
+          ub = VM.sig4Dig(this.upper_bound.result(MODEL.t)),
+          l = this.length_in_km,
+          x = VM.sig4Dig(g.reactancePerKm * l, true),
+          r = VM.sig4Dig(g.resistancePerKm * l, true),
+          alr = VM.sig4Dig(this.actualLossRate(MODEL.t) * 100, true);
+      n += ` [${g.name}] ${ub} ${g.power_unit}, ${l} km,` +
+       `  x = ${x}, R = ${r}, loss rate = ${alr}%`;
+    }
+    if(DEBUGGING) {
       n += ' [';
       if(this instanceof Process || this instanceof Product) {
         n += this.level_var_index;
@@ -5559,6 +5746,15 @@ class NodeBox extends ObjectWithXYWH {
     // Change this object's name and actor.
     this.actor = MODEL.addActor(actor_name);
     this.name = name;
+    // Ensure that actor cash flow data products have valid properties
+    if(this.name.startsWith('$')) {
+      this.scale_unit = MODEL.currency_unit;
+      this.initial_level.text = '';
+      this.price.text = '';
+      this.is_data = true;
+      this.is_buffer = false;
+      this.integer_level = false;
+    }
     // Update actor list in case some actor name is no longer used.
     MODEL.cleanUpActors();
     MODEL.replaceEntityInExpressions(old_name, this.displayName);
@@ -7338,9 +7534,12 @@ class Node extends NodeBox {
   }
   
   get needsOnOffData() {
-    // Returns TRUE if this node requires a binary ON/OFF variable
+    // Return TRUE if this node requires a binary ON/OFF variable.
     // This means that at least one output link must have the "start-up",
-    // "positive", "zero" or "spinning reserve" multiplier
+    // "positive", "zero", "shut-down", "spinning reserve" or
+    // "first commit" multiplier.
+    // NOTE: As of version 2.0.0, power grid processes also need ON/OFF.
+    if(this.grid) return true;
     for(let i = 0; i < this.outputs.length; i++) {
       if(VM.LM_NEEDING_ON_OFF.indexOf(this.outputs[i].multiplier) >= 0) {
         return true;
@@ -7349,8 +7548,19 @@ class Node extends NodeBox {
     return false;
   }
 
+  get needsIsZeroData() {
+    // Return TRUE if this node requires a binary IS ZERO variable.
+    // This means that at least one output link must have the "zero"
+    // multiplier.
+    for(let i = 0; i < this.outputs.length; i++) {
+      if(this.outputs[i].multiplier === VM.LM_ZERO) return true;
+    }
+    return false;
+  }
+
   get needsStartUpData() {
-    // Returns TRUE iff this node has an output data link for start-up 
+    // Return TRUE iff this node has an output data link for start-up
+    // or first commit.
     for(let i = 0; i < this.outputs.length; i++) {
       const m = this.outputs[i].multiplier;
       if(m === VM.LM_STARTUP || m === VM.LM_FIRST_COMMIT) return true;
@@ -7359,16 +7569,15 @@ class Node extends NodeBox {
   }
   
   get needsShutDownData() {
-    // Returns TRUE iff this node has an output data link for shut-down 
+    // Return TRUE iff this node has an output data link for shut-down. 
     for(let i = 0; i < this.outputs.length; i++) {
-      const m = this.outputs[i].multiplier;
-      if(m === VM.LM_SHUTDOWN) return true;
+      if(this.outputs[i].multiplier === VM.LM_SHUTDOWN) return true;
     }
     return false;
   }
   
   get needsFirstCommitData() {
-    // Returns TRUE iff this node has an output data link for first commit 
+    // Return TRUE iff this node has an output data link for first commit. 
     for(let i = 0; i < this.outputs.length; i++) {
       if(this.outputs[i].multiplier === VM.LM_FIRST_COMMIT) return true;
     }
@@ -7376,7 +7585,7 @@ class Node extends NodeBox {
   }
   
   get linksToFirstCommitDataProduct() {
-    // Returns data product P iff this node has an output link to P, and P has
+    // Return data product P iff this node has an output link to P, and P has
     // an output link for first commit 
     for(let i = 0; i < this.outputs.length; i++) {
       const p = this.outputs[i].to_node;
@@ -7395,7 +7604,12 @@ class Node extends NodeBox {
   }
   
   setPredecessors() {
-    // Recursive function to create list of all nodes that precede this one
+    // Recursive function to create list of all nodes that precede this one.
+    // NOTE: As of version 2.0.0, feedback links are no longer displayed
+    // as such. To permit re-enabling this function, the functional part
+    // of this method has been commented out.
+ 
+/*
     for(let i = 0; i < this.inputs.length; i++) {
       const l = this.inputs[i];
       if(!l.visited) {
@@ -7413,6 +7627,7 @@ class Node extends NodeBox {
         }
       }
     }
+*/
     return this.predecessors;
   }
   
@@ -7557,6 +7772,99 @@ class Node extends NodeBox {
     }
     return nn;
   }
+  
+  get TEXforBinaries() {
+    // Return LaTeX code for formulas that compute binary variables.
+    // In the equations, binary variables are underlined to distinguish
+    // them from (semi-)continuous variables.
+    const
+        NL = '\\\\\n',
+        tex = [NL],
+        x = (this.level_to_zero ? '\\hat{x}' : 'x'),
+        sub = (MODEL.start_period !== MODEL.end_period ?
+            '_{' + this.code + ',t}' : '_' + this.code),
+        sub_1 = '_{' + this.code +
+            (MODEL.start_period !== MODEL.end_period ? ',t-1}' : ',0}');
+    if(this.needsOnOffData) {
+      // Equations to compute OO variable (denoted as u for "up").
+      // (a)  L[t] - LB[t]*OO[t] >= 0
+      tex.push(x + sub, '- LB' + sub, '\\mathbf{u}' + sub, '\\ge 0', NL);
+      // (b)  L[t] - UB[t]*OO[t] <= 0
+      tex.push(x + sub, '- UB' + sub, '\\mathbf{u}' + sub, '\\le 0', NL);
+    }
+    if(this.needsIsZeroData) {
+      // Equation to compute IZ variable (denoted as d for "down").
+      // (c) OO[t] + IZ[t] = 1
+      tex.push('\\mathbf{u}' + sub, '+ \\mathbf{d}' + sub, '= 0', NL);
+      // (d) L[t] + IZ[t] >= LB[t]
+      // NOTE: for semicontinuous variables, use 0 instead of LB[t]
+      tex.push(x + sub, '+ \\mathbf{d}' + sub, '\\ge',
+          (this.level_to_zero ? '0' : 'LB' + sub), NL);
+    }
+    if(this.needsStartUpData) {
+      // Equation to compute start-up variable (denoted as su).
+      // (e) OO[t-1] - OO[t] + SU[t] >= 0
+      tex.push('\\mathbf{u}' + sub_1, '- \\mathbf{u}' + sub, 
+          '+ \\mathbf{su}' + sub, '\\ge 0', NL);
+      // (f) OO[t] - SU[t] >= 0
+      tex.push('\\mathbf{u}' + sub, '- \\mathbf{su}' + sub, '\\ge 0', NL);
+      // (g) OO[t-1] + OO[t] + SU[t] <= 2
+      tex.push('\\mathbf{u}' + sub_1, '+ \\mathbf{u}' + sub,
+          '+ \\mathbf{su}' + sub, '\\le 2', NL);
+    }
+    if(this.needsShutDownData) {
+      // Equation to compute shutdown variable (denoted as sd-circumflex).
+      // (e2) OO[t] - OO[t-1] + SD[t] >= 0
+      tex.push('\\mathbf{u}' + sub, '- \\mathbf{u}' + sub_1, 
+          '+ \\mathbf{sd}' + sub, '\\ge 0', NL);
+      // (f2) OO[t] + SD[t] <= 1
+      tex.push('\\mathbf{u}' + sub, '+ \\mathbf{sd}' + sub, '\\le 1', NL);
+      // (g2) SD[t] - OO[t-1] - OO[t] <= 0
+      tex.push('\\mathbf{sd}' + sub, '- \\mathbf{u}' + sub_1,
+          '- \\mathbf{su}' + sub, '\\le 0', NL);
+    }
+    if(this.needsFirstCommitData) {
+      // Equation to compute first commit variables (denoted as fc).
+      // To detect a first commit, start-ups are counted using an extra
+      // variable SC (denoted as suc) and then similar equations are
+      // added to detect "start-up" for this counter. This means one more
+      // binary SO (denoted as suo for "start-up occurred").
+      // (h)  SC[t] - SC[t-1] - SU[t] = 0
+      tex.push('\\mathbf{suc}' + sub, '- \\mathbf{suc}' + sub_1,
+          '- \\mathbf{su}' + sub, '= 0', NL);
+      // (i)  SC[t] - SO[t] >= 0
+      tex.push('\\mathbf{suc}' + sub, '- \\mathbf{suo}' + sub, '\\ge 0', NL);
+      // (j)  SC[t] - run length * SO[t] <= 0
+      tex.push('\\mathbf{suc}' + sub, '- N\\! \\mathbf{suo}' + sub, '\\le 0', NL);
+      // (k)  SO[t-1] - SO[t] + FC[t] >= 0
+      tex.push('\\mathbf{suo}' + sub_1, '- \\mathbf{suc}' + sub,
+          '+ \\mathbf{fc}' + sub, '\\ge 0', NL);
+      // (l)  SO[t] - FC[t] >= 0
+      tex.push('\\mathbf{suo}' + sub, '- \\mathbf{fc}' + sub, '\\ge 0', NL);
+      // (m)  SO[t-1] + SO[t] + FC[t] <= 2
+      tex.push('\\mathbf{suo}' + sub_1, '+ \\mathbf{suo}' + sub,
+          '+ \\mathbf{fc}' + sub, '\\le 2', NL);      
+    }
+
+    /*
+       To calculate the peak increase values, we need two continuous
+       "chunk variables", i.e., only 1 tableau column per chunk, not 1 for
+       each time step. These variables BPI and CPI will compute the highest
+       value (for all t in the block (B) and for the chunk (C)) of the
+       difference L[t] - block peak (BP) of previous block. This requires
+       one equation for every t = 1, ..., block length:
+       (n) L[t] - BPI[b] <= BP[b-1]  (where b denotes the block number)
+       plus one equation for every t = block length + 1 to chunk length:
+       (o) L[t] - BPI[b] - CPI[b] <= BP[b-1]
+       This ensures that CPI is the *additional* increase in the look-ahead 
+       Then use BPI[b] in first time step if block, and CPI[b] at first
+       time step of the look-ahead period to compute the actual flow for
+       the "peak increase" links. For all other time steps this AF equals 0.
+
+    */
+
+    return tex.join(' ');
+  }
 
 } // END of class Node
   
@@ -7565,6 +7873,8 @@ class Node extends NodeBox {
 class Process extends Node {
   constructor(cluster, name, actor) {
     super(cluster, name, actor);
+    // By default, processes have the letter p, products the letter q.
+    this.TEX_id = 'p';
     // NOTE: A process can change level once in PACE steps (default 1/1).
     // This means that for a simulation perio of N time steps, this process will
     // have a vector of only N / PACE decision variables (plus associated
@@ -7580,6 +7890,11 @@ class Process extends Node {
     this.level_to_zero = false;
     // Process node can be collapsed to take up less space in the diagram
     this.collapsed = false;
+    // Process can represent a power grid element, in which case it needs
+    // properties for calculating power flow.
+    this.power_grid = null;
+    this.length_in_km = 0;
+    this.reactance = 0;
     // Processes have 3 more result attributes: CP, CF, CI and CO
     this.cash_flow = [];
     this.cash_in = [];
@@ -7599,6 +7914,36 @@ class Process extends Node {
   get typeLetter() {
     return 'P';
   }
+  
+  get grid() {
+    if(MODEL.with_power_flow) return this.power_grid;
+    return null;
+  }
+  
+  get gridEdge() {
+    // Return "FROM node -> TO node" as string if this is a grid process.
+    const g = this.grid;
+    if(!g) return '';
+    let fn = null,
+        tn = null;
+    for(let i = 0; i < this.inputs.length; i++) {
+      const l = this.inputs[i];
+      if(l.multiplier == VM.LM_LEVEL) {
+        fn = l.from_node;
+        break;
+      }
+    }
+    for(let i = 0; i < this.outputs.length; i++) {
+      const l = this.outputs[i];
+      if(l.multiplier == VM.LM_LEVEL && !l.to_node.is_data) {
+        tn = l.from_node;
+        break;
+      }
+    }
+    fn = (fn ? fn.displayName : '???');
+    tn = (tn ? tn.displayName : '???');
+    return `${fn} ${UI.LINK_ARROW} ${tn}`;
+  }
 
   get attributes() {
     const a = {name: this.displayName};
@@ -7649,20 +7994,25 @@ class Process extends Node {
     if(this.integer_level) p += ' integer-level="1"';
     if(this.level_to_zero) p += ' level-to-zero="1"';
     if(this.equal_bounds) p += ' equal-bounds="1"';
+    // NOTE: Save power grid related properties even when grid element
+    // is not checked (so properties re-appear when re-checked).
     return ['<process', p, '><name>',  xmlEncoded(n),
         '</name><owner>', xmlEncoded(this.actor.name),
         '</owner><notes>', cmnts,
         '</notes><upper-bound>', this.upper_bound.asXML,
         '</upper-bound><lower-bound>', this.lower_bound.asXML,
         '</lower-bound><initial-level>', this.initial_level.asXML,
-        '</initial-level><pace>', this.pace_expression.asXML,
-        '</pace><x-coord>', x,
+        '</initial-level><tex-id>', this.TEX_id,
+        '</tex-id><pace>', this.pace_expression.asXML,
+        '</pace><grid-id>', (this.power_grid ? this.power_grid.id : ''),
+        '</grid-id><length>', this.length_in_km,
+        '</length><x-coord>', x,
         '</x-coord><y-coord>', y,
         '</y-coord></process>'].join('');
   }
 
   initFromXML(node) {
-    // NOTE: do not set code while importing, as new code must be assigned!
+    // NOTE: Do not set code while importing, as new code must be assigned!
     if(!IO_CONTEXT) this.code = nodeParameterValue(node, 'code');
     this.collapsed = nodeParameterValue(node, 'collapsed') === '1';
     this.integer_level = nodeParameterValue(node, 'integer-level') === '1';
@@ -7672,23 +8022,28 @@ class Process extends Node {
     this.comments = xmlDecoded(nodeContentByTag(node, 'notes'));
     this.lower_bound.text = xmlDecoded(nodeContentByTag(node, 'lower-bound'));
     this.upper_bound.text = xmlDecoded(nodeContentByTag(node, 'upper-bound'));
-    // legacy models can have LB and UB hexadecimal data strings
+    // legacy models can have LB and UB hexadecimal data strings.
     this.convertLegacyBoundData(nodeContentByTag(node, 'lower-bound-data'),
         nodeContentByTag(node, 'upper-bound-data'));
     if(nodeParameterValue(node, 'reversible') === '1') {
-      // For legacy "reversible" processes, the LB is set to -UB 
+      // For legacy "reversible" processes, the LB is set to -UB.
       this.lower_bound.text = '-' + this.upper_bound.text;
     }
-    // NOTE: legacy models have no initial level field => default to 0 
+    // NOTE: Legacy models have no initial level field => default to 0.
     const ilt = xmlDecoded(nodeContentByTag(node, 'initial-level'));
     this.initial_level.text = ilt || '0';
-    // NOTE: until version 1.0.16, pace was stored as a node parameter; 
+    // NOTE: Until version 1.0.16, pace was stored as a node parameter. 
     const pace_text = nodeParameterValue(node, 'pace') + 
         xmlDecoded(nodeContentByTag(node, 'pace'));
-    // NOTE: legacy models have no pace field => default to 1 
+    // NOTE: Legacy models have no pace field => default to 1.
     this.pace_expression.text = pace_text || '1';
-    // NOTE: immediately evaluate pace expression as integer
+    // NOTE: Immediately evaluate pace expression as integer.
     this.pace = Math.max(1, Math.floor(this.pace_expression.result(1)));
+    this.TEX_id = xmlDecoded(nodeContentByTag(node, 'tex-id') || 'p');
+    this.power_grid = MODEL.powerGridByID(nodeContentByTag(node, 'grid-id'));
+    this.length_in_km = safeStrToFloat(nodeContentByTag(node, 'length'), 0);
+    // NOTE: Reactance may be an empty string to indicate "infer from length".
+    this.reactance = nodeContentByTag(node, 'reactance');
     this.x = safeStrToInt(nodeContentByTag(node, 'x-coord'));
     this.y = safeStrToInt(nodeContentByTag(node, 'y-coord'));
     if(IO_CONTEXT) {
@@ -7784,6 +8139,50 @@ class Process extends Node {
     return (ub.isStatic ? ub.result(0) : VM.PLUS_INFINITY);
   }
   
+  lossRates(t) {
+    // Returns a list of loss rates for the slope variables associated
+    // with this process at time t.
+    // NOTE: Rates depend on upper bound, which may be dynamic.
+    // Source: section 4.4 of Neumann et al. (2022) Assessments of linear
+    // power flow and transmission loss approximations in coordinated
+    // capacity expansion problem. Applied Energy, 314: 118859.
+    // https://doi.org/10.1016/j.apenergy.2022.118859
+    if(!(this.grid && this.grid.loss_approximation)) return [0];
+    let ub = this.upper_bound.result(t);
+    if(ub >= VM.PLUS_INFINITY) {
+      // When UB = +INF, this is interpreted as "unlimited", which is
+      // implemented as 99999 grid power units.
+      ub = VM.UNLIMITED_POWER_FLOW;
+    }
+    const
+        la = this.grid.loss_approximation,
+        // Let m be the highest per unit loss. 
+        m = ub * this.grid.resistancePerKm * this.length_in_km;
+    // Linear loss approximation: 1 slope from 0 to m.
+    if(la === 1) return [m];
+    // 2-slope approximation of quadratic curve.
+    if(la === 2) return [m * 0.25, m * 0.75];
+    // 3-slope approximation of quadratic curve.
+    return [m / 9, m * 3/9, m * 5/9];
+  }
+  
+  actualLossRate(t) {
+    // Return the actual loss rate, which depends on the power flow
+    // and the max. power flow (process UB).
+    const g = this.grid;
+    if(!g) return 0;
+    const
+        lr = this.lossRates(t),
+        apl = Math.abs(this.actualLevel(t)),
+        ub = this.upper_bound.result(t),
+        la = g.loss_approximation,
+        // Prevent division by 0.
+        slope = (ub < VM.NEAR_ZERO ? 0 :
+            // NOTE: Index may exceed # slopes - 1 when level = UB.
+            Math.min(la - 1, Math.floor(apl * la / ub)));
+    return lr[slope];
+  }
+  
   copyPropertiesFrom(p) {
     // Set properties to be identical to those of process `p`
     this.x = p.x;
@@ -7797,6 +8196,7 @@ class Process extends Node {
     this.equal_bounds = p.equal_bounds;
     this.level_to_zero = p.level_to_zero;
     this.collapsed = p.collapsed;
+    this.TEX_id = p.TEX_id;
   }
 
   differences(p) {
@@ -7809,6 +8209,32 @@ class Process extends Node {
     if(Object.keys(d).length > 0) return d;
     return null;
   }
+  
+  get TEXcode() {
+    // Return LaTeX code for mathematical formula of constraints defined
+    // by this process.
+    const
+        NL = '\\\\\n',
+        tex = [NL],
+        sub = (MODEL.start_period !== MODEL.end_period ?
+            '_{' + this.TEX_id + ',t}' : '_' + this.TEX_id),
+        lb = (this.lower_bound.defined ? 'LB' + sub + ' \\le' : ''),
+        ub = (this.upper_bound.defined ? '\\le UB' + sub : '');
+    // Integer constraint if applicable.
+    if(this.integer_level) tex.push('x' + sub, '\\in \\mathbb{Z}', NL);
+    // Bound constraints...
+    if(lb && this.equal_bounds) {
+      tex.push('x' + sub, '= LB' + sub);      
+    } else if(lb || ub) {
+      tex.push(lb, 'x' + sub, ub);
+    }
+    // ... with semi-continuity if applicable. 
+    if(lb && this.level_to_zero) tex.push('\\vee x' + sub, '= 0');
+    tex.push(NL);
+    // Add equations for associated binary variables.
+    tex.push(this.TEXforBinaries);
+    return tex.join(' ');
+  }
 
 } // END of class Process
 
@@ -7818,6 +8244,8 @@ class Product extends Node {
   constructor(cluster, name, actor) {
     super(cluster, name, actor);
     this.scale_unit = MODEL.default_unit;
+    // By default, processes have the letter p, products the letter q.
+    this.TEX_id = 'p';
     // For products, the default bounds are [0, 0], and modeler-defined bounds
     // typically are equal
     this.equal_bounds = true;
@@ -7856,6 +8284,10 @@ class Product extends Node {
     return 'Q';
   }
   
+  get grid() {
+    return null;
+  }
+  
   get attributes() {
     const a = {name: this.displayName};
     a.LB = this.lower_bound.asAttribute;
@@ -8113,7 +8545,8 @@ class Product extends Node {
       '</lower-bound><price>', this.price.asXML,
       '</price><x-coord>', x,
       '</x-coord><y-coord>', y,
-      '</y-coord></product>'].join('');
+      '</y-coord><tex-id>', this.TEX_id,
+      '</tex-id></product>'].join('');
     return xml;
   }
 
@@ -8132,6 +8565,7 @@ class Product extends Node {
         nodeParameterValue(node, 'hidden')) === '1';
     this.scale_unit = MODEL.addScaleUnit(
         xmlDecoded(nodeContentByTag(node, 'unit')));
+    this.TEX_id = xmlDecoded(nodeContentByTag(node, 'tex-id') || 'q');
     // Legacy models have tag "profit" instead of "price"
     let pp = nodeContentByTag(node, 'price');
     if(!pp) pp = nodeContentByTag(node, 'profit');
@@ -8295,6 +8729,7 @@ class Product extends Node {
     this.no_slack = p.no_slack;
     this.initial_level.text = p.initial_level.text;
     this.integer_level = p.integer_level;
+    this.TEX_id = p.TEX_id;
     // NOTE: do not copy the `no_links` property, nor the import/export status
   }
 
@@ -8305,6 +8740,70 @@ class Product extends Node {
     return null;
   }
 
+  get TEXcode() {
+    // Return LaTeX code for mathematical formula of constraints defined
+    // by this product.
+    const
+        NL = '\\\\\n',
+        tex = [NL],
+        x = (this.level_to_zero ? '\\hat{x}' : 'x'),
+        sub = (MODEL.start_period !== MODEL.end_period ?
+            '_{' + this.TEX_id + ',t}' : '_' + this.TEX_id),
+        param = (x, p) => {
+            if(!x.defined) return '';
+            const v = safeStrToFloat(x.text, p + sub);
+            if(typeof v === 'number') return VM.sig4Dig(v);
+            return v;
+          };
+    // Integer constraint if applicable.
+    if(this.integer_level) tex.push(x + sub, '\\in \\mathbb{Z}', NL);
+    // Bounds can be explicit...
+    let lb = param(this.lower_bound, 'LB'),
+        ub = param(this.upper_bound, 'UB');
+    if(lb && this.equal_bounds) ub = lb;
+    // ... or implicit.
+    if(!lb && !this.isSourceNode) lb = '0';
+    if(!ub && !this.isSinkNode) ub = '0';
+    // Add the bound constraints.
+    if(lb && ub) {
+      if(lb === ub) {
+        tex.push(x + sub, '=', lb, NL);
+      } else {
+        tex.push(lb, '\\le ' + x + sub, '\\le', ub, NL);
+      }
+    } else if(lb) {
+      tex.push(x + sub, '\\ge', lb, NL);
+    } else if(ub) {
+      tex.push(x + sub, '\\le', ub, NL);      
+    }
+    // Add the "balance" constraint for links.
+    tex.push(x + sub, '=');
+    if(this.is_buffer) {
+      // Insert X[t-1]
+      tex.push(x + '_{' + this.code +
+            (MODEL.start_period !== MODEL.end_period ? ',t-1}' : ',0}'));
+    }
+    let first = true;
+    for(let i = 0; i < this.inputs.length; i++) {
+      let ltex = this.inputs[i].TEXcode.trim();
+      if(!first && !ltex.startsWith('-')) tex.push('+');
+      tex.push(ltex);
+      first = false;
+    }
+    for(let i = 0; i < this.outputs.length; i++) {
+      let ltex = this.outputs[i].TEXcode.trim();
+      if(ltex.trim().startsWith('-')) {
+        ltex = ltex.substring(1);
+        if(!first) {
+          ltex = '+ ' + ltex;
+          first = false;
+        }
+      }
+      tex.push(ltex);
+    }
+    return tex.join(' ');
+  }
+  
 } // END of class Product
 
 
@@ -8515,6 +9014,8 @@ class Link {
   actualDelay(t) {
     // Scale the delay expression value of this link to a discrete number
     // of time steps on the model time scale.
+    // NOTE: For links from grid processes, delays are ignored.
+    if(this.from_node.grid) return 0;
     let d = Math.floor(VM.SIG_DIF_FROM_ZERO + this.flow_delay.result(t));
     // NOTE: Negative values are permitted. This might invalidate cost
     // price calculation -- to be checked!!
@@ -8551,6 +9052,63 @@ class Link {
             fc.containsProduct(this.to_node))) return true;
     return false;
   }
+  
+  get TEXcode() {
+    // Return LaTeX code for the term for this link in the formula
+    // for its TO node if this is a product. The TEX routines for
+    // products will take care of the sign of this term.
+    const
+        dyn = MODEL.start_period !== MODEL.end_period,
+        x = (this.from_node.level_to_zero ? '\\hat(x)' : 'x'),
+        fsub = (dyn ?
+            '_{' + this.from_node.TEX_id + ',t}' :
+            '_' + this.from_node.TEX_id),
+        fsub_i = fsub.replace(',t}', ',i}'),
+        rsub = (dyn ?
+            '_{' + this.from_node.TEX_id +
+            ' \\rightarrow ' + this.to_node.TEX_id + ',t}' :
+            '_' + this.from_node.TEX_id),
+        param = (x, p, sub) => {
+            if(!x.defined) return '';
+            const v = safeStrToFloat(x.text, p + sub);
+            if(typeof v === 'number') return (v === 1 ? '' :
+                (v === -1 ? '-' : VM.sig4Dig(v)));
+            return v;
+          },
+        r = param(this.relative_rate, 'R', rsub),
+        d = param(this.flow_delay, '\\delta', rsub),
+        dn = safeStrToInt(d, '?'),
+        d_1 = (!d || typeof dn === 'number' ? dn + 1 : d + '+1');
+    if(this.multiplier === VM.LM_LEVEL) {
+      return r + ' ' + x + fsub;
+    } else if(this.multiplier === VM.LM_THROUGHPUT) {
+      return 'THR';
+    } else if(this.multiplier === VM.LM_INCREASE) {
+      return 'INC';
+    } else if(this.multiplier === VM.LM_SUM) {
+      if(d) return r + '\\sum_{i=t-' + d + '}^{t}{' + x + fsub_i + '}';
+      return x + fsub;
+    } else if(this.multiplier === VM.LM_MEAN) {
+      if(d) return r + '{1 \\over {' + d_1 + '}} \sum_{i=t-' +
+          d + '}^{t}{' + x + fsub_i + '}';
+      return x + fsub;
+    } else if(this.multiplier === VM.LM_STARTUP) {
+      return r + ' \\mathbf{su}' + fsub;
+    } else if(this.multiplier === VM.LM_POSITIVE) {
+      return r + '\\mathbf{u}' + fsub;
+    } else if(this.multiplier === VM.LM_ZERO) {
+      return r + '\\mathbf{d}' + fsub;    
+    } else if(this.multiplier === VM.LM_SPINNING_RESERVE) {
+      return 'SPIN';
+    } else if(this.multiplier === VM.LM_FIRST_COMMIT) {
+      return r + '\\mathbf{fc}' + fsub;    
+    } else if(this.multiplier === VM.LM_SHUTDOWN) {
+      return r + '\\mathbf{sd}' + fsub;    
+    } else if(this.multiplier === VM.LM_PEAK_INC) {
+      return 'PEAK';
+    }
+    return 'Unknown link multiplier: ' + this.multiplier;
+  }
 
   // NOTE: links do not draw themselves; they are visualized by Arrow objects
   
@@ -8584,6 +9142,7 @@ class DatasetModifier {
     // NOTE: Identifier will be unique only for equations.
     return UI.nameToID(this.selector);
   }
+
   get displayName() {
     // NOTE: When "displayed", dataset modifiers have their selector as name.
     return this.selector;
@@ -9030,6 +9589,10 @@ class Dataset {
       }
       // Reduce inner spaces to one, and trim outer spaces.
       s = s.replace(/\s+/g, ' ').trim();
+      if(!s) {
+        UI.warn(`Invalid equation name "${selector}"`);
+        return null;
+      }
       if(s.startsWith(':')) {
         // Methods must have no spaces directly after their leading colon,
         // and must not contain other colons.
@@ -9053,21 +9616,9 @@ class Dataset {
         return null;
       }
     } else {
-      // Standard dataset modifier selectors are much more restricted, but
-      // to be user-friendly, special chars are removed automatically.
-      s = s.replace(/[^a-zA-Z0-9\+\-\%\_\*\?]/g, '');
-      let msg = '';
-      if(s !== selector) msg = UI.WARNING.SELECTOR_SYNTAX;
-      // A selector can only contain 1 star.
-      if(s.indexOf('*') !== s.lastIndexOf('*')) msg = UI.WARNING.SINGLE_WILDCARD;
-      if(msg) {
-        UI.warn(msg);
-        return null;
-      }
-    }
-    if(s.trim().length === 0) {
-      UI.warn(UI.WARNING.INVALID_SELECTOR);
-      return null;
+      // Standard dataset modifier selectors are much more restricted.
+      s = MODEL.validSelector(s);
+      if(!s) return;
     }
     // Then add a dataset modifier to this dataset.
     const id = UI.nameToID(s);
@@ -9270,7 +9821,8 @@ class ChartVariable {
     // the Linny-R entity and its attribute, followed by its scale factor
     // unless it equals 1 (no scaling).
     const sf = (this.scale_factor === 1 ? '' :
-        ` (x${VM.sig4Dig(this.scale_factor)})`);
+        // NOTE: Pass tiny = TRUE to permit very small scaling factors.
+        ` (x${VM.sig4Dig(this.scale_factor, true)})`);
     // Display name of equation is just the equations dataset selector. 
     if(this.object instanceof DatasetModifier) {
       let eqn = this.object.selector;
@@ -9323,9 +9875,9 @@ class ChartVariable {
             ` wildcard-index="${this.wildcard_index}"` : ''),
         ` sorted="${this.sorted}"`,
         '><object-id>', xmlEncoded(id),
-        '</object-id><attribute>', this.attribute,
+        '</object-id><attribute>', xmlEncoded(this.attribute),
         '</attribute><color>', this.color,
-        '</color><scale-factor>', VM.sig4Dig(this.scale_factor),
+        '</color><scale-factor>', VM.sig4Dig(this.scale_factor, true),
         '</scale-factor><line-width>', VM.sig4Dig(this.line_width),
         '</line-width></chart-variable>'].join('');
     return xml;
@@ -9371,7 +9923,7 @@ class ChartVariable {
     this.wildcard_index = (wci ? parseInt(wci) : false);
     this.setProperties(
         obj,
-        nodeContentByTag(node, 'attribute'),
+        xmlDecoded(nodeContentByTag(node, 'attribute')),
         nodeParameterValue(node, 'stacked') === '1',
         nodeContentByTag(node, 'color'),
         safeStrToFloat(nodeContentByTag(node, 'scale-factor')),
@@ -9826,7 +10378,7 @@ class Chart {
   }
   
   timeScaleAsString(s) {
-    // Returns number `s` (in hours) as string with most appropriate time unit
+    // Return number `s` (in hours) as string with most appropriate time unit.
     if(s < 1/60) return VM.sig2Dig(s * 3600) + 's';
     if(s < 1) return VM.sig2Dig(s * 60) + 'm';
     if(s < 24) return VM.sig2Dig(s) + 'h';
@@ -10292,7 +10844,7 @@ class Chart {
         this.plot_max_y = maxy;
         y = miny;
         const labels = [];
-        while(y <= maxy) {
+        while(y - maxy <= VM.NEAR_ZERO) {
           // NOTE: Large values having exponents will be "neat" numbers,
           // so then display fewer decimals, as these will be zeroes.
           const v = (Math.abs(y) > 1e5 ? VM.sig2Dig(y) : VM.sig4Dig(y));
@@ -12061,61 +12613,345 @@ class Experiment {
 } // END of CLASS Experiment
 
 
+// CLASS BoundlineSelector
+class BoundlineSelector {
+  constructor(boundline, selector, x='', g=false) {
+    this.boundline = boundline;
+    this.selector = selector;
+    this.expression = new Expression(boundline, selector, x);
+    this.grouping = g;
+  }
+  
+  get asXML() {
+    // Prevent saving unidentified selectors.
+    if(this.selector.trim().length === 0) return '';
+    return ['<boundline-selector', (this.grouping ? ' points-x="1"' : ''),
+      '><selector>', xmlEncoded(this.selector),
+      '</selector><expression>', xmlEncoded(this.expression.text),
+      '</expression></boundline-selector>'].join('');
+  }
+
+  initFromXML(node) {
+    this.grouping = nodeParameterValue(node, 'points-x') === '1';
+    this.expression.text = xmlDecoded(nodeContentByTag(node, 'expression'));
+    if(IO_CONTEXT) {
+      // Contextualize the included expression.
+      IO_CONTEXT.rewrite(this.expression);
+    }
+  }
+
+} // END of class BoundlineSelector
+
+
 // CLASS BoundLine
 class BoundLine {
   constructor(c) {
     this.constraint = c;
     // Default bound line imposes no constraint: Y >= 0 for all X.
     this.points = [[0, 0], [100, 0]];
+    this.storePoints();
     this.type = VM.GE;
-    this.selectors = '';
+    // SVG string for contour of this bound line (to reduce computation).
     this.contour_path = '';
+    this.point_data = [];
+    this.url = '';
+    this.selectors = [];
+    this.selectors.push(new BoundlineSelector(this, '(default)', '0'));
   }
   
   get displayName() {
-    return this.constraint.displayName + ': ' +
-        VM.constraint_codes[this.type] + ' bound line #' +
-        this.constraint.bound_lines.indexOf(this) +
-        (this.selectors ? ` (${this.selectors}) ` : '');
+    return this.constraint.displayName + ' [' +
+        VM.constraint_codes[this.type] + '] bound line #' +
+        this.constraint.bound_lines.indexOf(this);
   }
 
   get copy() {
     // Return a "clone" of this bound line.
     let bl = new BoundLine(this.constraint);
-    bl.points.length = 0;
-    for(let i = 0; i < this.points.length; i++) {
-      const p = this.points[i];
-      bl.points.push([p[0], p[1]]);
-    }
+    bl.points_string = this.points_string;
+    // NOTE: Reset boundline to its initial "as edited" state.
+    bl.restorePoints();
     bl.type = this.type;
-    bl.selectors = this.selectors;
     bl.contour_path = this.contour_path;
+    bl.url = this.url;
+    bl.point_data.length = 0;
+    for(let i = 0; i < this.point_data.length; i++) {
+      bl.point_data.push(this.point_data[i].slice());
+    }
+    bl.selectors.length = 0;
+    for(let i = 0; i < this.selectors.length; i++) {
+      const s = this.selectors[i];
+      bl.selectors.push(new BoundlineSelector(s.boundline, s.selector,
+          s.expression.text, s.grouping));
+    }
     return bl;
   }
   
+  get staticLine() {
+    // Return TRUE if bound line has only the default selector, and this
+    // evaluates as default index = 0.
+    return this.selectors.length < 2 &&
+        this.selectors[0].expression.text === '0';
+  }
+  
+  get selectorList() {
+    // Return list of selector names only.
+    const sl = [];
+    for(let i = 0; i < this.selectors.length; i++) {
+      sl.push(this.selectors[i].selector);
+    }
+    return sl;
+  }
+
+  selectorByName(name) {
+    // Return index of selector `n` in the list, or null if not found.
+    for(let i = 0; i < this.selectors.length; i++) {
+      if(this.selectors[i].selector === name) return this.selectors[i];
+    }
+    return null;
+  }
+  
+  addSelector(name, x='') {
+    // Add selector if new, and return the named selector.
+    const s = this.selectorByName(name);
+    if(s) return s;
+    name = MODEL.validSelector(name);
+    if(name.indexOf('*') >= 0 || name.indexOf('?') >= 0) {
+      UI.warn('Bound line selector cannot contain wildcards');
+      return null;
+    }
+    if(name) {
+      const s = new BoundlineSelector(this, name, x);
+      this.selectors.push(s);
+      this.selectors.sort((a, b) => compareSelectors(a.selector, b.selector));
+      return s;
+    }
+    return null;
+  }
+
+  setPointsFromData(index) {
+    // Get point coordinates from bound line series data at index.
+    if(index > 0 && index <= this.point_data.length) {
+      const pd = this.point_data[index - 1];
+      this.points.length = 0;
+      for(let i = 0; i < pd.length; i += 2) {
+        this.points.push([pd[i] * 100, pd[i + 1] * 100]);
+      }
+    } else {
+      // Data is seen as 1-based array => default to original coordinates.
+      this.restorePoints();
+    }
+  }
+  
+  get activeSelectorIndex() {
+    // Return the number of the first boundline selector that matches the
+    // selector combination of the current experiment. Defaults to 0.
+    if(this.selectors.length < 2) return 0;
+    const x = MODEL.running_experiment;
+    if(!x) return 0;
+    for(let i = 1; i < this.selectors.length; i++) {
+      if(x.activeCombination.indexOf(this.selectors[i].selector) >= 0) {
+        return i;
+      }
+    }
+    return 0;
+  }
+  
+  setDynamicPoints(t, draw=false) {
+    // Adapt bound line point coordinates for the current time step
+    // for the running experiment (if any).
+    // NOTE: For speed, first perform the quick check whether this line
+    // is static, as then the points do not change.
+    if(this.staticLine) return;
+    const
+        bls = this.selectors[this.activeSelectorIndex],
+        r = bls.expression.result(t);
+    // Log errors on the console, but ignore them.
+    if(r <= VM.ERROR || r >= VM.EXCEPTION) {
+      console.log('ERROR: Exception in boundline selector expression', bls, r);
+    // NOTE: Double-check whether result is a grouping.
+    } else if(bls.grouping || Array.isArray(r)) {
+      this.validatePoints(r);
+      this.points.length = 0;
+      for(let i = 0; i < r.length; i += 2) {
+        this.points.push([r[i] * 100, r[i + 1] * 100]);
+      }
+    } else {
+      // NOTE: Data is not a time series but "array type" data. The time
+      // step co-determines the result. If modelers provide time series
+      // data, then they shoud use `t` (absolute time) as index expression,
+      // otherwise `rt` (relative time).
+      // NOTE: Result is a floating point number, so truncate it to integer.
+      this.setPointsFromData(Math.floor(r));
+    }
+    // Compute and store SVG for thumbnail only when needed.
+    if(draw) CONSTRAINT_EDITOR.setContourPath(this);
+  }
+  
+  restorePoints() {
+    // Restore point coordinates from original string.
+    this.points = JSON.parse(this.points_string);
+  }
+  
+  storePoints() {
+    // Set point coordinates to be the original string.
+    this.points_string = JSON.stringify(this.points);
+  }
+  
+  get pointsDataString() {
+    // Return point coordinates in data format (semicolon-separated numbers).
+    const pd = [];
+    for(let i = 0; i < this.points.length; i++) {
+      const p = this.points[i];
+      pd.push(p[0], p[1]);
+    }
+    return pd.join(';');
+  }
+
+  get maxPoints() {
+    // Return the highest number of points that this boundline can have.
+    this.restorePoints();
+    let n = this.points.length;
+    for(let i = 0; i < this.point_data.length; i++) {
+      n = Math.max(n, this.point_data[i].length);
+    }
+    const bls = this.selectors[this.activeSelectorIndex];
+    if(bls.grouping) {
+      const x = bls.expression;
+      if(x.isStatic) {
+        n = Math.max(n, x.result(1).length);
+      } else {
+        // For dynamic expressions, the grouping length may vary, so
+        // we must check for the complete run length.
+        for(let t = MODEL.start_period; t <= MODEL.end_period; t++) {
+          n = Math.max(n, x.result(t).length);
+        }
+      }
+    }
+    return n;
+  }
+
+  validatePoints(pd) {
+    if(!Array.isArray(pd)) {
+      console.log(pd); throw "Not an array";
+    }
+    // Ensure that array `pd` is a valid series of point coordinates.
+    if(pd.length) {
+      // Ensure that number of point coordinates is even (Y defaults to 0).
+      if(pd.length % 2) pd.push(0);
+      // Ensure that bound line has at least 2 points.
+      if(pd.length === 2) pd.push(1, 0);
+    } else {
+      // Default to horizontal line Y = 0.
+      pd.push(0, 0, 1, 0);
+    }
+    // NOTE: Point coordinates must lie between 0 and 1, and for the
+    // X-coordinates, it should hold that X[0] = 0, X[i+1] >= X[i],
+    // and X[N] = 1.
+    if(pd[0] !== 0) pd[0] = 0;
+    if(pd[pd.length - 2] !== 1) pd[pd.length - 2] = 1;
+    let min = 0,
+        last = 2;
+    for(let i = 1; i < pd.length; i++) {
+      const x = 1 - i % 2;
+      pd[i] = Math.min(1, Math.max(x ? min : 0, pd[i]));
+      if(x) {
+        // Keep track of first point having X = 1, as this should be the
+        // last point of the boundline.
+        if(pd[i] > min) last = i + 1;
+        min = pd[i];
+      }
+    }
+    // Truncate any points after the first point having X = 1.
+    pd.lengh = last;
+  }
+  
+  get pointDataString() {
+    // Point data is stored as separate lines of semicolon-separated
+    // floating point numbers, with N-digit precision to keep model files
+    // compact (default: N = 8)
+    let d = [];
+    for(let i = 0; i < this.point_data.length; i++) {
+      const
+          opd = this.point_data[i],
+          pd = [];
+      for(let j = 0; j < opd.length; j++) {
+        // Convert number to string with the desired precision.
+        const f = opd[j].toPrecision(CONFIGURATION.dataset_precision);
+        // Then parse it again, so that the number will be represented
+        // (by JavaScript) in the most compact representation.
+        pd.push(parseFloat(f));
+      }
+      this.validatePoints(pd);
+      // Push point coordinates as space-separated string.
+      d.push(pd.join(';'));
+    }
+    return d.join('\n');
+  }
+  
+  unpackPointDataString(str) {
+    // Convert separate lines of semicolon-separated point data to a
+    // list of lists of numbers.
+    this.point_data.length = 0;
+    str= str.trim();
+    if(str) {
+      const lines = str.split('\n');
+      for(let i = 0; i < lines.length; i++) {
+        const
+            numbers = lines[i].split(';'),
+            pd = [];
+        for(let i = 0; i < numbers.length; i++) {
+          pd.push(parseFloat(numbers[i].trim()));
+        }
+        this.validatePoints(pd);
+        this.point_data.push(pd);
+      }
+    }
+  }
+
   get asXML() {
-    return ['<bound-line type="', this.type,
-      '"><points>', JSON.stringify(this.points),
-      '</points><selectors>', xmlEncoded(this.selectors),
-      '</selectors><contour>', this.contour_path,
-      '</contour></bound-line>'].join('');
+    // NOTE: Save boundline always with points-as-last-edited.
+    this.restorePoints();
+    const xml = ['<bound-line type="', this.type,
+        '"><points>', JSON.stringify(this.points),
+        '</points><contour>', this.contour_path,
+        '</contour><url>', xmlEncoded(this.url),
+        '</url><point-data>', xmlEncoded(this.pointDataString),
+        '</point-data><selectors>'];
+    for(let i = 0; i < this.selectors.length; i++) {
+      xml.push(this.selectors[i].asXML);
+    }
+    xml.push('</selectors></bound-line>');
+    return xml.join('');
   }
   
   initFromXML(node) {
     this.type = safeStrToInt(nodeParameterValue(node, 'type'), VM.EQ);
-    this.points = JSON.parse(nodeContentByTag(node, 'points'));
-    this.selectors = xmlDecoded(nodeContentByTag(node, 'selectors'));
+    this.points_string = nodeContentByTag(node, 'points');
+    this.restorePoints();
     this.contour_path = nodeContentByTag(node, 'contour');
-  }
-  
-  get isActive() {
-    // Return TRUE if this line has no selectors, or if its selectors match
-    // with the selectors of the current experiment run.
-    if(!this.selectors) return true;
-    const x = MODEL.running_experiment;
-    if(!x) return false;
-    const ss = intersection(this.selectors.split(' '), x.active_combination);
-    return ss.length > 0;
+    this.url = xmlDecoded(nodeContentByTag(node, 'url'));
+    if(this.url) {
+      FILE_MANAGER.getRemoteData(this, this.url);
+    } else {
+      this.unpackPointDataString(
+          xmlDecoded(nodeContentByTag(node, 'point-data')));
+    }
+    const n = childNodeByTag(node, 'selectors');
+    if(n && n.childNodes && n.childNodes.length) {
+      // NOTE: Only overwrite default selector if XML specifies selectors.
+      this.selectors.length = 0;
+      for(let i = 0; i < n.childNodes.length; i++) {
+        const c = n.childNodes[i];
+        if(c.nodeName === 'boundline-selector') {
+          const
+              s = xmlDecoded(nodeContentByTag(c, 'selector')),
+              bls = new BoundlineSelector(this, s);
+          bls.initFromXML(c);
+          this.selectors.push(bls);
+        }
+      }
+    }
   }
   
   get needsNoSOS() {
@@ -12272,7 +13108,15 @@ class Constraint {
     this.bottom_y = 0;
     this.from_offset = 0;
     this.to_offset = 0;
-    // Slack information is a "sparse vector" that is filled after solving
+    this.reset();
+  }
+  
+  reset() {
+    // Reset run-dependent properties.
+    for(let i = 0; i < this.bound_lines.length; i++) {
+      this.bound_lines[i].current = -1;
+    }
+    // Slack information is a "sparse vector" that is filled after solving.
     this.slack_info = {};
   }
   
@@ -12285,9 +13129,10 @@ class Constraint {
   }
 
   get identifier() {
-    // NOTE: constraint IDs are based on the node codes rather than IDs, as
-    // this prevents problems when nodes are renamed; to ensure ID uniqueness,
-    // constraints have FOUR underscores between node IDs (links have three)
+    // NOTE: Constraint IDs are based on the node codes rather than IDs,
+    // as this prevents problems when nodes are renamed. To ensure ID
+    // uniqueness, constraints have FOUR underscores between node IDs
+    // (links have three).
     return this.from_node.code + '____' + this.to_node.code;
   }
   
@@ -12297,7 +13142,7 @@ class Constraint {
   }
 
   get attributes() {
-    // NOTE: this requires some thought, still!
+    // NOTE: This requires some thought, still!
     const a = {name: this.displayName};
     if(MODEL.infer_cost_prices) {
       a.SOC = this.share_of_cost * this.soc_direction;
@@ -12311,16 +13156,16 @@ class Constraint {
   }
 
   attributeValue(a) {
-    // Returns the computed result for attribute `a`: for constraints,
-    // only A (active) and SOC (share of cost)
-    if(a === 'A') return this.activeVector; // binary vector - see below
-    // NOTE: negative share indicates Y->X direction of cost sharing
-    if(a === 'SOC') return this.share_of_cost * this.soc_direction; // number
+    // Return the computed result for attribute `a`: for constraints,
+    // only A (active) and SOC (share of cost).
+    if(a === 'A') return this.activeVector; // Binary vector - see below.
+    // NOTE: Negative share indicates Y->X direction of cost sharing.
+    if(a === 'SOC') return this.share_of_cost * this.soc_direction;
     return null;
   }
   
   get setsEquality() {
-    // Returns TRUE iff this constraint has an EQ boundline
+    // Return TRUE iff this constraint has an EQ bound line.
     for(let i = 0; i < this.bound_lines.length; i++) {
       if(this.bound_lines[i].type === VM.EQ) return true;
     }
@@ -12328,35 +13173,42 @@ class Constraint {
   }
   
   active(t) {
-    // Returns 1 if (X, Y) is on the bound line, otherwise 0
+    // Return 1 if (X, Y) is on the bound line AND Y is not on its own
+    // bounds, otherwise 0.
     if(!MODEL.solved) return 0;
     const
         fn = this.from_node,
         tn = this.to_node;
     let lbx = fn.lower_bound.result(t),
         lby = tn.lower_bound.result(t);
-    // NOTE: LB of semi-continuous processes is 0 if LB > 0
+    // NOTE: LB of semi-continuous processes is 0 if LB > 0.
     if(lbx > 0 && fn instanceof Process & fn.level_to_zero) lbx = 0;
     if(lby > 0 && tn instanceof Process & tn.level_to_zero) lby = 0;
     const
         rx = fn.upper_bound.result(t) - lbx,
         ry = tn.upper_bound.result(t) - lby;
     // Prevent division by zero: when either range is 0, the constraint
-    // must be active
+    // must be active.
     if(rx < VM.NEAR_ZERO || ry < VM.NEAR_ZERO) return 1;
     // Otherwise, convert levels to % of range...
     const
         x = (fn.level[t] - lbx) / rx * 100,
         y = (tn.level[t] - lby) / ry * 100;
-    // ... and then check whether (%X, %Y) lies on the boundline
+    // ... and then check whether (%X, %Y) lies on the bound line.
     for(let i = 0; i < this.bound_lines.length; i++) {
       const bl = this.bound_lines[i];
-      if(bl.isActive && bl.pointOnLine(x, y)) return 1;
+      // Bound line does NOT constrain when Y is on its own bound.
+      if((bl.type === VM.LE && Math.abs(y - 100) < VM.NEAR_ZERO) ||
+          (bl.type === VM.GE && Math.abs(y) < VM.NEAR_ZERO)) continue;
+      // Actualize bound line points for current time step.
+      bl.setDynamicPoints(t);
+      if(bl.pointOnLine(x, y)) return 1;
     }
     return 0;
   }
   
   get activeVector() {
+    // Return active state for all time steps in the optimization period.
     const v = [];
     for(let t = 0; t < MODEL.runLength + 1; t++) v.push(this.active(t));
     return v;
@@ -12490,10 +13342,10 @@ class Constraint {
   
   addBoundLine() {
     // Adds a new bound line to this constraint, and returns this new line
-    // NOTE: returns the "base" bound line Y >= 0 (for any X) if it already
-    //       exists and has no specified selectors
+    // NOTE: Returns the "base" bound line Y >= 0 (for any X) if it already
+    //       exists and has no associated dataset.
     let bl = this.baseLine;
-    if(bl && !bl.selectors) return bl;
+    if(bl && bl.point_data.length === 0) return bl;
     bl = new BoundLine(this);
     this.bound_lines.push(bl);
     return bl;
@@ -12556,6 +13408,7 @@ if(NODE) module.exports = {
   BlockMessages: BlockMessages,
   ExperimentRun: ExperimentRun,
   Experiment: Experiment,
+  BoundlineSelector: BoundlineSelector,
   BoundLine: BoundLine,
   Constraint: Constraint
 };