@datagrok/peptides 1.8.0 → 1.8.2

package/src/viewers/sar-viewer.ts

@@ -1,4 +1,3 @@
-import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
@@ -7,70 +6,111 @@ import * as C from '../utils/constants';
 import * as CR from '../utils/cell-renderer';
 import {PeptidesModel, VIEWER_TYPE} from '../model';
 
-export class SARViewerBase extends DG.JsViewer {
-  tempName!: string;
+export enum MONOMER_POSITION_MODE {
+  MUTATION_CLIFFS = 'Mutation Cliffs',
+  INVARIANT_MAP = 'Invariant Map',
+}
+
+/** Structure-activity relationship viewer */
+export class MonomerPosition extends DG.JsViewer {
+  _titleHost = ui.divText('Mutation Cliffs', {id: 'pep-viewer-title'});
   _viewerGrid!: DG.Grid;
-  sourceGrid!: DG.Grid;
   _model!: PeptidesModel;
-  isPropertyChanging: boolean = false;
-  _isVertical = false;
+  colorColumnName: string;
+  aggregation: string;
 
   constructor() {
     super();
+    this.colorColumnName = this.string('colorColumnName', C.COLUMNS_NAMES.ACTIVITY_SCALED, {category: 'Invariant Map'});
+    this.aggregation = this.string('aggregation', 'avg', {category: 'Invariant Map', choices: Object.values(DG.AGG)});
   }
 
-  get name(): string {return '';}
+  get name(): string {return VIEWER_TYPE.MONOMER_POSITION;}
 
   get viewerGrid(): DG.Grid {
+    if (!this._viewerGrid)
+      this.createMonomerPositionGrid();
     return this._viewerGrid;
   }
   set viewerGrid(grid: DG.Grid) {
     this._viewerGrid = grid;
   }
 
+  get mode(): MONOMER_POSITION_MODE {
+    return this.dataFrame.getTag(C.TAGS.MONOMER_POSITION_MODE) as MONOMER_POSITION_MODE ??
+      MONOMER_POSITION_MODE.MUTATION_CLIFFS;
+  }
+  set mode(mode: MONOMER_POSITION_MODE) {
+    this.dataFrame.setTag(C.TAGS.MONOMER_POSITION_MODE, mode);
+    this.viewerGrid.invalidate();
+  }
+
   get model(): PeptidesModel {
     this._model ??= PeptidesModel.getInstance(this.dataFrame);
     return this._model;
   }
 
+  detach(): void {this.subs.forEach((sub) => sub.unsubscribe());}
+
   onTableAttached(): void {
     super.onTableAttached();
-    this.sourceGrid = this.view?.grid ?? (grok.shell.v as DG.TableView).grid;
-    // this.model = PeptidesModel.getInstance(this.dataFrame);
-    this.subs.push(this.model.onMutationCliffsSelectionChanged.subscribe(() => this.viewerGrid.invalidate()));
+    this.subs.push(this.model.onMonomerPositionSelectionChanged.subscribe(() => this.viewerGrid.invalidate()));
     this.helpUrl = '/help/domains/bio/peptides.md';
+    this.subs.push(this.model.onSettingsChanged.subscribe(() => {
+      this.createMonomerPositionGrid();
+      this.render();
+    }));
+    this.render();
   }
 
-  detach(): void {this.subs.forEach((sub) => sub.unsubscribe());}
-
-  get isMutationCliffsMode(): string {
-    return this.dataFrame.getTag(C.TAGS.SAR_MODE) ?? '1';
+  onPropertyChanged(property: DG.Property): void {
+    super.onPropertyChanged(property);
+    this.render();
   }
-  set isMutationCliffsMode(s: string) {
-    this.dataFrame.setTag(C.TAGS.SAR_MODE, s);
+
+  createMonomerPositionGrid(): void {
+    this.viewerGrid = this.model.monomerPositionDf.plot.grid();
+    this.viewerGrid.sort([C.COLUMNS_NAMES.MONOMER]);
+    this.viewerGrid.columns.setOrder([C.COLUMNS_NAMES.MONOMER, ...this.model.splitSeqDf.columns.names()]);
+    const monomerCol = this.model.monomerPositionDf.getCol(C.COLUMNS_NAMES.MONOMER);
+    CR.setAARRenderer(monomerCol, this.model.alphabet);
+    this.viewerGrid.onCellRender.subscribe((args: DG.GridCellRenderArgs) => renderCell(args, this.model,
+      this.mode === MONOMER_POSITION_MODE.INVARIANT_MAP, this.dataFrame.getCol(this.colorColumnName),
+      this.aggregation as DG.AggregationType));
+    this.viewerGrid.onCellTooltip((cell: DG.GridCell, x: number, y: number) => showTooltip(cell, x, y, this.model));
+    this.viewerGrid.root.addEventListener('click', (ev) => {
+      const gridCell = this.viewerGrid.hitTest(ev.offsetX, ev.offsetY);
+      if (!gridCell?.isTableCell || gridCell?.tableColumn?.name == C.COLUMNS_NAMES.MONOMER)
+        return;
+
+      const position = gridCell!.tableColumn!.name;
+      const aar = monomerCol.get(gridCell!.tableRowIndex!);
+      chooseAction(aar, position, ev.shiftKey, this.mode === MONOMER_POSITION_MODE.INVARIANT_MAP, this.model);
+      this.viewerGrid.invalidate();
+      // this.model.fireBitsetChanged();
+    });
+    this.viewerGrid.onCurrentCellChanged.subscribe((_gc) => cellChanged(this.model.monomerPositionDf, this.model));
+
+    setViewerGridProps(this.viewerGrid, false);
   }
 
   render(refreshOnly = false): void {
     if (!refreshOnly) {
       $(this.root).empty();
       let switchHost = ui.divText(VIEWER_TYPE.MOST_POTENT_RESIDUES, {id: 'pep-viewer-title'});
-      if (this.name == 'MC') {
-        const mutationCliffsMode = ui.boolInput('', this.isMutationCliffsMode === '1');
+      if (this.name == VIEWER_TYPE.MONOMER_POSITION) {
+        const mutationCliffsMode = ui.boolInput('', this.mode === MONOMER_POSITION_MODE.MUTATION_CLIFFS);
         mutationCliffsMode.root.addEventListener('click', () => {
           invariantMapMode.value = false;
           mutationCliffsMode.value = true;
-          this.isMutationCliffsMode = '1';
-          this.model.isInvariantMap = false;
-          this.viewerGrid.invalidate();
+          this.mode = MONOMER_POSITION_MODE.MUTATION_CLIFFS;
         });
         mutationCliffsMode.addPostfix('Mutation Cliffs');
-        const invariantMapMode = ui.boolInput('', this.isMutationCliffsMode === '0');
+        const invariantMapMode = ui.boolInput('', this.mode === MONOMER_POSITION_MODE.INVARIANT_MAP);
         invariantMapMode.root.addEventListener('click', () => {
           mutationCliffsMode.value = false;
           invariantMapMode.value = true;
-          this.isMutationCliffsMode = '0';
-          this.model.isInvariantMap = true;
-          this.viewerGrid.invalidate();
+          this.mode = MONOMER_POSITION_MODE.INVARIANT_MAP;
         });
         invariantMapMode.addPostfix('Invariant Map');
         const setDefaultProperties = (input: DG.InputBase): void => {
@@ -97,89 +137,19 @@ export class SARViewerBase extends DG.JsViewer {
     }
     this.viewerGrid?.invalidate();
   }
-
-  onPropertyChanged(property: DG.Property): void {
-    super.onPropertyChanged(property);
-
-    this.render(true);
-  }
-}
-
-/** Structure-activity relationship viewer */
-export class MonomerPosition extends SARViewerBase {
-  _titleHost = ui.divText('Mutation Cliffs', {id: 'pep-viewer-title'});
-  _name = 'MC';
-  _isVertical = false;
-  colorColumnName: string;
-  aggregation: string;
-
-  constructor() {
-    super();
-    this.colorColumnName = this.string('colorColumnName', C.COLUMNS_NAMES.ACTIVITY_SCALED, {category: 'Invariant Map'});
-    this.aggregation = this.string('aggregation', 'avg', {category: 'Invariant Map', choices: Object.values(DG.AGG)});
-  }
-
-  get name(): string {return this._name;}
-
-  get viewerGrid(): DG.Grid {
-    if (!this._viewerGrid)
-      this.createMonomerPositionGrid();
-    return this._viewerGrid;
-  }
-  set viewerGrid(grid: DG.Grid) {
-    this._viewerGrid = grid;
-  }
-
-  onTableAttached(): void {
-    super.onTableAttached();
-    this.subs.push(this.model.onSettingsChanged.subscribe(() => {
-      this.createMonomerPositionGrid();
-      this.render();
-    }));
-    this.render();
-  }
-
-  onPropertyChanged(property: DG.Property): void {
-    super.onPropertyChanged(property);
-  }
-
-  createMonomerPositionGrid(): void {
-    this.viewerGrid = this.model.monomerPositionDf.plot.grid();
-    this.viewerGrid.sort([C.COLUMNS_NAMES.MONOMER]);
-    this.viewerGrid.columns.setOrder([C.COLUMNS_NAMES.MONOMER, ...this.model.splitSeqDf.columns.names()]);
-    const monomerCol = this.model.monomerPositionDf.getCol(C.COLUMNS_NAMES.MONOMER);
-    CR.setAARRenderer(monomerCol, this.model.alphabet);
-    this.viewerGrid.onCellRender.subscribe((args: DG.GridCellRenderArgs) => renderCell(args, this.model,
-      this.model.isInvariantMap, this.dataFrame.getCol(this.colorColumnName), this.aggregation as DG.AggregationType));
-    this.viewerGrid.onCellTooltip((cell: DG.GridCell, x: number, y: number) => showTooltip(cell, x, y, this.model));
-    this.viewerGrid.root.addEventListener('click', (ev) => {
-      const gridCell = this.viewerGrid.hitTest(ev.offsetX, ev.offsetY);
-      if (!gridCell?.isTableCell || gridCell?.tableColumn?.name == C.COLUMNS_NAMES.MONOMER)
-        return;
-
-      const position = gridCell!.tableColumn!.name;
-      const aar = monomerCol.get(gridCell!.tableRowIndex!);
-      chooseAction(aar, position, ev.shiftKey, this.model.isInvariantMap, this.model);
-      this.viewerGrid.invalidate();
-      this.model.fireBitsetChanged();
-    });
-    this.viewerGrid.onCurrentCellChanged.subscribe((_gc) => cellChanged(this.model.monomerPositionDf, this.model));
-
-    setViewerGridProps(this.viewerGrid, false);
-  }
 }
 
 /** Vertical structure activity relationship viewer */
-export class MostPotentResiduesViewer extends SARViewerBase {
-  _name = 'MPR';
+export class MostPotentResiduesViewer extends DG.JsViewer {
   _titleHost = ui.divText(VIEWER_TYPE.MOST_POTENT_RESIDUES, {id: 'pep-viewer-title'});
-  _isVertical = true;
+  _viewerGrid!: DG.Grid;
+  _model!: PeptidesModel;
 
   constructor() {
     super();
   }
 
-  get name(): string {return this._name;}
+  get name(): string {return VIEWER_TYPE.MOST_POTENT_RESIDUES;}
 
   get viewerGrid(): DG.Grid {
     if (!this._viewerGrid)
@@ -190,8 +160,17 @@ export class MostPotentResiduesViewer extends SARViewerBase {
     this._viewerGrid = grid;
   }
 
+  get model(): PeptidesModel {
+    this._model ??= PeptidesModel.getInstance(this.dataFrame);
+    return this._model;
+  }
+
+  detach(): void {this.subs.forEach((sub) => sub.unsubscribe());}
+
   onTableAttached(): void {
     super.onTableAttached();
+    this.subs.push(this.model.onMonomerPositionSelectionChanged.subscribe(() => this.viewerGrid.invalidate()));
+    this.helpUrl = '/help/domains/bio/peptides.md';
     this.subs.push(this.model.onSettingsChanged.subscribe(() => {
       this.createMostPotentResiduesGrid();
       this.render();
@@ -201,6 +180,7 @@ export class MostPotentResiduesViewer extends SARViewerBase {
 
   onPropertyChanged(property: DG.Property): void {
     super.onPropertyChanged(property);
+    this.render();
   }
 
   createMostPotentResiduesGrid(): void {
@@ -226,13 +206,31 @@ export class MostPotentResiduesViewer extends SARViewerBase {
       const aar = monomerCol.get(tableRowIdx);
       chooseAction(aar, position!.toFixed(), ev.shiftKey, false, this.model);
       this.viewerGrid.invalidate();
-      this.model.fireBitsetChanged();
+      // this.model.fireBitsetChanged();
     });
     this.viewerGrid.onCurrentCellChanged.subscribe((_gc) => cellChanged(this.model.mostPotentResiduesDf, this.model));
     const mdCol: DG.GridColumn = this.viewerGrid.col(C.COLUMNS_NAMES.MEAN_DIFFERENCE)!;
     mdCol.name = 'Diff';
     setViewerGridProps(this.viewerGrid, true);
   }
+
+  render(refreshOnly = false): void {
+    if (!refreshOnly) {
+      $(this.root).empty();
+      const switchHost = ui.divText(VIEWER_TYPE.MOST_POTENT_RESIDUES, {id: 'pep-viewer-title'});
+      const tips: HTMLElement = ui.iconFA('question');
+      ui.tooltip.bind(tips,
+        () => ui.divV([ui.divText('Color intensity - p-value'), ui.divText('Circle size - Mean difference')]));
+
+      $(tips).addClass('pep-help-icon');
+
+      const viewerRoot = this.viewerGrid.root;
+      viewerRoot.style.width = 'auto';
+      const header = ui.divH([switchHost, tips], {style: {alignSelf: 'center', lineHeight: 'normal'}});
+      this.root.appendChild(ui.divV([header, viewerRoot]));
+    }
+    this.viewerGrid?.invalidate();
+  }
 }
 
 function renderCell(args: DG.GridCellRenderArgs, model: PeptidesModel, isInvariantMap?: boolean,
@@ -292,16 +290,16 @@ function renderCell(args: DG.GridCellRenderArgs, model: PeptidesModel, isInvaria
 
     const color = DG.Color.scaleColor(cellColorDataCol.aggregate(colorAgg!), colorColStats.min, colorColStats.max);
     CR.renderInvaraintMapCell(
-      canvasContext, currentMonomer, currentPosition, model.invariantMapSelection, value, bound, color);
+      canvasContext, currentMonomer, currentPosition, model.monomerPositionFilter, value, bound, color);
   } else {
     CR.renderMutationCliffCell(canvasContext, currentMonomer, currentPosition, model.monomerPositionStats, bound,
-      model.mutationCliffsSelection, model.substitutionsInfo, model.settings.isBidirectional);
+      model.monomerPositionSelection, model.mutationCliffs, model.settings.isBidirectional);
   }
   args.preventDefault();
   canvasContext.restore();
 }
 
-function showTooltip(cell: DG.GridCell, x: number, y: number, model: PeptidesModel): boolean {
+export function showTooltip(cell: DG.GridCell, x: number, y: number, model: PeptidesModel): boolean {
   const renderColNames = [...model.splitSeqDf.columns.names(), C.COLUMNS_NAMES.MEAN_DIFFERENCE];
   const tableCol = cell.tableColumn;
   const tableColName = tableCol?.name;
@@ -323,12 +321,12 @@ function showTooltip(cell: DG.GridCell, x: number, y: number, model: PeptidesMod
   return true;
 }
 
-function chooseAction(aar: string, position: string, isShiftPressed: boolean, isInvariantMapSelection: boolean,
+function chooseAction(aar: string, position: string, isShiftPressed: boolean, isFilter: boolean,
   model: PeptidesModel): void {
-  if (isShiftPressed)
-    model.modifyMonomerPositionSelection(aar, position, isInvariantMapSelection);
-  else
-    model.initMonomerPositionSelection(aar, position, isInvariantMapSelection);
+  if (!isShiftPressed)
+    model.initMonomerPositionSelection({cleanInit: true, notify: false});
+
+  model.modifyMonomerPositionSelection(aar, position, isFilter);
 }
 
 function cellChanged(table: DG.DataFrame, model: PeptidesModel): void {

package/src/widgets/distribution.ts

@@ -5,27 +5,27 @@ import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations'
 import $ from 'cash-dom';
 
 import * as C from '../utils/constants';
-import {getAggregatedValue, getStats, MaskInfo, Stats} from '../utils/statistics';
+import {getStats, Stats} from '../utils/statistics';
 import {PeptidesModel} from '../model';
-import {wrapDistroAndStatsDefault} from '../utils/misc';
+import {getStatsSummary} from '../utils/misc';
+import BitArray from '@datagrok-libraries/utils/src/bit-array';
 
 const allConst = 'All';
 const otherConst = 'Other';
 
 export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
-  const activityScaledCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
-  const rowCount = activityScaledCol.length;
-  const selectionObject = model.mutationCliffsSelection;
+  const activityCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
+  const activityColData = activityCol.getRawData();
+  const rowCount = activityCol.length;
+  const selectionObject = model.monomerPositionSelection;
   const clustersColName = model.settings.clustersColumnName;
   let clustersProcessedObject: string[] = [];
   if (clustersColName)
-    clustersProcessedObject = model.logoSummarySelection;
+    clustersProcessedObject = model.clusterSelection;
 
   const positions = Object.keys(selectionObject);
-  const positionsLen = positions.length;
   let aarStr = allConst;
   let otherStr = '';
-  // const useSelectedStr = model.isPeptideSpaceChangingBitset;
 
   const updateDistributionHost = (): void => {
     model.splitByPos = splitByPosition.value!;
@@ -34,34 +34,30 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
     if (splitByPosition.value && splitByAAR.value) {
       otherStr = otherConst;
       for (const position of positions) {
-        const posCol = table.getCol(position);
         const aarList = selectionObject[position];
         if (aarList.length === 0)
           continue;
 
+        const posCol = table.getCol(position);
+        const posColCategories = posCol.categories;
+        const posColData = posCol.getRawData();
+
         for (const aar of aarList) {
-          const indexes: number[] = [];
-          aarStr = `${position} : ${aar}`;
-          const splitCol = DG.Column.bool(C.COLUMNS_NAMES.SPLIT_COL, rowCount).init((i) => {
-            const flag = posCol.get(i) == aar;
-            if (flag)
-              indexes.push(i);
-          });
-          const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
-
-          const colResults: {[colName: string]: number} = {};
-          for (const [col, agg] of Object.entries(model.settings.columns || {})) {
-            const currentCol = table.getCol(col);
-            const currentColData = currentCol.getRawData();
-            const tempCol = DG.Column.float('', indexes.length);
-            tempCol.init((i) => currentColData[indexes[i]]);
-            colResults[`${agg}(${col})`] = tempCol.stats[agg as keyof DG.Stats] as number;
-          }
+          const labels = getDistributionLegend(`${position} : ${aar}`, otherStr);
+
+          const aarCategoryIndex = posColCategories.indexOf(aar);
+          const mask = DG.BitSet.create(rowCount, (i) => posColData[i] === aarCategoryIndex);
+          const distributionTable = DG.DataFrame.fromColumns(
+            [activityCol, DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask)]);
+          const hist = getActivityDistribution(distributionTable);
 
           const stats = model.monomerPositionStats[position][aar];
-          const das = getDistributionAndStats(distributionTable, stats, aarStr, otherStr, true);
-          const resultMap: {[key: string]: any} = {...das.tableMap, ...colResults};
-          const distributionRoot = wrapDistroAndStatsDefault(das.labels, das.histRoot, resultMap);
+          const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
+
+          const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
+
+          const resultMap = {...tableMap, ...aggregatedColMap};
+          const distributionRoot = getStatsSummary(labels, hist, resultMap);
           $(distributionRoot).addClass('d4-flex-col');
 
           res.push(distributionRoot);
@@ -69,40 +65,32 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
       }
     } else if (splitByPosition.value) {
       otherStr = otherConst;
-      const activityScaledData = activityScaledCol.toList();
       for (const position of positions) {
-        const posCol = table.getCol(position);
         const aarList = selectionObject[position];
         if (aarList.length === 0)
           continue;
 
         aarStr = `${position}: {${aarList.join(', ')}}`;
+        const labels = getDistributionLegend(aarStr, otherStr);
 
-        //OPTIMIZE: don't create Bitset, use bool[]
-        const mask = DG.BitSet.create(rowCount, (i) => aarList.includes(posCol.get(i)));
+        const posCol = table.getCol(position);
+        const posColCategories = posCol.categories;
+        const posColData = posCol.getRawData();
+        const aarIndexesList = aarList.map((aar) => posColCategories.indexOf(aar));
+        const mask = DG.BitSet.create(rowCount, (i) => aarIndexesList.includes(posColData[i]));
         const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
 
-        const maskInfo: MaskInfo = {
-          mask: splitCol.toList() as boolean[],
-          trueCount: mask.trueCount,
-          falseCount: mask.falseCount,
-        };
-        const stats = getStats(activityScaledData, maskInfo);
-        const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
-
-        const indexes = mask.getSelectedIndexes();
-        const colResults: {[colName: string]: number} = {};
-        for (const [col, agg] of Object.entries(model.settings.columns || {})) {
-          const currentCol = table.getCol(col);
-          const currentColData = currentCol.getRawData();
-          const tempCol = DG.Column.float('', indexes.length);
-          tempCol.init((i) => currentColData[indexes[i]]);
-          colResults[`${agg}(${col})`] = tempCol.stats[agg as keyof DG.Stats] as number;
-        }
+        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
 
-        const das = getDistributionAndStats(distributionTable, stats, aarStr, otherStr, true);
-        const resultMap: {[key: string]: any} = {...das.tableMap, ...colResults};
-        const distributionRoot = wrapDistroAndStatsDefault(das.labels, das.histRoot, resultMap);
+        const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
+        const hist = getActivityDistribution(distributionTable);
+
+        const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
+        const stats = getStats(activityColData, bitArray);
+        const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
+
+        const resultMap = {...tableMap, ...aggregatedColMap};
+        const distributionRoot = getStatsSummary(labels, hist, resultMap);
         $(distributionRoot).addClass('d4-flex-col');
 
         res.push(distributionRoot);
@@ -123,43 +111,30 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
       }
 
       otherStr = otherConst;
-      const activityScaledData = activityScaledCol.getRawData();
       for (const aar of aars) {
         const posList = reversedSelectionObject[aar];
+        const posColList = posList.map((pos) => table.getCol(pos));
+        const posColCategoriesList = posColList.map((posCol) => posCol.categories);
+        const posColDataList = posColList.map((posCol) => posCol.getRawData());
+        const aarCategoryIndexList = posColCategoriesList.map((posColCategories) => posColCategories.indexOf(aar));
+
         aarStr = `${aar}: {${posList.join(', ')}}`;
+        const labels = getDistributionLegend(aarStr, otherStr);
+
+        const mask = DG.BitSet.create(rowCount,
+          (i) => posColDataList.some((posColData, j) => posColData[i] === aarCategoryIndexList[j]));
+        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
 
-        //OPTIMIZE: don't create Bitset, use bool[]
-        const mask = DG.BitSet.create(rowCount, (i) => {
-          const currentRow = table.row(i);
-          for (const position of posList) {
-            if (currentRow.get(position) == aar)
-              return true;
-          }
-          return false;
-        });
         const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
+        const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
+        const hist = getActivityDistribution(distributionTable);
 
-        const maskInfo: MaskInfo = {
-          mask: splitCol.toList() as boolean[],
-          trueCount: mask.trueCount,
-          falseCount: mask.falseCount,
-        };
-        const stats = getStats(activityScaledData, maskInfo);
-        const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
-
-        const indexes = mask.getSelectedIndexes();
-        const colResults: {[colName: string]: number} = {};
-        for (const [col, agg] of Object.entries(model.settings.columns || {})) {
-          const currentCol = table.getCol(col);
-          const currentColData = currentCol.getRawData();
-          const tempCol = DG.Column.float('', indexes.length);
-          tempCol.init((i) => currentColData[indexes[i]]);
-          colResults[`${agg}(${col})`] = tempCol.stats[agg as keyof DG.Stats] as number;
-        }
+        const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
+        const stats = getStats(activityColData, bitArray);
+        const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
 
-        const das = getDistributionAndStats(distributionTable, stats, aarStr, otherStr, true);
-        const resultMap: {[key: string]: any} = {...das.tableMap, ...colResults};
-        const distributionRoot = wrapDistroAndStatsDefault(das.labels, das.histRoot, resultMap);
+        const resultMap: {[key: string]: any} = {...tableMap, ...aggregatedColMap};
+        const distributionRoot = getStatsSummary(labels, hist, resultMap);
         $(distributionRoot).addClass('d4-flex-col');
 
         res.push(distributionRoot);
@@ -170,10 +145,8 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
         res.push(ui.divText('No distribution'));
       else {
         otherStr = '';
-        if (false /*useSelectedStr*/) {
-          aarStr = 'Selected';
-          otherStr = otherConst;
-        } else if (positionsLen) {
+        if (Object.values(selectionObject).some((selectedAar) => selectedAar.length !== 0) ||
+          clustersProcessedObject.length !== 0) {
           aarStr = '';
           for (const position of positions) {
             const aarList = selectionObject[position];
@@ -184,25 +157,20 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
             aarStr += `Clusters: ${clustersProcessedObject.join(', ')}`;
           otherStr = otherConst;
         }
+        const labels = getDistributionLegend(aarStr, otherStr);
 
-        const distributionTable = DG.DataFrame.fromColumns([activityScaledCol, splitCol]);
+        const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
+        const hist = getActivityDistribution(distributionTable);
 
-        const compoundBs = model.getCompoundBitest();
-        const colResults: {[colName: string]: number} = {};
-        for (const [col, agg] of Object.entries(model.settings.columns || {})) {
-          const currentCol = table.getCol(col);
-          colResults[`${agg}(${col})`] = getAggregatedValue(currentCol, agg, compoundBs);
-        }
+        const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
+        const mask = DG.BitSet.create(rowCount, (i) => bitArray.getBit(i));
+        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
+
+        const stats = getStats(activityColData, bitArray);
+        const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
 
-        const maskInfo: MaskInfo = {
-          mask: splitCol.toList() as boolean[],
-          trueCount: compoundBs.trueCount,
-          falseCount: compoundBs.falseCount,
-        };
-        const stats = getStats(activityScaledCol.getRawData(), maskInfo);
-        const das = getDistributionAndStats(distributionTable, stats, aarStr, otherStr);
-        const resultMap: {[key: string]: any} = {...das.tableMap, ...colResults};
-        const distributionRoot = wrapDistroAndStatsDefault(das.labels, das.histRoot, resultMap);
+        const resultMap: {[key: string]: any} = {...tableMap, ...aggregatedColMap};
+        const distributionRoot = getStatsSummary(labels, hist, resultMap);
         $(distributionRoot).addClass('d4-flex-col');
 
         res.push(distributionRoot);
@@ -212,14 +180,14 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
   };
 
   const setDefaultProperties = (input: DG.InputBase): void => {
-    input.enabled = !model.isMutationCliffSelectionEmpty;
+    input.enabled = !model.isMonomerPositionSelectionEmpty;
     $(input.root).find('.ui-input-editor').css('margin', '0px');
     $(input.root).find('.ui-input-description').css('padding', '0px').css('padding-left', '5px');
   };
 
   let defaultValuePos = model.splitByPos;
   let defaultValueAAR = model.splitByAAR;
-  if (!model.isLogoSummarySelectionEmpty && model.isMutationCliffSelectionEmpty) {
+  if (!model.isClusterSelectionEmpty && model.isMonomerPositionSelectionEmpty) {
     defaultValuePos = false;
     defaultValueAAR = false;
   }
@@ -239,34 +207,36 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
   return new DG.Widget(ui.divV([controlsHost, distributionHost]));
 }
 
-type DistroAndStats = {labels: HTMLDivElement, histRoot: HTMLElement, tableMap: StringDictionary};
-
-export function getDistributionAndStats(table: DG.DataFrame, stats: Stats, thisLabel: string, otherLabel: string = '',
-  isTooltip: boolean = false, splitColName?: string): DistroAndStats {
-  const labels = ui.divV([
-    ui.label(thisLabel, {style: {color: DG.Color.toHtml(otherLabel == '' ? DG.Color.blue : DG.Color.orange)}}),
-    ui.label(otherLabel, {style: {color: DG.Color.toHtml(DG.Color.blue)}})]);
-
-  const histRoot = table.plot.histogram({
+export function getActivityDistribution(table: DG.DataFrame, isTooltip: boolean = false,
+): DG.Viewer<DG.IHistogramLookSettings> {
+  const hist = table.plot.histogram({
     filteringEnabled: false,
     valueColumnName: C.COLUMNS_NAMES.ACTIVITY_SCALED,
-    splitColumnName: splitColName ?? C.COLUMNS_NAMES.SPLIT_COL,
+    splitColumnName: C.COLUMNS_NAMES.SPLIT_COL,
     legendVisibility: 'Never',
     showXAxis: true,
     showColumnSelector: false,
     showRangeSlider: false,
     showBinSelector: !isTooltip,
     backColor: isTooltip ? '#fdffe5' : '#fffff',
-  }).root;
-  histRoot.style.width = 'auto';
+  }) as DG.Viewer<DG.IHistogramLookSettings>;
+  hist.root.style.width = 'auto';
+  return hist;
+}
 
-  const tableMap: StringDictionary = {
+export function getStatsTableMap(stats: Stats, options: {fractionDigits?: number} = {}): StringDictionary {
+  const tableMap = {
     'Statistics:': '',
     'Count': stats.count.toString(),
-    'Ratio': stats.ratio.toFixed(2),
-    'p-value': stats.pValue < 0.01 ? '<0.01' : stats.pValue.toFixed(2),
-    'Mean difference': stats.meanDifference.toFixed(2),
+    'Ratio': stats.ratio.toFixed(options.fractionDigits),
+    'p-value': stats.pValue < 0.01 ? '<0.01' : stats.pValue.toFixed(options.fractionDigits),
+    'Mean difference': stats.meanDifference.toFixed(options.fractionDigits),
   };
+  return tableMap;
+}
 
-  return {labels: labels, histRoot: histRoot, tableMap: tableMap};
+export function getDistributionLegend(thisLabel: string, otherLabel: string = ''): HTMLDivElement {
+  return ui.divV([
+    ui.label(thisLabel, {style: {color: DG.Color.toHtml(otherLabel.length === 0 ? DG.Color.blue : DG.Color.orange)}}),
+    ui.label(otherLabel, {style: {color: DG.Color.toHtml(DG.Color.blue)}})]);
 }

package/src/widgets/mutation-cliffs.ts

@@ -7,8 +7,8 @@ import {getSeparator} from '../utils/misc';
 
 export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
   const currentFilter = table.filter.getSelectedIndexes();
-  const substInfo = model.substitutionsInfo;
-  const currentCell = model.mutationCliffsSelection;
+  const substInfo = model.mutationCliffs;
+  const currentCell = model.monomerPositionSelection;
   const positions = Object.keys(currentCell);
 
   if (!positions.length)