@datagrok/peptides 1.16.0 → 1.17.0

package/src/viewers/sar-viewer.ts

@@ -21,11 +21,14 @@ export enum MONOMER_POSITION_PROPERTIES {
   COLOR_COLUMN_NAME = 'color',
   AGGREGATION = 'aggregation',
   TARGET = 'target',
-};
+}
+
+const MUTATION_CLIFFS_CELL_WIDTH = 40;
+const AAR_CELL_WIDTH = 30;
 
 /** Structure-activity relationship viewer */
 export class MonomerPosition extends DG.JsViewer {
-  _titleHost = ui.divText(SELECTION_MODE.MUTATION_CLIFFS, {id: 'pep-viewer-title'});
+  // _titleHost = ui.divText(SELECTION_MODE.MUTATION_CLIFFS, {id: 'pep-viewer-title'});
   _viewerGrid!: DG.Grid;
   _model!: PeptidesModel;
   color: string;
@@ -38,13 +41,11 @@ export class MonomerPosition extends DG.JsViewer {
     super();
     this.target = this.string(MONOMER_POSITION_PROPERTIES.TARGET, null,
       {category: SELECTION_MODE.MUTATION_CLIFFS, choices: []});
-    this.color = this.string(MONOMER_POSITION_PROPERTIES.COLOR_COLUMN_NAME, C.COLUMNS_NAMES.ACTIVITY_SCALED,
-      {category: SELECTION_MODE.INVARIANT_MAP,
-        choices: wu(grok.shell.t.columns.numerical).toArray().map((col) => col.name)});
+    this.color = this.string(MONOMER_POSITION_PROPERTIES.COLOR_COLUMN_NAME, C.COLUMNS_NAMES.ACTIVITY,
+      {category: SELECTION_MODE.INVARIANT_MAP, choices: wu(grok.shell.t.columns.numerical).toArray().map((col) => col.name)});
     this.aggregation = this.string(MONOMER_POSITION_PROPERTIES.AGGREGATION, DG.AGG.AVG,
       {category: SELECTION_MODE.INVARIANT_MAP,
-        choices: Object.values(DG.AGG)
-          .filter((agg) => ![DG.AGG.KEY, DG.AGG.PIVOT, DG.AGG.SELECTED_ROWS_COUNT].includes(agg))});
+        choices: Object.values(DG.AGG).filter((agg) => ![DG.AGG.KEY, DG.AGG.PIVOT, DG.AGG.SELECTED_ROWS_COUNT].includes(agg))});
   }
 
   get name(): string {return VIEWER_TYPE.MONOMER_POSITION;}
@@ -84,6 +85,10 @@ export class MonomerPosition extends DG.JsViewer {
     super.onPropertyChanged(property);
     if (property.name === MONOMER_POSITION_PROPERTIES.TARGET)
       this.model.updateMutationCliffs().then(() => this.render(true));
+    // this will cause colors to recalculate
+    this.model.df.columns.toList().forEach((col) => {
+      col.temp[C.TAGS.INVARIANT_MAP_COLOR_CACHE] = null;
+    });
 
     this.render(true);
   }
@@ -113,7 +118,8 @@ export class MonomerPosition extends DG.JsViewer {
     const monomerPositionDf = this.createMonomerPositionDf();
     this.viewerGrid = monomerPositionDf.plot.grid();
     this.viewerGrid.sort([C.COLUMNS_NAMES.MONOMER]);
-    this.viewerGrid.columns.setOrder([C.COLUMNS_NAMES.MONOMER, ...this.model.positionColumns.toArray().map((col) => col.name)]);
+    const positionColumns = this.model.positionColumns.toArray().map((col) => col.name);
+    this.viewerGrid.columns.setOrder([C.COLUMNS_NAMES.MONOMER, ...positionColumns]);
     const monomerCol = monomerPositionDf.getCol(C.COLUMNS_NAMES.MONOMER);
     CR.setMonomerRenderer(monomerCol, this.model.alphabet);
     this.viewerGrid.onCellRender.subscribe((args: DG.GridCellRenderArgs) => renderCell(args, this.model,
@@ -175,6 +181,8 @@ export class MonomerPosition extends DG.JsViewer {
               this.model.modifyMutationCliffsSelection(monomerPosition, {shiftPressed: true, ctrlPressed: false}, false);
           }
         }
+      } else {
+        return;
       }
       this.model.fireBitsetChanged();
       this.viewerGrid.invalidate();
@@ -197,7 +205,21 @@ export class MonomerPosition extends DG.JsViewer {
       this.showHelp();
     });
 
-    setViewerGridProps(this.viewerGrid, false);
+    setViewerGridProps(this.viewerGrid);
+
+    // Monomer cell renderer overrides width settings. This way I ensure is "initially" set.
+    const afterDraw = this.viewerGrid.onAfterDrawContent.subscribe(() => {
+      const monomerGCol = this.viewerGrid.col(C.COLUMNS_NAMES.MONOMER)!;
+      if (monomerGCol.width === AAR_CELL_WIDTH) {
+        afterDraw.unsubscribe();
+        return;
+      }
+      monomerGCol.width = AAR_CELL_WIDTH;
+      for (const posCol of positionColumns) {
+        const gcCol = this.viewerGrid.col(posCol)!;
+        gcCol.width = MUTATION_CLIFFS_CELL_WIDTH;
+      }
+    });
   }
 
   showHelp(): void {
@@ -212,6 +234,14 @@ export class MonomerPosition extends DG.JsViewer {
   }
 
   render(refreshOnly = false): void {
+    // Backward compatability with 1.16.0
+    const columnProperty = this.getProperty(MONOMER_POSITION_PROPERTIES.COLOR_COLUMN_NAME);
+    if (columnProperty) {
+      columnProperty.choices = wu(grok.shell.t.columns.numerical).toArray().map((col) => col.name);
+      if (columnProperty.get(this) === C.COLUMNS_NAMES.ACTIVITY_SCALED)
+        columnProperty.set(this, C.COLUMNS_NAMES.ACTIVITY);
+    }
+
     if (!refreshOnly) {
       $(this.root).empty();
       let switchHost = ui.divText(VIEWER_TYPE.MOST_POTENT_RESIDUES, {id: 'pep-viewer-title'});
@@ -254,7 +284,7 @@ export class MonomerPosition extends DG.JsViewer {
 
 /** Vertical structure activity relationship viewer */
 export class MostPotentResidues extends DG.JsViewer {
-  _titleHost = ui.divText(VIEWER_TYPE.MOST_POTENT_RESIDUES, {id: 'pep-viewer-title'});
+  // _titleHost = ui.divText(VIEWER_TYPE.MOST_POTENT_RESIDUES, {id: 'pep-viewer-title'});
   _viewerGrid!: DG.Grid;
   _model!: PeptidesModel;
   keyPressed: boolean = false;
@@ -350,6 +380,7 @@ export class MostPotentResidues extends DG.JsViewer {
     pValData.length = i;
     countData.length = i;
     ratioData.length = i;
+    meanData.length = i;
 
     const mprDf = DG.DataFrame.create(i); // Subtract 'general' entry from mp-stats
     const mprDfCols = mprDf.columns;
@@ -420,6 +451,8 @@ export class MostPotentResidues extends DG.JsViewer {
           const monomerPosition = this.getMonomerPosition(this.viewerGrid.cell('Diff', rowIdx));
           this.model.modifyMutationCliffsSelection(monomerPosition, {shiftPressed: true, ctrlPressed: false}, false);
         }
+      } else {
+        return;
       }
       this.model.fireBitsetChanged();
       this.viewerGrid.invalidate();
@@ -440,9 +473,19 @@ export class MostPotentResidues extends DG.JsViewer {
         grok.shell.windows.help.showHelp(ui.markdown(text));
       }).catch((e) => grok.log.error(e));
     });
+    setViewerGridProps(this.viewerGrid);
     const mdCol: DG.GridColumn = this.viewerGrid.col(C.COLUMNS_NAMES.MEAN_DIFFERENCE)!;
     mdCol.name = 'Diff';
-    setViewerGridProps(this.viewerGrid, true);
+    // Monomer cell renderer overrides width settings. This way I ensure is "initially" set.
+    const afterDraw = this.viewerGrid.onAfterDrawContent.subscribe(() => {
+      const monomerGCol = this.viewerGrid.col(C.COLUMNS_NAMES.MONOMER)!;
+      if (monomerGCol.width === AAR_CELL_WIDTH) {
+        afterDraw.unsubscribe();
+        return;
+      }
+      monomerGCol.width = AAR_CELL_WIDTH;
+      mdCol.width = MUTATION_CLIFFS_CELL_WIDTH;
+    });
   }
 
   getMonomerPosition(gridCell: DG.GridCell): SelectionItem {
@@ -464,7 +507,7 @@ export class MostPotentResidues extends DG.JsViewer {
 }
 
 function renderCell(args: DG.GridCellRenderArgs, model: PeptidesModel, isInvariantMap?: boolean,
-  colorCol?: DG.Column<number>, colorAgg?: DG.AGG, renderNums?: boolean): void {
+                    colorCol?: DG.Column<number>, colorAgg?: DG.AGG): void {
   const renderColNames = [...model.positionColumns.toArray().map((col) => col.name), C.COLUMNS_NAMES.MEAN_DIFFERENCE];
   const canvasContext = args.g;
   const bound = args.bounds;
@@ -505,31 +548,38 @@ function renderCell(args: DG.GridCellRenderArgs, model: PeptidesModel, isInvaria
   if (isInvariantMap) {
     const value = currentPosStats![currentMonomer]!.count;
     const positionCol = model.df.getCol(currentPosition);
-    const positionColData = positionCol.getRawData();
-    const positionColCategories = positionCol.categories;
-
-    const colorColData = colorCol!.getRawData();
-    const colorValuesIndexes: number[] = [];
-    for (let i = 0; i < positionCol.length; ++i) {
-      if (positionColCategories[positionColData[i]] === currentMonomer)
-        colorValuesIndexes.push(i);
-    }
-    const cellColorDataCol = DG.Column.float('color', colorValuesIndexes.length)
-      .init((i) => colorColData[colorValuesIndexes[i]]);
-    const colorColStats = colorCol!.stats;
+    const colorCache: {[_: string]: number} = positionCol.temp[C.TAGS.INVARIANT_MAP_COLOR_CACHE] ?? {};
+    let color: number | null = null;
+    if (colorCache[currentMonomer])
+      color = colorCache[currentMonomer];
+    else {
+      const positionColData = positionCol.getRawData();
+      const positionColCategories = positionCol.categories;
+
+      const colorColData = colorCol!.getRawData();
+      const colorValuesIndexes: number[] = [];
+      for (let i = 0; i < positionCol.length; ++i) {
+        if (positionColCategories[positionColData[i]] === currentMonomer)
+          colorValuesIndexes.push(i);
+      }
+      const cellColorDataCol = DG.Column.float('color', colorValuesIndexes.length)
+        .init((i) => colorColData[colorValuesIndexes[i]]);
+      const colorColStats = colorCol!.stats;
 
-    const color = DG.Color.scaleColor(cellColorDataCol.aggregate(colorAgg!), colorColStats.min, colorColStats.max);
-    CR.renderInvaraintMapCell(
-      canvasContext, currentMonomer, currentPosition, model.invariantMapSelection, value, bound, color);
+      color = DG.Color.scaleColor(cellColorDataCol.aggregate(colorAgg!), colorColStats.min, colorColStats.max);
+      colorCache[currentMonomer] = color;
+      positionCol.temp[C.TAGS.INVARIANT_MAP_COLOR_CACHE] = colorCache;
+    }
+    CR.renderInvariantMapCell(canvasContext, currentMonomer, currentPosition, model.invariantMapSelection, value, bound, color);
   } else {
     CR.renderMutationCliffCell(canvasContext, currentMonomer, currentPosition, model.monomerPositionStats, bound,
-      model.mutationCliffsSelection, model.mutationCliffs, renderNums);
+      model.mutationCliffsSelection, model.mutationCliffs);
   }
   args.preventDefault();
   canvasContext.restore();
 }
 
-function setViewerGridProps(grid: DG.Grid, isMostPotentResiduesGrid: boolean): void {
+function setViewerGridProps(grid: DG.Grid): void {
   const gridProps = grid.props;
   gridProps.allowEdit = false;
   gridProps.allowRowSelection = false;
@@ -539,12 +589,5 @@ function setViewerGridProps(grid: DG.Grid, isMostPotentResiduesGrid: boolean): v
   gridProps.showCurrentRowIndicator = false;
 
   gridProps.rowHeight = 20;
-  const girdCols = grid.columns;
-  const colNum = girdCols.length;
-  for (let i = 0; i < colNum; ++i) {
-    const col = girdCols.byIndex(i)!;
-    const colName = col.name;
-    col.width = isMostPotentResiduesGrid && colName !== 'Diff' && colName !== C.COLUMNS_NAMES.MONOMER ? 50 :
-      gridProps.rowHeight + 10;
-  }
+
 }

package/src/widgets/distribution.ts

@@ -1,227 +1,87 @@
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
+import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+
 import $ from 'cash-dom';
 
 import * as C from '../utils/constants';
 import {getAggregatedColumnValues, getStats, Stats} from '../utils/statistics';
 import {PeptidesModel} from '../model';
-import {getStatsSummary, prepareTableForHistogram} from '../utils/misc';
-import BitArray from '@datagrok-libraries/utils/src/bit-array';
-
-const allConst = 'All';
-const otherConst = 'Other';
+import {getDistributionPanel, getDistributionTable} from '../utils/misc';
 
 export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
   if (!table.selection.anyTrue)
     return new DG.Widget(ui.divText('No distribution'));
 
-  const activityCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
-  const activityColData = activityCol.getRawData();
+  const activityCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY);
   const rowCount = activityCol.length;
-  const selectionObject = model.invariantMapSelection;
-  const clustersColName = model.settings.clustersColumnName;
-  let clustersProcessedObject: string[] = [];
-  if (clustersColName)
-    clustersProcessedObject = Object.values(model.clusterSelection).flat();
 
-  const positions = Object.keys(selectionObject);
-  let monomerStr = allConst;
-  let otherStr = '';
+  // const setDefaultProperties = (input: DG.InputBase): void => {
+  //   input.enabled = !model.isMutationCliffsSelectionEmpty;
+  //   $(input.root).find('.ui-input-editor').css('margin', '0px');
+  //   $(input.root).find('.ui-input-description').css('padding', '0px').css('padding-left', '5px');
+  //   $(input.captionLabel).addClass('ui-label-right');
+  // };
+  //
+  // let defaultValuePos = model.splitByPos;
+  // let defaultValueMonomer = model.splitByMonomer;
+  // if (!model.isClusterSelectionEmpty && model.isMutationCliffsSelectionEmpty) {
+  //   defaultValuePos = false;
+  //   defaultValueMonomer = false;
+  // }
+
+  const distributionHost = ui.div([], 'd4-flex-wrap');
 
   const updateDistributionHost = (): void => {
-    model.splitByPos = splitByPosition.value!;
-    model.splitByMonomer = splitByMonomer.value!;
     const res: HTMLDivElement[] = [];
-    if (splitByPosition.value && splitByMonomer.value) {
-      otherStr = otherConst;
-      for (const position of positions) {
-        const monomerList = selectionObject[position];
-        if (monomerList.length === 0)
-          continue;
-
-        const posCol = table.getCol(position);
-        const posColCategories = posCol.categories;
-        const posColData = posCol.getRawData();
-
-        for (const monomer of monomerList) {
-          const labels = getDistributionLegend(`${position} : ${monomer}`, otherStr);
-
-          const monomerCategoryIndex = posColCategories.indexOf(monomer);
-          const mask = DG.BitSet.create(rowCount, (i) => posColData[i] === monomerCategoryIndex);
-          const distributionTable = DG.DataFrame.fromColumns(
-            [activityCol, DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask)]);
-          const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
-
-          const stats = model.monomerPositionStats[position]![monomer]!;
-          const tableMap = getStatsTableMap(stats);
-
-          const aggregatedColMap = getAggregatedColumnValues(model.df, model.settings.columns!, {filterDf: true, mask});
-
-          const resultMap = {...tableMap, ...aggregatedColMap};
-          const distributionRoot = getStatsSummary(labels, hist, resultMap);
-          $(distributionRoot).addClass('d4-flex-col');
-
-          res.push(distributionRoot);
-        }
-      }
-    } else if (splitByPosition.value) {
-      otherStr = otherConst;
-      for (const position of positions) {
-        const monomerList = selectionObject[position];
-        if (monomerList.length === 0)
-          continue;
-
-        monomerStr = `${position}: {${monomerList.join(', ')}}`;
-        const labels = getDistributionLegend(monomerStr, otherStr);
-
-        const posCol = table.getCol(position);
-        const posColCategories = posCol.categories;
-        const posColData = posCol.getRawData();
-        const monomerIndexesList = monomerList.map((monomer) => posColCategories.indexOf(monomer));
-        const mask = DG.BitSet.create(rowCount, (i) => monomerIndexesList.includes(posColData[i]));
-        const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
-
-        const aggregatedColMap = getAggregatedColumnValues(model.df, model.settings.columns!, {filterDf: true, mask});
-
-        const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
-        const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
-
-        const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
-        const stats = getStats(activityColData, bitArray);
-        const tableMap = getStatsTableMap(stats);
-
-        const resultMap = {...tableMap, ...aggregatedColMap};
-        const distributionRoot = getStatsSummary(labels, hist, resultMap);
-        $(distributionRoot).addClass('d4-flex-col');
-
-        res.push(distributionRoot);
-      }
-    } else if (splitByMonomer.value) {
-      const reversedSelectionObject: {[monomer: string]: string[]} = {};
-      const monomers = [];
-      for (const position of positions) {
-        for (const monomer of selectionObject[position]) {
-          if (!reversedSelectionObject.hasOwnProperty(monomer)) {
-            reversedSelectionObject[monomer] = [position];
-            monomers.push(monomer);
-            continue;
-          }
-          if (!reversedSelectionObject[monomer].includes(position))
-            reversedSelectionObject[monomer].push(position);
-        }
-      }
-
-      otherStr = otherConst;
-      for (const monomer of monomers) {
-        const posList = reversedSelectionObject[monomer];
-        const posColList = posList.map((pos) => table.getCol(pos));
-        const posColCategoriesList = posColList.map((posCol) => posCol.categories);
-        const posColDataList = posColList.map((posCol) => posCol.getRawData());
-        const monomerCategoryIndexList = posColCategoriesList.map((posColCategories) => posColCategories.indexOf(monomer));
-
-        monomerStr = `${monomer}: {${posList.join(', ')}}`;
-        const labels = getDistributionLegend(monomerStr, otherStr);
-
-        const mask = DG.BitSet.create(rowCount,
-          (i) => posColDataList.some((posColData, j) => posColData[i] === monomerCategoryIndexList[j]));
-        const aggregatedColMap = getAggregatedColumnValues(model.df, model.settings.columns!, {filterDf: true, mask});
-
-        const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
-        const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
-        const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
-
-        const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
-        const stats = getStats(activityColData, bitArray);
-        const tableMap = getStatsTableMap(stats);
-
-        const resultMap: {[key: string]: any} = {...tableMap, ...aggregatedColMap};
-        const distributionRoot = getStatsSummary(labels, hist, resultMap);
-        $(distributionRoot).addClass('d4-flex-col');
-
-        res.push(distributionRoot);
-      }
-    } else {
-      if (!table.selection.anyTrue)
-        res.push(ui.divText('No distribution'));
-      else {
-        otherStr = '';
-        if (Object.values(selectionObject).some((selectedAar) => selectedAar.length !== 0) ||
-          clustersProcessedObject.length !== 0) {
-          monomerStr = '';
-          for (const position of positions) {
-            const monomerList = selectionObject[position];
-            if (monomerList.length !== 0)
-              monomerStr += `${position}: {${monomerList.join(', ')}}; `;
-          }
-          if (clustersProcessedObject.length !== 0)
-            monomerStr += `Clusters: ${clustersProcessedObject.join(', ')}`;
-          otherStr = otherConst;
-        }
-        const labels = getDistributionLegend(monomerStr, otherStr);
-
-        const distributionTable = DG.DataFrame.fromColumns([activityCol, DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, table.selection)]);
-        const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
-        const bitArray = BitArray.fromString(table.selection.toBinaryString());
-        const mask = DG.BitSet.create(rowCount,
-          bitArray.allFalse || bitArray.allTrue ? (_): boolean => true : (i): boolean => bitArray.getBit(i));
-        const aggregatedColMap = getAggregatedColumnValues(model.df, model.settings.columns!, {filterDf: true, mask});
-        const stats = bitArray.allFalse || bitArray.allTrue ?
-          {count: rowCount, pValue: null, meanDifference: 0, ratio: 1, mask: bitArray,
-            mean: activityCol.stats.avg} :
-          getStats(activityColData, bitArray);
-        const tableMap = getStatsTableMap(stats);
-        const resultMap: {[key: string]: any} = {...tableMap, ...aggregatedColMap};
-        const distributionRoot = getStatsSummary(labels, hist, resultMap);
-        $(distributionRoot).addClass('d4-flex-col');
-
-        res.push(distributionRoot);
-      }
+    if (!table.selection.anyTrue)
+      res.push(ui.divText('No distribution'));
+    else {
+      const hist = getActivityDistribution(getDistributionTable(activityCol, model.df.selection, model.getCombinedSelection()));
+      const bitArray = BitArray.fromString(table.selection.toBinaryString());
+      const mask = DG.BitSet.create(rowCount,
+        bitArray.allFalse || bitArray.allTrue ? (_): boolean => true : (i): boolean => bitArray.getBit(i));
+      const aggregatedColMap = getAggregatedColumnValues(model.df, model.settings.columns!, {filterDf: true, mask});
+      const stats = bitArray.allFalse || bitArray.allTrue ?
+        {count: rowCount, pValue: null, meanDifference: 0, ratio: 1, mask: bitArray, mean: activityCol.stats.avg} :
+        getStats(activityCol.getRawData(), bitArray);
+      const tableMap = getStatsTableMap(stats);
+      const resultMap: { [key: string]: any } = {...tableMap, ...aggregatedColMap};
+      const distributionRoot = getDistributionPanel(hist, resultMap);
+      $(distributionRoot).addClass('d4-flex-col');
+
+      res.push(distributionRoot);
     }
-    $(distributionHost).empty().append(res);
-  };
 
-  const setDefaultProperties = (input: DG.InputBase): void => {
-    input.enabled = !model.isMutationCliffsSelectionEmpty;
-    $(input.root).find('.ui-input-editor').css('margin', '0px');
-    $(input.root).find('.ui-input-description').css('padding', '0px').css('padding-left', '5px');
-    $(input.captionLabel).addClass('ui-label-right');
+    $(distributionHost).empty().append(res);
   };
 
-  let defaultValuePos = model.splitByPos;
-  let defaultValueMonomer = model.splitByMonomer;
-  if (!model.isClusterSelectionEmpty && model.isMutationCliffsSelectionEmpty) {
-    defaultValuePos = false;
-    defaultValueMonomer = false;
-  }
-
-  const splitByPosition = ui.boolInput('Split by position', defaultValuePos, updateDistributionHost);
-  splitByPosition.setTooltip('Constructs distribution for each position separately');
-  setDefaultProperties(splitByPosition);
-  $(splitByPosition.root).css('margin-right', '10px');
-  const splitByMonomer = ui.boolInput('Split by monomer', defaultValueMonomer, updateDistributionHost);
-  splitByMonomer.setTooltip('Constructs distribution for each monomer separately');
-  setDefaultProperties(splitByMonomer);
-
-  const controlsHost = ui.divH([splitByPosition.root, splitByMonomer.root]);
-  const distributionHost = ui.div([], 'd4-flex-wrap');
-  splitByMonomer.fireChanged();
-
-  return new DG.Widget(ui.divV([controlsHost, distributionHost]));
+  // const splitByPosition = ui.boolInput('Split by position', defaultValuePos, updateDistributionHost);
+  // splitByPosition.setTooltip('Constructs distribution for each position separately');
+  // setDefaultProperties(splitByPosition);
+  // $(splitByPosition.root).css('margin-right', '10px');
+  // const splitByMonomer = ui.boolInput('Split by monomer', defaultValueMonomer, updateDistributionHost);
+  // splitByMonomer.setTooltip('Constructs distribution for each monomer separately');
+  // setDefaultProperties(splitByMonomer);
+
+  // const controlsHost = ui.divH([splitByPosition.root, splitByMonomer.root]);
+  // splitByMonomer.fireChanged();
+  updateDistributionHost();
+  return new DG.Widget(ui.divV([/*controlsHost,*/ distributionHost]));
 }
 
-export function getActivityDistribution(table: DG.DataFrame, isTooltip: boolean = false,
-): DG.Viewer<DG.IHistogramLookSettings> {
+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,
+    valueColumnName: C.COLUMNS_NAMES.ACTIVITY,
     splitColumnName: C.COLUMNS_NAMES.SPLIT_COL,
     legendVisibility: 'Never',
     showXAxis: true,
     showColumnSelector: false,
     showRangeSlider: false,
-    showBinSelector: !isTooltip,
+    showBinSelector: false,
     backColor: isTooltip ? '#fdffe5' : '#fffff',
   }) as DG.Viewer<DG.IHistogramLookSettings>;
   hist.root.style.width = 'auto';
@@ -239,9 +99,3 @@ export function getStatsTableMap(stats: Stats, options: {fractionDigits?: number
     tableMap['p-value'] = stats.pValue < 0.01 ? '<0.01' : stats.pValue.toFixed(options.fractionDigits);
   return 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

@@ -23,7 +23,7 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
   const alignedSeqCol = table.getCol(model.settings.sequenceColumnName!);
   const alignedSeqColCategories = alignedSeqCol.categories;
   const alignedSeqColData = alignedSeqCol.getRawData();
-  const activityScaledCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
+  const activityScaledCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY);
   const activityScaledColData = activityScaledCol.getRawData();
   const seenIndexes = new Map<number, number[]>();
   const uniqueSequencesBitSet = DG.BitSet.create(table.rowCount);
@@ -85,11 +85,10 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
     else
       pairsTable.filter.setAll(true);
   });
-  aminoToInput.setTooltip('Monomer to which the mutation was made');
+  aminoToInput.setTooltip('Filter the rows by the monomer that the mutation was substituted to');
 
   const pairsGrid = pairsTable.plot.grid();
   setGridProps(pairsGrid);
-  pairsGrid.root.style.height = '150px';
   substCol.semType = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
   substCol.tags[C.TAGS.SEPARATOR] = getSeparator(alignedSeqCol);
   substCol.tags[DG.TAGS.UNITS] = alignedSeqCol.tags[DG.TAGS.UNITS];
@@ -164,7 +163,6 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
   const uniqueSequencesGrid = uniqueSequencesTable.plot.grid();
   setGridProps(uniqueSequencesGrid);
   uniqueSequencesGrid.props.rowHeight = 20;
-  uniqueSequencesGrid.root.style.height = '250px';
   uniqueSequencesTable.filter.onChanged.subscribe(() => {
     const uniqueSelectedIndexes: number[] = [];
     for (const idx of pairsSelectedIndexes) {

package/src/widgets/peptides.ts

@@ -78,7 +78,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {h
 
       const hist = DG.DataFrame.fromColumns([scaledCol]).plot.histogram({
         filteringEnabled: false,
-        valueColumnName: C.COLUMNS_NAMES.ACTIVITY_SCALED,
+        valueColumnName: C.COLUMNS_NAMES.ACTIVITY,
         legendVisibility: 'Never',
         showXAxis: true,
         showColumnSelector: false,
@@ -169,7 +169,7 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
     newDfCols.add(scaledCol);
     for (const col of currentDf.columns) {
       if (col.getTag(C.TAGS.ANALYSIS_COL) !== `${true}`) {
-        if (col.name === scaledCol.name)
+        if (col.name.toLowerCase() === scaledCol.name.toLowerCase())
           col.name = currentDf.columns.getUnusedName(col.name);
         newDfCols.add(col);
       }
@@ -196,7 +196,7 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
     }
     newDf.setTag(C.TAGS.SETTINGS, JSON.stringify(settings));
 
-    let monomerType = 'HELM_AA';
+    let monomerType: string;
     if (peptidesCol.getTag(DG.TAGS.UNITS) === NOTATION.HELM) {
       const sampleSeq = peptidesCol.get(0)!;
       monomerType = sampleSeq.startsWith('PEPTIDE') ? 'HELM_AA' : 'HELM_BASE';

package/src/widgets/selection.ts

@@ -6,13 +6,13 @@ import {PeptidesModel} from '../model';
 import wu from 'wu';
 import {COLUMNS_NAMES} from '../utils/constants';
 import {addExpandIcon} from '../utils/misc';
-import {CellRendererOptions, WebLogoBounds, setWebLogoRenderer} from '../utils/cell-renderer';
+import {CellRendererOptions, setWebLogoRenderer, WebLogoBounds} from '../utils/cell-renderer';
 import {CachedWebLogoTooltip, SelectionItem} from '../utils/types';
 import {TooltipOptions} from '../utils/tooltips';
 import {calculateMonomerPositionStatistics} from '../utils/algorithms';
 
 export function getSelectionWidget(table: DG.DataFrame, model: PeptidesModel): HTMLElement {
-  const compBitset = model.getCompoundBitset();
+  const compBitset = model.getVisibleSelection();
   if (compBitset.trueCount === 0)
     return ui.divText('No compounds selected');
   const newTable = DG.DataFrame.create(table.rowCount);
@@ -29,7 +29,7 @@ export function getSelectionWidget(table: DG.DataFrame, model: PeptidesModel): H
     const sourceColCategories = sourceCol.categories;
     const getValue = numericalCols.some((col) => col.name === sourceCol.name) ? (i: number): number => sourceColRawData[i] :
       (i: number): string => sourceColCategories[sourceColRawData[i]];
-    const col = sourceCol.name === COLUMNS_NAMES.ACTIVITY_SCALED ?
+    const col = sourceCol.name === COLUMNS_NAMES.ACTIVITY ?
       newTable.columns.addNewFloat(gridCol.name).init((i) => getValue(i)) :
       newTable.columns.addNewVirtual(gridCol.name, (i) => getValue(i), sourceCol.type as DG.TYPE);
     for (const [tag, value] of sourceCol.tags)

package/src/widgets/settings.ts

@@ -62,7 +62,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   const activityCol = ui.columnInput(GENERAL_INPUTS.ACTIVITY, model.df,
     model.df.getCol(model.settings.activityColumnName!), () => result.activityColumnName = activityCol.value!.name,
     {filter: (col: DG.Column) => (col.type === DG.TYPE.FLOAT || col.type === DG.TYPE.INT) &&
-      col.name !== C.COLUMNS_NAMES.ACTIVITY_SCALED && col.stats.missingValueCount === 0});
+      col.name !== C.COLUMNS_NAMES.ACTIVITY && col.stats.missingValueCount === 0});
   activityCol.setTooltip('Numeric activity column');
   const activityScaling =
     ui.choiceInput(GENERAL_INPUTS.ACTIVITY_SCALING, currentScaling, Object.values(C.SCALING_METHODS),
@@ -120,7 +120,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   const includedColumnsInputs: DG.InputBase[] = [];
   for (const col of model.df.columns.numerical) {
     const colName = col.name;
-    if (colName === settings.activityColumnName || colName === C.COLUMNS_NAMES.ACTIVITY_SCALED)
+    if (colName === settings.activityColumnName || colName === C.COLUMNS_NAMES.ACTIVITY)
       continue;
 
     const isIncludedInput = ui.boolInput(COLUMNS_INPUTS.IS_INCLUDED, typeof (currentColumns)[colName] !== 'undefined',