linny-r 2.0.9 → 2.0.10

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

@@ -856,8 +856,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 +867,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 +1083,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;
   }
@@ -9006,16 +9025,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 = '';
   }
 
@@ -11319,6 +11338,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 +11350,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 +11368,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 +11386,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 +11567,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 +11576,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 +11584,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 +11660,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-vm.js

@@ -671,30 +671,8 @@ class ExpressionParser {
     // 
     if(owner) {
       this.context_number = owner.numberContext;
-      // NOTE: The owner prefix includes the trailing colon+space.
-      if(owner instanceof Link || owner instanceof Constraint) {
-        // For links and constraints, it depends:
-        const
-            fn = owner.from_node.displayName,
-            tn = owner.to_node.displayName;
-        if(fn.indexOf(UI.PREFIXER) >= 0) {
-          if(tn.indexOf(UI.PREFIXER) >= 0) {
-            // If both nodes are prefixed, use the longest prefix that these
-            // nodes have in common.
-            this.owner_prefix = UI.sharedPrefix(fn, tn) + UI.PREFIXER;
-          } else {
-            // Use the FROM node prefix.
-            this.owner_prefix = UI.completePrefix(fn);
-          }
-        } else if(tn.indexOf(UI.PREFIXER) >= 0) {
-          // Use the TO node prefix.
-          this.owner_prefix = UI.completePrefix(tn);
-        }
-      } else if(owner === MODEL.equations_dataset) {
-        this.owner_prefix = UI.completePrefix(attribute);
-      } else {
-        this.owner_prefix = UI.completePrefix(owner.displayName);
-      }
+      this.owner_prefix = UI.entityPrefix(
+          owner === MODEL.equations_dataset ? attribute : owner.displayName);
       if(owner instanceof Dataset) {
         this.dataset = owner;
         // The attribute (if specified) is a dataset modifier selector.
@@ -848,30 +826,33 @@ class ExpressionParser {
         }
       }
     }
-    // Run specifier (optional) must be leading and braced
-    // Specifier format: {method$title|run} where method and title are
-    // optional -- NOTE: # in title or run is NOT seen as a wildcard
+    // Experiment result specifier (optional) must be leading and braced.
+    // Specifier format: {method$title|run} where method$ and title| are
+    // optional. The run specifier may be a # followed by a run number, or
+    // a comma- or space-separated list of selectors.
+    // NOTE: # in title or run is NOT seen as a wildcard.
     if(name.startsWith('{')) {
       s = name.split('}');
       if(s.length > 1) {
-        // Brace pair => interpret it as experiment result reference
+        // Brace pair => interpret it as experiment result reference.
         const x = {
             x: false, // experiment
             r: false, // run number
             v: false, // variable; if parametrized {n: name seg's, p: indices}  
             s: '',    // statistic
-            m: '',    // method
+            m: '',    // method 
             p: false, // periodic
             nr: false // run number range
           };
-        // NOTE: name should then be in the experiment's variable list
+        // NOTE: Name should then be in the experiment's variable list.
+        // This will be checked later, after validating the run specifier.
         name = s[1].trim();
         s = s[0].substring(1);
-        // Check for scaling method
-        // NOTE: simply ignore $ unless it indicates a valid method
+        // Check for a time scaling method (used only for dataset run results).
+        // NOTE: Simply ignore $ unless it indicates a valid method.
         const msep = s.indexOf('$');
         if(msep <= 5) {
-          // Be tolerant as to case
+          // Be tolerant as to case.
           let method = s.substring(0, msep).toUpperCase();
           if(method.endsWith('P')) {
             x.p = true;
@@ -879,70 +860,89 @@ class ExpressionParser {
           }
           if(['ABS', 'MEAN', 'SUM', 'MAX', ''].indexOf(method) >= 0) {
             x.m = method;
-            s = s.substring(msep + 1);
+            s = s.substring(msep + 1).trim();
           }
         }
-        s = s.split('#');
-        let rn = (s.length > 1 ? s[1].trim() : false);
-        // Experiment specifier may contain modifier selectors.
-        s = s[0].trim().split(UI.OA_SEPARATOR);
-        if(s.length > 1) {
-          // If so, the selector list may indicate the run number.
-          // NOTE: permit selectors to be separated by various characters.
-          x.r = s.slice(1).join('|').split(/[\|\,\.\:\;\/\s]+/g);
-        }
-        if(rn) {
-          // NOTE: Special notation for run numbers to permit modelers
-          // to chart results as if run numbers are on the time axis
-          // (with a given step size). The chart will be made as usual,
-          // i.e., plot a point for each time step t, but the value v[t]
-          // will then stay the same for the time interval that corresponds
-          // to simulation period length / number of runs.
-          // NOTE: This will fail to produce a meaningful chart when the
-          // simulation period is small compared to the number of runs.
-          if(rn.startsWith('n')) {
-            // #n may be followed by a range, or this range defaults to
-            // 0 - last run number. Of this range, the i-th number will
-            // be used, where i is computes as:
-            // floor(current time step * number of runs / period length)
-            const range = rn.substring(1);
-            // Call rangeToList only to validate the range syntax.
-            if(rangeToList(range)) {
-              x.nr = range;
-              this.is_static = false;
-              this.log('dynamic because experiment run number range');
-            } else {
-              msg = `Invalid experiment run number range "${range}"`;
-            }
+        // Now `s` may still have format title|run specifier.
+        let x_title = '',
+            run_spec = '';
+        s = s.split('|');
+        if(s.length > 2) {
+          msg = `Experiment result specifier may contain only one "|"`;
+        } else {
+          if(s.length == 2) {
+            run_spec = s.pop().trim();
+            x_title = s[0].trim();
+          } else {
+            // No vertical bar => no title, only the run specifier.
+            run_spec = s[0].trim();
+          }
+          // Run specifier can start with a # sign... 
+          if(!run_spec.startsWith('#')) {
+            // ... and if not, it is assumed to be a list of modifier selectors
+            // that will identify (during problem set-up) a specific run.
+            // NOTE: Permit selectors to be separated by any combination
+            // of commas, semicolons and spaces.
+            x.r = run_spec.split(/[\,\;\/\s]+/g);
+            // NOTE: The VMI instruction accepts `x.r` to be a list of selectors
+            // or an integer number.
           } else {
-            // Explicit run number is specified.
-            const n = parseInt(rn);
-            if(isNaN(n)) {
-              msg = `Invalid experiment run number "${rn}"`;
+            // If the specifier does start with a #, trim it...
+            run_spec = run_spec.substring(1);
+            // ... and then
+            // NOTE: Special notation for run numbers to permit modelers
+            // to chart results as if run numbers are on the time axis
+            // (with a given step size). The chart will be made as usual,
+            // i.e., plot a point for each time step t, but the value v[t]
+            // will then stay the same for the time interval that corresponds
+            // to simulation period length / number of runs.
+            // NOTE: This will fail to produce a meaningful chart when the
+            // simulation period is small compared to the number of runs.
+            if(run_spec.startsWith('n')) {
+              // #n may be followed by a range, or this range defaults to
+              // 0 - last run number. Of this range, the i-th number will
+              // be used, where i is computes as:
+              // floor(current time step * number of runs / period length)
+              const range = run_spec.substring(1);
+              // Call rangeToList only to validate the range syntax.
+              if(rangeToList(range)) {
+                x.nr = range;
+                this.is_static = false;
+                this.log('dynamic because experiment run number range');
+              } else {
+                msg = `Invalid experiment run number range "${range}"`;
+              }
             } else {
-              // Explicit run number overrules selector list.
-              x.r = n;
+              // Explicit run number is specified.
+              const n = parseInt(run_spec);
+              if(isNaN(n)) {
+                msg = `Invalid experiment run number "${run_spec}"`;
+              } else {
+                // NOTE: Negative run numbers are acceptable.
+                x.r = n;
+              }
             }
           }
         }
-        // NOTE: s[0] still holds the experiment title
-        s = s[0].trim();
-        if(s) {
-          // NOTE: title cannot be parametrized with a # wildcard
-          const n = MODEL.indexOfExperiment(s);
+        // NOTE: Experiment title cannot be parametrized with a # wildcard.
+        if(x_title) {
+          const n = MODEL.indexOfExperiment(x_title);
           if(n < 0) {
-            msg = `Unknown experiment "${s}"`;
+            msg = `Unknown experiment "${x_title}"`;
           } else {
             x.x = MODEL.experiments[n];
           }
         }
+        // END of code for parsing an experiment result specifier.
+        // Now proceed with parsing the variable name.
+        
         // Variable name may start with a (case insensitive) statistic
-        // specifier such as SUM or MEAN
+        // specifier such as SUM or MEAN.
         s = name.split('$');
         if(s.length > 1) {
           const stat = s[0].trim().toUpperCase();
-          // NOTE: simply ignore $ (i.e., consider it as part of the
-          // variable name) unless it is preceded by a valid statistic
+          // NOTE: Simply ignore $ (i.e., consider it as part of the
+          // variable name) unless it is preceded by a valid statistic.
           if(VM.outcome_statistics.indexOf(stat) >= 0) {
             x.s = stat;
             name = s[1].trim();
@@ -7145,7 +7145,7 @@ function VMI_push_dataset_modifier(x, args) {
 
 
 function VMI_push_run_result(x, args) {
-  // NOTE: the first argument specifies the experiment run results:
+  // NOTE: The first argument specifies the experiment run results:
   // x: experiment object (FALSE indicates: use current experiment)
   // r: integer number, or selector list
   // v: variable index (integer number), or identifier (string)
@@ -7156,12 +7156,13 @@ function VMI_push_run_result(x, args) {
   // t: if integer t > 0, use floor(current time step / t) as run number
   const
       rrspec = args[0],
-      // NOTE: when expression `x` for which this instruction is executed is
-      // a dataset modifier, use the time scale of the dataset, not of the
-      // model, because the dataset vector is scaled to the model time scale
+      // NOTE: When *expression* `x` for which this instruction is executed
+      // is a dataset modifier, use the time scale of the dataset, not of the
+      // model, because the dataset vector is scaled to the model time scale.
       model_dt = MODEL.timeStepDuration;
-  // NOTE: run result now defaults to UNDEFINED, because the VM handles errors
-  // better now (no call stack dump on "undefined" etc., but only on errors)
+  // NOTE: Run result can now default to UNDEFINED, because the VM now handles
+  // exceptional values better: no call stack dump on "undefined" etc., but
+  // only on real errors.
   let v = rrspec.dv || VM.UNDEFINED;
   if(rrspec && rrspec.hasOwnProperty('x')) {
     let xp = rrspec.x,
@@ -7170,12 +7171,14 @@ function VMI_push_run_result(x, args) {
     if(xp === false) xp = MODEL.running_experiment;
     if(xp instanceof Experiment) {
       if(Array.isArray(rn)) {
+        // Let the running experiment infer run number from selector list `rn`
+        // and its own "active combination" of selectors.
         rn = xp.matchingCombinationIndex(rn); 
       } else if(rn < 0) {
-        // Relative run number: use current run # + r (first run has number 0)
+        // Relative run number: use current run # + r (first run has number 0).
         rn += xp.active_combination_index;
       } else if(rrspec.nr !== false) {
-        // Run number inferred from local time step of expression
+        // Run number inferred from local time step of expression.
         const
             rl = VM.nr_of_time_steps,
             range = rangeToList(rrspec.nr, xp.runs.length - 1);
@@ -7186,9 +7189,9 @@ function VMI_push_run_result(x, args) {
           rn = (ri < l ? range[ri] : range[l - 1]);
         }
       }
-      // If variable is passed as identifier, get its index for the experiment
+      // If variable is passed as identifier, get its index for the experiment.
       if(typeof rri === 'string') rri = xp.resultIndex(rri);
-      // Then proceed only if run number and result index both make sense
+      // Then proceed only if run number and result index both make sense.
       const run_count = (xp.completed ? xp.runs.length :
           xp.active_combination_index);
       if(rn !== false && rn >= 0 && rn < run_count) {
@@ -7233,11 +7236,14 @@ function VMI_push_run_result(x, args) {
           } else {
             // No statistic => return the vector for local time step
             // using here, too, the delta-time-modifier to adjust the offsets
-            // for different time steps per experiment
+            // for different time steps per experiment.
             const tot = twoOffsetTimeStep(x.step[x.step.length - 1],
                 args[1], args[2], args[3], args[4], dtm, x);
             // Scale the (midpoint) time step (at current model run time scale)
-            // to the experiment run time scale and get the run result value
+            // to the experiment run time scale and get the run result value.
+            // NOTE: the .m property specifies the time scaling method, and
+            // the .p property whether the run result vector should be used as
+            // a periodic time series.
             v = rr.valueAtModelTime(tot[0], model_dt, rrspec.m, rrspec.p);
             if(DEBUGGING) {
               const trc = ['push run result: ', xp.title,