@datagrok/eda 1.4.12 → 1.5.0

package/package.json

@@ -1,25 +1,26 @@
 {
   "name": "@datagrok/eda",
   "friendlyName": "EDA",
-  "version": "1.4.12",
+  "version": "1.5.0",
   "description": "Exploratory Data Analysis Tools",
   "dependencies": {
     "@datagrok-libraries/math": "^1.2.6",
-    "@datagrok-libraries/ml": "^6.10.8",
-    "@datagrok-libraries/statistics": "^1.10.0",
+    "@datagrok-libraries/ml": "^6.10.10",
+    "@datagrok-libraries/statistics": "^1.12.0",
     "@datagrok-libraries/tutorials": "^1.7.4",
-    "@datagrok-libraries/utils": "^4.6.5",
+    "@datagrok-libraries/utils": "^4.7.0",
     "@keckelt/tsne": "^1.0.2",
     "@webgpu/types": "^0.1.40",
     "cash-dom": "^8.1.1",
-    "datagrok-api": "^1.26.3",
+    "datagrok-api": "^1.27.0",
     "dayjs": "^1.11.9",
     "jstat": "^1.9.6",
     "mathjs": "^15.1.0",
     "source-map-loader": "^4.0.1",
     "umap-js": "^1.3.3",
     "worker-loader": "^3.0.8",
-    "wu": "^2.1.0"
+    "wu": "^2.1.0",
+    "@datagrok-libraries/test": "^1.1.0"
   },
   "author": {
     "name": "Viktor Makarichev",
@@ -29,7 +30,7 @@
     "@typescript-eslint/eslint-plugin": "^5.32.0",
     "@typescript-eslint/parser": "^5.32.0",
     "css-loader": "^7.1.2",
-    "datagrok-tools": "^4.14.55",
+    "datagrok-tools": "^5.1.5",
     "eslint": "^8.21.0",
     "eslint-config-google": "^0.14.0",
     "style-loader": "^4.0.0",
@@ -97,5 +98,8 @@
         "Reduce Dimensionality": null
       }
     }
+  },
+  "overrides": {
+    "datagrok-api": "$datagrok-api"
   }
 }

package/src/package-api.ts

@@ -282,10 +282,14 @@ export namespace funcs {
     return await grok.functions.call('EDA:TrainPmpo', {});
   }
 
+  export async function getPmpoAppItems(view: DG.View ): Promise<any> {
+    return await grok.functions.call('EDA:GetPmpoAppItems', { view });
+  }
+
   /**
-  Apply trained probabilistic multi-parameter optimization (pMPO) model to score samples
+  Generates syntethetic dataset oriented on the pMPO modeling
   */
-  export async function applyPmpo(table: DG.DataFrame , file: DG.FileInfo ): Promise<void> {
-    return await grok.functions.call('EDA:ApplyPmpo', { table, file });
+  export async function generatePmpoDataset(samples: number ): Promise<DG.DataFrame> {
+    return await grok.functions.call('EDA:GeneratePmpoDataset', { samples });
   }
 }

package/src/package-test.ts

@@ -1,10 +1,13 @@
 import * as DG from 'datagrok-api/dg';
-import {runTests, tests, TestContext, initAutoTests as initTests} from '@datagrok-libraries/utils/src/test';
+import {runTests, tests, TestContext, initAutoTests as initTests} from '@datagrok-libraries/test/src/test';
 import './tests/dim-reduction-tests';
 import './tests/linear-methods-tests';
 import './tests/classifiers-tests';
 import './tests/mis-vals-imputation-tests';
 import './tests/anova-tests';
+import './tests/pmpo-tests';
+import './tests/pareto-tests';
+
 export const _package = new DG.Package();
 export {tests};
 

package/src/package.g.ts

@@ -7,6 +7,7 @@ export function info() : void {
 }
 
 //tags: init
+//meta.role: init
 export async function init() : Promise<void> {
   await PackageFunctions.init();
 }
@@ -37,34 +38,37 @@ export async function PCA(table: DG.DataFrame, features: DG.ColumnList, componen
 }
 
 //name: DBSCAN clustering
+//tags: dim-red-postprocessing-function
 //input: column col1 
 //input: column col2 
 //input: double epsilon = 0.01 { description: Minimum distance between two points to be considered as in the same neighborhood. }
 //input: int minimumPoints = 5 { description: Minimum number of points to form a dense region. }
 //meta.defaultPostProcessingFunction: true
-//meta.role: dimRedPostprocessingFunction
+//meta.role: dim-red-postprocessing-function
 export async function dbscanPostProcessingFunction(col1: DG.Column, col2: DG.Column, epsilon: number, minimumPoints: number) : Promise<void> {
   await PackageFunctions.dbscanPostProcessingFunction(col1, col2, epsilon, minimumPoints);
 }
 
 //name: None (number)
+//tags: dim-red-preprocessing-function
 //input: column col 
 //input: string _metric { optional: true }
 //output: object result
 //meta.supportedTypes: int,float,double,qnum
 //meta.supportedDistanceFunctions: Difference
-//meta.role: dimRedPreprocessingFunction
+//meta.role: dim-red-preprocessing-function
 export function numberPreprocessingFunction(col: DG.Column, _metric: string) {
   return PackageFunctions.numberPreprocessingFunction(col, _metric);
 }
 
 //name: None (string)
+//tags: dim-red-preprocessing-function
 //input: column col 
 //input: string _metric { optional: true }
 //output: object result
 //meta.supportedTypes: string
 //meta.supportedDistanceFunctions: One-Hot,Levenshtein,Hamming
-//meta.role: dimRedPreprocessingFunction
+//meta.role: dim-red-preprocessing-function
 export function stringPreprocessingFunction(col: DG.Column, _metric: string) {
   return PackageFunctions.stringPreprocessingFunction(col, _metric);
 }
@@ -77,6 +81,7 @@ export async function reduceDimensionality() : Promise<void> {
 
 //tags: editor
 //input: funccall call 
+//meta.role: editor
 export function GetMCLEditor(call: DG.FuncCall) : void {
   PackageFunctions.GetMCLEditor(call);
 }
@@ -102,6 +107,7 @@ export async function MCLClustering(df: DG.DataFrame, cols: DG.Column[], metrics
 
 //name: MCL
 //description: Markov clustering viewer
+//tags: viewer
 //output: viewer result
 //meta.showInGallery: false
 //meta.role: viewer
@@ -532,6 +538,7 @@ export function paretoFront() : void {
 
 //name: Pareto front
 //description: Pareto front viewer
+//tags: viewer
 //output: viewer result
 //meta.icon: icons/pareto-front-viewer.svg
 //meta.role: viewer
@@ -540,14 +547,19 @@ export function paretoFrontViewer() : any {
 }
 
 //description: Train probabilistic multi-parameter optimization (pMPO) model
-//top-menu: Chem | Calculate | Train pMPO...
 export function trainPmpo() : void {
   PackageFunctions.trainPmpo();
 }
 
-//description: Apply trained probabilistic multi-parameter optimization (pMPO) model to score samples
-//input: dataframe table 
-//input: file file 
-export async function applyPmpo(table: DG.DataFrame, file: DG.FileInfo) : Promise<void> {
-  await PackageFunctions.applyPmpo(table, file);
+//input: view view 
+//output: object result
+export function getPmpoAppItems(view: any) : any {
+  return PackageFunctions.getPmpoAppItems(view);
+}
+
+//description: Generates syntethetic dataset oriented on the pMPO modeling
+//input: int samples 
+//output: dataframe Synthetic
+export async function generatePmpoDataset(samples: number) : Promise<any> {
+  return await PackageFunctions.generatePmpoDataset(samples);
 }

package/src/package.ts

@@ -36,10 +36,12 @@ import {SoftmaxClassifier} from './softmax-classifier';
 
 import {initXgboost} from '../wasm/xgbooster';
 import {XGBooster} from './xgbooster';
+
 import {ParetoOptimizer} from './pareto-optimization/pareto-optimizer';
 import {ParetoFrontViewer} from './pareto-optimization/pareto-front-viewer';
+
 import {Pmpo} from './probabilistic-scoring/prob-scoring';
-import {loadPmpoParams} from './probabilistic-scoring/pmpo-utils';
+import {getSynteticPmpoData} from './probabilistic-scoring/data-generator';
 
 export const _package = new DG.Package();
 export * from './package.g';
@@ -53,7 +55,7 @@ export class PackageFunctions {
   }
 
 
-  @grok.decorators.init({})
+  @grok.decorators.init({tags: ['init']})
   static async init(): Promise<void> {
     await _initEDAAPI();
     await initXgboost();
@@ -115,8 +117,9 @@ export class PackageFunctions {
 
 
   @grok.decorators.func({
-    'meta': {'defaultPostProcessingFunction': 'true', role: 'dimRedPostprocessingFunction'},
+    'meta': {'defaultPostProcessingFunction': 'true', 'role': 'dim-red-postprocessing-function'},
     'name': 'DBSCAN clustering',
+    'tags': ['dim-red-postprocessing-function'],
   })
   static async dbscanPostProcessingFunction(
     col1: DG.Column,
@@ -145,9 +148,10 @@ export class PackageFunctions {
     'meta': {
       'supportedTypes': 'int,float,double,qnum',
       'supportedDistanceFunctions': 'Difference',
-      'role': 'dimRedPreprocessingFunction'
+      'role': 'dim-red-preprocessing-function',
     },
     'name': 'None (number)',
+    'tags': ['dim-red-preprocessing-function'],
     'outputs': [{name: 'result', type: 'object'}],
   })
   static numberPreprocessingFunction(
@@ -163,8 +167,9 @@ export class PackageFunctions {
     'meta': {
       'supportedTypes': 'string',
       'supportedDistanceFunctions': 'One-Hot,Levenshtein,Hamming',
-      'role': 'dimRedPreprocessingFunction'
+      'role': 'dim-red-preprocessing-function',
     },
+    'tags': ['dim-red-preprocessing-function'],
     'name': 'None (string)',
     'outputs': [{name: 'result', type: 'object'}],
   })
@@ -219,7 +224,7 @@ export class PackageFunctions {
   }
 
 
-  @grok.decorators.editor()
+  @grok.decorators.editor({tags: ['editor']})
   static GetMCLEditor(
     call: DG.FuncCall): void {
     try {
@@ -287,6 +292,7 @@ export class PackageFunctions {
   @grok.decorators.func({
     'outputs': [{'name': 'result', 'type': 'viewer'}],
     'meta': {showInGallery: 'false', role: 'viewer'},
+    'tags': ['viewer'],
     'name': 'MCL',
     'description': 'Markov clustering viewer',
   })
@@ -979,14 +985,14 @@ export class PackageFunctions {
     'name': 'Pareto front',
     'description': 'Pareto front viewer',
     'outputs': [{'name': 'result', 'type': 'viewer'}],
-    'meta': {'icon': 'icons/pareto-front-viewer.svg', role: 'viewer'},
+    'meta': {'icon': 'icons/pareto-front-viewer.svg', 'role': 'viewer'},
+    'tags': ['viewer'],
   })
   static paretoFrontViewer(): DG.Viewer {
     return new ParetoFrontViewer();
   }
 
   @grok.decorators.func({
-    'top-menu': 'Chem | Calculate | Train pMPO...',
     'name': 'trainPmpo',
     'description': 'Train probabilistic multi-parameter optimization (pMPO) model',
   })
@@ -1004,22 +1010,26 @@ export class PackageFunctions {
     pMPO.runTrainingApp();
   }
 
+  @grok.decorators.func({'name': 'getPmpoAppItems', 'outputs': [{name: 'result', type: 'object'}]})
+  static getPmpoAppItems(@grok.decorators.param({type: 'view'}) view: DG.TableView): any | null {
+    const df = view.dataFrame;
+    if (!Pmpo.isTableValid(df))
+      return null;
+
+    const pMPO = new Pmpo(df, view);
+
+    return pMPO.getPmpoAppItems();
+  }
+
   @grok.decorators.func({
-    //'top-menu': 'ML | Apply pMPO...',
-    'name': 'applyPmpo',
-    'description': 'Apply trained probabilistic multi-parameter optimization (pMPO) model to score samples',
+    'name': 'generatePmpoDataset',
+    'description': 'Generates syntethetic dataset oriented on the pMPO modeling',
+    'outputs': [{name: 'Synthetic', type: 'dataframe'}],
   })
-  static async applyPmpo(
-    @grok.decorators.param({'type': 'dataframe'}) table: DG.DataFrame,
-    @grok.decorators.param({'type': 'file'}) file: DG.FileInfo,
-  ): Promise<void> {
-    try {
-      const params = await loadPmpoParams(file);
-      const predName = table.columns.getUnusedName('pMPO score');
-      const prediction = Pmpo.predict(table, params, predName);
-      table.columns.add(prediction, true);
-    } catch (err) {
-      grok.shell.warning(`Failed to apply pMPO: ${err instanceof Error ? err.message : 'the platform issue.'}`);
-    }
+  static async generatePmpoDataset(@grok.decorators.param({'type': 'int'}) samples: number): Promise<DG.DataFrame> {
+    const df = await getSynteticPmpoData(samples, false);
+    df.name = 'Synthetic';
+    return df;
   }
+
 }

package/src/pareto-optimization/pareto-computations.ts

@@ -2,6 +2,12 @@
 
 import {NumericArray, OPT_TYPE} from './defs';
 
+/** Computes the Pareto front mask for a given dataset and optimization sense
+ * @param rawData Array of numeric arrays representing the dataset (each array corresponds to a feature/dimension)
+ * @param sense Array of optimization types (OPT_TYPE.MIN or OPT_TYPE.MAX) for each dimension
+ * @param nPoints Number of data points in the dataset
+ * @param nullIndices Optional set of indices corresponding to missing values (these points will be marked as non-optimal)
+ * @returns Boolean array where true indicates that the point is on the Pareto front */
 export function getParetoMask(rawData: NumericArray[], sense: OPT_TYPE[], nPoints: number,
   nullIndices?: Set<number>): boolean[] {
   if (nPoints === 0)

package/src/pareto-optimization/pareto-optimizer.ts

@@ -19,7 +19,7 @@ export class ParetoOptimizer {
   private toUpdatePcCols = false;
   private paretoFrontViewer: DG.Viewer;
   private resultColName: string;
-  private intervalId: NodeJS.Timeout | null = null;
+  private intervalId: ReturnType<typeof setInterval> | null = null;
   private inputsMap = new Map<string, DG.InputBase>();
   private pcPlotNode: DG.DockNode | null = null;
   private inputFormNode: DG.DockNode | null = null;

package/src/pls/pls-constants.ts

@@ -17,8 +17,10 @@ export enum ERROR_MSG {
   ENOUGH = 'Not enough of features',
   COMP_LIN_PLS = 'Components count must be less than the number of features',
   COMP_QUA_PLS = 'Too large components count for the quadratic PLS regression',
-  COMPONENTS = 'Components count must be greater than 1',
+  COMP_ROWS = 'Components count must not exceed the number of rows',
+  COMPONENTS = 'Components count must be at least 1',
   INV_INP = 'Invalid inputs',
+  NULL_COMPS = 'Components count is not specified',
 }
 
 /** Widget titles */

package/src/pls/pls-tools.ts

@@ -36,6 +36,24 @@ export type PlsInput = {
 
 type TypedArray = Int32Array | Float32Array | Uint32Array | Float64Array;
 
+/** Set style for input element depending on the validity of the value */
+function setStyle(valid: boolean, element: HTMLElement, tooltip: string, errorMsg: string) {
+  if (valid) {
+    element.style.color = COLOR.VALID_TEXT;
+    element.style.borderBottomColor = COLOR.VALID_LINE;
+    ui.tooltip.bind(element, tooltip);
+  } else {
+    element.style.color = COLOR.INVALID;
+    element.style.borderBottomColor = COLOR.INVALID;
+    ui.tooltip.bind(element, () => {
+      const hint = ui.label(tooltip);
+      const err = ui.label(errorMsg);
+      err.style.color = COLOR.INVALID;
+      return ui.divV([hint, err]);
+    });
+  }
+};
+
 /** Return lines */
 export function getLines(names: string[]): DG.FormulaLine[] {
   const lines: DG.FormulaLine[] = [];
@@ -137,7 +155,7 @@ function getQuadraticPlsInput(input: PlsInput): PlsInput {
 
     for (let j = i; j < colsCount; ++j) {
       col2 = cols[j];
-      raw2 = col2.getRawData();      
+      raw2 = col2.getRawData();
       qaudrRaw = new Float32Array(rowsCount);
 
       for (let k = 0; k < rowsCount; ++k)
@@ -268,7 +286,7 @@ async function performMVA(input: PlsInput, analysisType: PLS_ANALYSIS): Promise<
   });
 
 
-  // 4.3) create lines & circles  
+  // 4.3) create lines & circles
   view.addViewer(scoresScatter);
   scoresScatter.meta.formulaLines.addAll(getLines(scoreNames));
 
@@ -321,7 +339,7 @@ async function performMVA(input: PlsInput, analysisType: PLS_ANALYSIS): Promise<
   }));
 
   // emphasize viewers in the demo case
-  if (analysisType === PLS_ANALYSIS.DEMO) {    
+  if (analysisType === PLS_ANALYSIS.DEMO) {
     grok.shell.windows.help.showHelp(ui.markdown(DEMO_RESULTS_MD));
 
     describeElements(
@@ -372,38 +390,32 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
     return;
   }
 
-  let features: DG.Column[] = numCols.slice(0, numCols.length - 1);
-  let predict = numCols[numCols.length - 1];
-  let components = min(numColNames.length - 1, COMPONENTS.DEFAULT as number);
-  let isQuadratic = false;
-
-  const isPredictValid = () => {
-    for (const col of features)
-      if (col.name === predict.name)
-        return false;
-    return true;
+  const doFeaturesIncludePredict = () => {
+    return featuresInput.value.some((col) => col.name === predictInput.value!.name);
   };
 
   const isCompConsistent = () => {
-    if (components < 1)
+    if (componentsInput.value! < 1)
       return false;
 
-    const n = features.length;
+    if (componentsInput.value! > table.rowCount)
+      return false;
 
-    if (isQuadratic)      
-      return components <= (n + 1) * n / 2 + n;
+    const n = featuresInput.value.length;
 
-    return components <= n;
-  }
+    if (isQuadraticInput.value)
+      return componentsInput.value! <= (n + 1) * n / 2 + n;
+
+    return componentsInput.value! <= n;
+  };
 
   // response (to predict)
   const predictInput = ui.input.column(TITLE.PREDICT, {
     table: table,
-    value: predict,
+    value: numCols[numCols.length - 1],
     nullable: false,
-    onValueChanged: (value) => {
-      predict = value;
-      updateIputs();
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
     filter: (col: DG.Column) => isValidNumeric(col),
     tooltipText: HINT.PREDICT,
@@ -413,21 +425,21 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
   const featuresInput = ui.input.columns(TITLE.USING, {
     table: table,
     available: numColNames,
-    value: features,
-    onValueChanged: (val) => {
-      features = val;
-      updateIputs();      
+    value: numCols.slice(0, numCols.length - 1),
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
     tooltipText: HINT.FEATURES,
+    nullable: false,
   });
 
   // components count
   const componentsInput = ui.input.int(TITLE.COMPONENTS, {
-    value: components,
+    value: min(numColNames.length - 1, COMPONENTS.DEFAULT as number),
     showPlusMinus: true,
-    onValueChanged: (val) => {
-      components = val;
-      updateIputs();
+    nullable: false,
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
     tooltipText: HINT.COMPONENTS,
   });
@@ -446,28 +458,14 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
     dlgRunBtnTooltip = HINT.MVA;
   }
 
-  const setStyle = (valid: boolean, element: HTMLElement, tooltip: string, errorMsg: string) => {
-    if (valid) {
-      element.style.color = COLOR.VALID_TEXT;
-      element.style.borderBottomColor = COLOR.VALID_LINE;
-      ui.tooltip.bind(element, tooltip);
-    } else {
-      element.style.color = COLOR.INVALID;
-      element.style.borderBottomColor = COLOR.INVALID;
-      ui.tooltip.bind(element, () => {
-        const hint = ui.label(tooltip);
-        const err = ui.label(errorMsg);
-        err.style.color = COLOR.INVALID;
-        return ui.divV([hint, err]);
-      });
-    }    
-  };
-
-  const updateIputs = () => {
-    const predValid = isPredictValid();
+  const updateInputStyles = () => {
+    const featuresValid = featuresInput.value.length >= 1;
+    const predValid = featuresValid && !doFeaturesIncludePredict();
     let compValid: boolean;
 
-    if (predValid) {
+    if (!featuresValid)
+      setStyle(false, featuresInput.input, HINT.FEATURES, ERROR_MSG.ENOUGH);
+    else if (predValid) {
       setStyle(true, predictInput.input, HINT.PREDICT, '');
       setStyle(true, featuresInput.input, HINT.FEATURES, '');
     } else {
@@ -475,9 +473,12 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
       setStyle(false, featuresInput.input, HINT.FEATURES, ERROR_MSG.PREDICT);
     }
 
-    if (components < 1) {
+    if (componentsInput.value == null) {
+      setStyle(false, componentsInput.input, HINT.COMPONENTS, ERROR_MSG.NULL_COMPS);
+      compValid = false;
+    } else if (componentsInput.value < 1) {
       setStyle(false, componentsInput.input, HINT.COMPONENTS, ERROR_MSG.COMPONENTS);
-      compValid = false;  
+      compValid = false;
     } else {
       compValid = isCompConsistent();
 
@@ -486,7 +487,9 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
         if (predValid)
           setStyle(true, featuresInput.input, HINT.FEATURES, '');
       } else {
-        const errMsg = isQuadratic ? ERROR_MSG.COMP_QUA_PLS : ERROR_MSG.COMP_LIN_PLS;
+        const errMsg = componentsInput.value! > table.rowCount ?
+          ERROR_MSG.COMP_ROWS :
+          isQuadraticInput.value ? ERROR_MSG.COMP_QUA_PLS : ERROR_MSG.COMP_LIN_PLS;
         setStyle(false, componentsInput.input, HINT.COMPONENTS, errMsg);
         setStyle(false, featuresInput.input, HINT.FEATURES, ERROR_MSG.ENOUGH);
       }
@@ -497,10 +500,18 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
     dlg.getButton(TITLE.RUN).disabled = !isValid;
 
     return isValid;
+  }; // updateInputStyles
+
+  const getStrColWithUniqueVals = () => {
+    for (const col of strCols) {
+      if (col.stats.uniqueCount === table.rowCount)
+        return col;
+    }
+    return undefined;
   };
 
   // names of samples
-  let names = (strCols.length > 0) ? strCols[0] : undefined;
+  let names = getStrColWithUniqueVals();
   const namesInputs = ui.input.column(TITLE.NAMES, {
     table: table,
     value: names,
@@ -512,11 +523,10 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
 
   // quadratic/linear model
   const isQuadraticInput = ui.input.bool(TITLE.QUADRATIC, {
-    value: isQuadratic,
+    value: false,
     tooltipText: HINT.QUADRATIC,
-    onValueChanged: (val) => {
-      isQuadratic = val;
-      updateIputs();
+    onValueChanged: (_) => {
+      updateInputStyles();
     },
   });
 
@@ -527,21 +537,15 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
 
       await performMVA({
         table: table,
-        features: DG.DataFrame.fromColumns(features).columns,
-        predict: predict,
-        components: components,
-        isQuadratic: isQuadratic,
+        features: DG.DataFrame.fromColumns(featuresInput.value).columns,
+        predict: predictInput.value!,
+        components: componentsInput.value!,
+        isQuadratic: isQuadraticInput.value,
         names: names,
       }, analysisType);
     }, undefined, dlgRunBtnTooltip)
     .show({x: X_COORD, y: Y_COORD});
 
-  // the following delay provides correct styles (see https://reddata.atlassian.net/browse/GROK-15196)
-  setTimeout(() => {
-    featuresInput.value = numCols.filter((col) => col !== predict);
-    features = featuresInput.value;
-  }, TIMEOUT);
-
   grok.shell.v.append(dlg.root);
 } // runMVA