linny-r 2.0.9 → 2.0.11

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

@@ -501,6 +501,30 @@ class LinnyRModel {
     return this.namedObjectByID(UI.nameToID(name));
   }
   
+  validVariable(name) {
+    // Return TRUE if `name` references an entity plus valid attribute.
+    const
+        ea = name.split('|'),
+        en = ea[0].trim(),
+        e = this.objectByName(en);
+    if(!e) return `Unknown model entity "${en}"`;
+    const
+        ao = ea[1].split('@'),
+        a = ao[0].trim();
+    // Valid if no attribute, as all entity types have a default attribute. 
+    if(!a) return true;
+    // Attribute should be valid for the entity type.
+    const
+        et = e.type.toLowerCase(),
+        ac = VM.attribute_codes[VM.entity_letter_codes[et]];
+    if(ac.indexOf(a) >= 0 || (e instanceof Cluster && a.startsWith('=')) ||
+        (e instanceof Dataset && e.modifiers.hasOwnProperty(a.toLowerCase()))) {
+      return true;
+    }
+    if(e instanceof Dataset) return `Dataset ${e.displayName} has no modifier "${a}"`;
+    return `Invalid attribute "${a}"`;
+  }
+  
   setByType(type) {
     // Return a "dictionary" object with entities of the specified types
     if(type === 'Process') return this.processes;
@@ -856,8 +880,10 @@ class LinnyRModel {
 
   indexOfChart(t) {
     // Return the index of a chart having title `t` in the model's chart list.
+    // NOTE: Titles should not be case-sensitive.
+    t = t.toLowerCase();
     for(let index = 0; index < this.charts.length; index++) {
-      if(this.charts[index].title === t) return index;
+      if(this.charts[index].title.toLowerCase() === t) return index;
     }
     return -1;
   }
@@ -865,8 +891,11 @@ class LinnyRModel {
   indexOfExperiment(t) {
     // Return the index of an experiment having title `t` in the model's
     // experiment list.
+    // NOTE: Titles should not be case-sensitive.
+    t = t.toLowerCase();
     for(let index = 0; index < this.experiments.length; index++) {
-      if(this.experiments[index].title === t) return index;
+      // NOTE: Use nameToID to
+      if(this.experiments[index].title.toLowerCase() === t) return index;
     }
     return -1;
   }
@@ -1078,49 +1107,63 @@ class LinnyRModel {
     return ss.length > 0;
   }
 
-  renamePrefixedDatasets(old_prefix, new_prefix) {
+  renamePrefixedDatasets(old_prefix, new_prefix, subset=null) {
     // Rename all datasets having the specified old prefix so that they
     // have the specified new prefix UNLESS this would cause name conflicts.
+    // NOTE: If `subset` is defined, limit renaming to the datasets it contains.
     const
         oldkey = old_prefix.toLowerCase().split(UI.PREFIXER).join(':_'),
         newkey = new_prefix.toLowerCase().split(UI.PREFIXER).join(':_'),
-        dsl = [];
+        dskl = [];
     // No change if new prefix is identical to old prefix.
     if(old_prefix !== new_prefix) { 
       for(let k in MODEL.datasets) if(MODEL.datasets.hasOwnProperty(k)) {
-        if(k.startsWith(oldkey)) dsl.push(k);
+        if(k.startsWith(oldkey) &&
+            (!subset || subset.indexOf(MODEL.datasets[k]) >= 0)) dskl.push(k);
       }
       // NOTE: No check for name conflicts needed when name change is
       // merely some upper/lower case change.
       if(newkey !== oldkey) {
         let nc = 0;
-        for(const ds of dsl) {
-          const nk = newkey + ds.substring(oldkey.length);
+        for(const k of dskl) {
+          const nk = newkey + k.substring(oldkey.length);
           if(MODEL.datasets[nk]) nc++;
         }
         if(nc) {
-          UI.warn('Renaming ' + pluralS(dsl.length, 'dataset') +
+          UI.warn('Renaming ' + pluralS(dskl.length, 'dataset') +
               ' would cause ' + pluralS(nc, 'name conflict'));
           return false;
         }
       }
       // Reset counts of effects of a rename operation.
-      this.entity_count = 0;
+      this.variable_count = 0;
       this.expression_count = 0;
       // Rename datasets one by one, suppressing notifications.
-      for(const ds of dsl) {
-        const d = MODEL.datasets[ds];
-        d.rename(d.displayName.replace(old_prefix, new_prefix), false);
-      }
-      let msg = 'Renamed ' + pluralS(dsl.length, 'dataset').toLowerCase();
-      if(MODEL.variable_count) msg += ', and updated ' +
-          pluralS(MODEL.variable_count, 'variable') + ' in ' +
-          pluralS(MODEL.expression_count, 'expression');
-      UI.notify(msg);
-      if(EXPERIMENT_MANAGER.selected_experiment) {
-        EXPERIMENT_MANAGER.selected_experiment.inferVariables();
+      // NOTE: Make a list of renamed datasets.
+      const rdsl = [];
+      for(const k of dskl) {
+        const
+            ds = this.datasets[k],
+            // NOTE: When old prefix is empty string, add instead of replace.
+            nn = (old_prefix ? ds.displayName.replace(old_prefix, new_prefix) :
+                new_prefix + ds.displayName);
+        rdsl.push(ds.rename(nn, false));
+      }
+      if(subset) {
+        // Update the specified subset so it contains the renamed datasets.
+        subset.length = 0;
+        subset.push(...rdsl);
+      } else {
+        let msg = 'Renamed ' + pluralS(dskl.length, 'dataset').toLowerCase();
+        if(this.variable_count) msg += ', and updated ' +
+            pluralS(this.variable_count, 'variable') + ' in ' +
+            pluralS(this.expression_count, 'expression');
+        UI.notify(msg);
+        if(EXPERIMENT_MANAGER.selected_experiment) {
+          EXPERIMENT_MANAGER.selected_experiment.inferVariables();
+        }
+        UI.updateControllerDialogs('CDEFJX');
       }
-      UI.updateControllerDialogs('CDEFJX');
     }
     return true;
   }
@@ -4351,22 +4394,24 @@ class IOBinding {
         datastyle = (this.is_data ?
             '; text-decoration: 1.5px dashed underline' : '');
     let html = ['<tr class="', ioc[this.io_type],  '-param">',
-        '<td style="padding-bottom:2px">',
-        '<span style="font-style:normal; font-weight:normal', datastyle, '">',
+        '<td style="padding-bottom: 2px">',
+        '<span style="font-style: normal; font-weight: normal', datastyle, '">',
         this.entity_type, ':</span> ', this.name_in_module].join('');
     if(this.io_type === 1) {
       // An IMPORT binding generates two rows: the formal name (in the module)
-      // and the actual name (in the current model) as dropdown box
-      // NOTE: the first (default) option is the *prefixed* formal name, which
-      // means that the parameter is not bound to an entity in the current model
+      // and the actual name (in the current model) as dropdown box.
+      // NOTE: The first (default) option is the *prefixed* formal name, which
+      // means that the parameter is not bound to an entity in the current model.
       html += ['<br>&rdca;<select id="', this.id, '" name="', this.id,
-          '" class="i-param"><option value="_CLUSTER">Cluster: ',
+          '" class="i-param"><option value="_CLUSTER" style="color: purple">Cluster: ',
           this.name_in_module, '</option>'].join('');
       const
           s = MODEL.setByType(this.entity_type),
-          index = Object.keys(s).sort();
+          tail = ':_' + this.name_in_module.toLowerCase(),
+          index = Object.keys(s).sort(
+              (a, b) => compareTailFirst(a, b, tail));
       if(s === MODEL.datasets) {
-        // NOTE: do not list the model equations as dataset
+        // NOTE: Do not list the model equations as dataset.
         const i = index.indexOf(UI.EQUATIONS_DATASET_ID);
         if(i >= 0) index.splice(i, 1);
       }
@@ -4448,12 +4493,14 @@ class IOContext {
   }
 
   actualName(n, an='') {
-    // Returns the actual name for a parameter with formal name `n`
+    // Return the actual name for a parameter with formal name `n`
     // (and for processes and clusters: with actor name `an` if specified and
-    // not "(no actor)")
-    // NOTE: do not modify (no actor), nor the "dataset dot"
+    // not "(no actor)").
+    // NOTE: Do not modify (no actor), nor the "dataset dot".
     if(n === UI.NO_ACTOR || n === '.') return n;
-    // NOTE: the top cluster of the included model has the prefix as its name
+    // NOTE: Do not modify "prefix-relative" variables.
+    if(n.startsWith(':')) return n;
+    // NOTE: The top cluster of the included model has the prefix as its name.
     if(n === UI.TOP_CLUSTER_NAME || n === UI.FORMER_TOP_CLUSTER_NAME) {
       return this.prefix;
     }
@@ -4470,7 +4517,7 @@ class IOContext {
       return n;
     }
     // All other entities are prefixed
-    return (this.prefix ? this.prefix + ': ' : '') + n;
+    return (this.prefix ? this.prefix + UI.PREFIXER : '') + n;
   }
   
   get clusterName() {
@@ -4562,19 +4609,19 @@ class IOContext {
   }
   
   supersede(obj) {
-    // Logs that entity `obj` is superseded, i.e., that this entity already
+    // Log that entity `obj` is superseded, i.e., that this entity already
     // exists in the current model, and is initialized anew from the XML of
     // the model that is being included. The log is shown to modeler afterwards.
     addDistinct(obj.type + UI.PREFIXER + obj.displayName, this.superseded);
   }
   
   rewrite(x, n1='', n2='') {
-    // Replaces entity names of variables used in expression `x` by their
-    // actual name after inclusion
-    // NOTE: when strings `n1` and `n2` are passed, replace entity name `n1`
+    // Replace entity names of variables used in expression `x` by their
+    // actual name after inclusion.
+    // NOTE: When strings `n1` and `n2` are passed, replace entity name `n1`
     // by `n2` in all variables (this is not IO-related, but used when the
-    // modeler renames an entity)
-    // NOTE: nothing to do if expression contains no variables 
+    // modeler renames an entity).
+    // NOTE: Nothing to do if expression contains no variables.
     if(x.text.indexOf('[') < 0) return;
     const rcnt = this.replace_count;
     let s = '',
@@ -4588,28 +4635,28 @@ class IOContext {
     while(true) {
       p = x.text.indexOf('[', q + 1);
       if(p < 0) {
-        // No more '[' => add remaining part of text, and quit
+        // No more '[' => add remaining part of text, and quit.
         s += x.text.slice(q + 1);
         break;
       }
-      // Add part from last ']' up to new '['
+      // Add part from last ']' up to new '['.
       s += x.text.slice(q + 1, p);
       // Find next ']'
       q = indexOfMatchingBracket(x.text, p);
-      // Get the bracketed text (without brackets)
+      // Get the bracketed text (without brackets).
       ss = x.text.slice(p + 1, q);
-      // Separate into variable and attribute + offset string (if any)
+      // Separate into variable and attribute + offset string (if any).
       vb = ss.lastIndexOf('|');
       if(vb >= 0) {
         v = ss.slice(0, vb);
-        // NOTE: attribute string includes the vertical bar '|'
+        // NOTE: Attribute string includes the vertical bar '|'.
         a = ss.slice(vb);
       } else {
-        // Separate into variable and offset string (if any)
+        // Separate into variable and offset string (if any).
         vb = ss.lastIndexOf('@');
         if(vb >= 0) {
           v = ss.slice(0, vb);
-          // NOTE: attribute string includes the "at" sign '@'
+          // NOTE: Attribute string includes the "at" sign '@'.
           a = ss.slice(vb);
         } else {
           v = ss;
@@ -4631,12 +4678,13 @@ class IOContext {
           brace = '';
         }
       }
-      // NOTE: patterns used to compute statistics must not be rewritten 
+      // NOTE: Patterns used to compute statistics must not be rewritten.
       let doit = true;
       stat = v.split('$');
       if(stat.length > 1 && VM.statistic_operators.indexOf(stat[0]) >= 0) {
         if(brace) {
-          // NOTE: this does not hold for statistics for experiment outcomes
+          // NOTE: This does not hold for statistics for experiment outcomes,
+          // because there no patterns but actual names are used.
           brace += stat[0] + '$';
           v = stat.slice(1).join('$');
         } else {
@@ -4644,21 +4692,21 @@ class IOContext {
         }
       }
       if(doit) {
-        // NOTE: when `n1` and `n2` have been specified, compare `v` with `n1`,
-        // and if matching, replace it by `n2`
+        // NOTE: When `n1` and `n2` have been specified, compare `v` with `n1`,
+        // and if matching, replace it by `n2`.
         if(n1 && n2) {
           // NOTE: UI.replaceEntity handles link names by replacing either the
-          // FROM or TO node name if it matches with `n1`
+          // FROM or TO node name if it matches with `n1`.
           const r = UI.replaceEntity(v, n1, n2);
-          // Only replace `v` by `r` in case of a match
+          // Only replace `v` by `r` in case of a match.
           if(r) {
             this.replace_count++;
             v = r;
           }
         } else {
           // When `n1` and `n2` are NOT specified, rewrite the variable
-          // using the parameter bindings
-          // NOTE: link variables contain TWO entity names
+          // using the parameter bindings.
+          // NOTE: Link variables contain TWO entity names.
           if(v.indexOf(UI.LINK_ARROW) >= 0) {
             const ln = v.split(UI.LINK_ARROW);
             v = this.actualName(ln[0]) + UI.LINK_ARROW + this.actualName(ln[1]);
@@ -4667,24 +4715,24 @@ class IOContext {
           }
         }
       }
-      // Add [actual name|attribute string] while preserving "by reference"
+      // Add [actual name|attribute string] while preserving "by reference".
       s += `[${brace}${by_ref}${v}${a}]`;
     }
-    // Increase expression count when 1 or more variables were replaced
+    // Increase expression count when 1 or more variables were replaced.
     if(this.replace_count > rcnt) this.expression_count++;
-    // Replace the original expression by the new one
+    // Replace the original expression by the new one.
     x.text = s;
-    // Force expression to recompile
+    // Force expression to recompile.
     x.code = null;
   }
   
   addedNode(node) {
-    // Record that node was added
+    // Record that node was added.
     this.added_nodes.push(node);
   }
 
   addedLink(link) {
-    // Record that link was added
+    // Record that link was added.
     this.added_links.push(link);
   }
 
@@ -9006,16 +9054,16 @@ class Dataset {
     this.black_box = false;
     this.outcome = false;
     this.parent_anchor = 0;
-    // URL indicates that data must be read from external source
+    // URL indicates that data must be read from external source.
     this.url = '';
     // Array `data` will contain modeler-defined values, starting at *dataset*
-    // time step t = 1
+    // time step t = 1.
     this.data = [];
     // Array `vector` will contain data values on model time scale, starting at
-    // *model* time step t = 0
+    // *model* time step t = 0.
     this.vector = [];
     this.modifiers = {};
-    // Selector to be used when model is run normally, i.e., no experiment
+    // Selector to be used when model is run normally, i.e., no experiment.
     this.default_selector = '';
   }
 
@@ -9177,12 +9225,17 @@ class Dataset {
     // Data is stored simply as semicolon-separated floating point numbers,
     // with N-digit precision to keep model files compact (default: N = 8).
     let d = [];
-    for(const v of this.data) {
-      // Convert number to string with the desired precision.
-      const f = v.toPrecision(CONFIGURATION.dataset_precision);
-      // Then parse it again, so that the number will be represented
-      // (by JavaScript) in the most compact representation.
-      d.push(parseFloat(f));
+    // NOTE: Guard against empty strings and other invalid data.
+    for(const v of this.data) if(v) {
+      try {
+        // Convert number to string with the desired precision.
+        const f = v.toPrecision(CONFIGURATION.dataset_precision);
+        // Then parse it again, so that the number will be represented
+        // (by JavaScript) in the most compact representation.
+        d.push(parseFloat(f));
+      } catch(err) {
+        console.log('-- Notice: dataset', this.displayName, 'has invalid data', v);
+      }
     }
     return d.join(';');
   }
@@ -11319,6 +11372,7 @@ class ExperimentRun {
   constructor(x, n) {
     this.experiment = x;
     this.number = n;
+    this.combination = [];
     this.time_started = 0;
     this.time_recorded = 0;
     this.time_steps = MODEL.end_period - MODEL.start_period + 1;
@@ -11330,6 +11384,8 @@ class ExperimentRun {
   }
   
   start() {
+    // Initialize this run.
+    this.combination = this.experiment.combinations[this.number].slice();
     this.time_started = new Date().getTime();
     this.time_recorded = 0;
     this.results = [];
@@ -11346,7 +11402,8 @@ class ExperimentRun {
         '" started="', this.time_started,
         '" recorded="', this.time_recorded,
         '"><x-title>', xmlEncoded(this.experiment.title),
-        '</x-title><time-steps>', this.time_steps,
+        '</x-title><x-combi>', this.combination.join(' '),
+        '</x-combi><time-steps>', this.time_steps,
         '</time-steps><delta-t>', this.time_step_duration,
         '</delta-t><results>', r,
         '</results><messages>', bm,
@@ -11363,6 +11420,7 @@ class ExperimentRun {
       UI.warn(`Run title "${t}" does not match experiment title "` +
           this.experiment.title + '"');
     }
+    this.combi = nodeContentByTag(node, 'x-combi').split(' ');
     this.time_steps = safeStrToInt(nodeContentByTag(node, 'time-steps'));
     this.time_step_duration = safeStrToFloat(nodeContentByTag(node, 'delta-t'));
     let n = childNodeByTag(node, 'results');
@@ -11543,7 +11601,6 @@ class Experiment {
     this.selected_statistic = 'mean';
     this.selected_scale = 'val';
     this.selelected_color_scale = 'no';
-    this.active_combination_index = -1;
     // Set of combination indices to be displayed in chart.
     this.chart_combinations = [];
     // String to store original model settings while executing experiment runs.
@@ -11553,7 +11610,7 @@ class Experiment {
   }
   
   clearRuns() {
-    // NOTE: separated from basic initialization so that it can be called
+    // NOTE: Separated from basic initialization so that it can be called
     // when the modeler clicks on the "Clear results" button.
     // @@TO DO: prepare for UNDO.
     this.runs.length = 0;
@@ -11561,7 +11618,7 @@ class Experiment {
     this.completed = false;
     this.time_started = 0;
     this.time_stopped = 0;
-    this.active_combination_index = 0;
+    this.active_combination_index = -1;
     this.chart_combinations.length = 0;
   }
 
@@ -11637,21 +11694,72 @@ class Experiment {
   }
   
   matchingCombinationIndex(sl) {
-    // Return index of combination with most selectors in common with `sl`.
+    // Return the index of the run that can be inferred from selector list
+    // `sl`, or FALSE if results for this run are not yet available.
+    // NOTE: The selector list `sl` is a run specification that is *relative*
+    // to the active combination of the *running* experiment, which may be
+    // different from `this`. For example, consider an experiment with
+    // three dimensions A = {a1, a2, a3), B = {b1, b2} and C = {c1, c2, c3},
+    // and assume that the active combination is a2 + b2 + c2. Then the
+    // "matching" combination will be:
+    //  a2 + b2 + c2  if `sl` is empty
+    //  a2 + b1 + c2  if `sl` is [b1]
+    //  a1 + b3 + c2  if `sl` is [b3, a1]  (selector sequence)
+    // NOTES:
+    // (1) Elements of `sl` that are not element of A, B or C are ingnored.
+    // (2) `sl` should not contain more than 1 selector from the same dimension.
+    const
+        valid = [],
+        v_pos = {},
+        matching = [];
+    // First, retain only the (unique) valid selectors in `sl`.
+    for(const s of sl) if(valid.indexOf(s) < 0) {
+      for(const c of this.combinations) {
+        // NOTE: Because of the way combinations are constructed, the index of
+        // a valid selector in a combinations will always be the same.
+        const pos = c.indexOf(s);
+        // Conversely, when a new selector has the same position as a selector
+        // that was already validated, this new selector is disregarded.
+        if(pos >= 0 && !v_pos[pos]) {
+          valid.push(s);
+          v_pos[pos] = true;
+        }
+      }
+    }
+    // Then build a list of indices of combinations that match all valid selectors.
+    // NOTE: The list of runs may not cover ALL combinations.
+    for(let ri = 0; ri < this.runs.length; ri++) {
+      if(intersection(valid, this.runs[ri].combination).length === valid.length) {
+        matching.push(ri);
+      }
+    }
+    // Results may already be conclusive:
+    if(!matching.length) return false;
+    // NOTE: If no experiment is running, there is no "active combination".
+    // This should not occur, but in then return the last (= most recent) match. 
+    if(matching.length === 1 || !MODEL.running_experiment) return matching.pop();
+    // If not conclusive, find the matching combination that -- for the remaining
+    // dimensions of the experiment -- has most selectors in common with
+    // the active combination of the *running* experiment.
+    const ac = MODEL.running_experiment.activeCombination;
     let high = 0,
         index = false;
-    // NOTE: Results of current run are not available yet, hence length-1.
-    for(let ci = 0; ci < this.active_combination_index; ci++) {
-      const l = intersection(sl, this.combinations[ci]).length;
-      if(l > high) {
-        high = l;
-        index = ci;
+    for(const ri of matching) {
+      const c = this.runs[ri].combination;
+      let nm = 0;
+      // NOTE: Ignore the matching valid selectors.
+      for(let ci = 0; ci < c.length; ci++) {
+        if(!v_pos[ci] && ac.indexOf(c[ci]) >= 0) nm++;
+      }
+      // NOTE: Using >= ensures that index will be set even for 0 matching.
+      if(nm >= high) {
+        high = nm;
+        index = ri;
       }
     }
-    // NOTE: If no matching selectors, return value is FALSE.
     return index;
   }
-  
+
   isDimensionSelector(s) {
     // Return TRUE if `s` is a dimension selector in this experiment.
     for(const dim of this.dimensions) if(dim.indexOf(s) >= 0) return true;

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

@@ -303,11 +303,21 @@ function markFirstDifference(s1, s2) {
 //
 
 function ciCompare(a, b) {
-  // Performs case-insensitive comparison that does differentiate
-  // between accented characters (as this differentiates between identifiers)
+  // Perform case-insensitive comparison that does differentiate
+  // between accented characters (as this differentiates between identifiers).
   return a.localeCompare(b, undefined, {sensitivity: 'accent'});
 }
 
+function compareTailFirst(a, b, tail) {
+  // Sort strings while prioritizing the group of elements that end on `tail`.
+  const
+      a_tail = a.endsWith(tail),
+      b_tail = b.endsWith(tail);
+  if(a_tail && !b_tail) return -1;
+  if(!a_tail && b_tail) return 1;
+  return ciCompare(a, b);
+}
+
 function endsWithDigits(str) {
   // Returns trailing digts of `str` (empty string will evaluate as FALSE)
   let i = str.length - 1,
@@ -1143,6 +1153,7 @@ if(NODE) module.exports = {
   differences: differences,
   markFirstDifference: markFirstDifference,
   ciCompare: ciCompare,
+  compareTailFirst: compareTailFirst,
   endsWithDigits: endsWithDigits,
   indexOfMatchingBracket: indexOfMatchingBracket,
   monoSpaced: monoSpaced,