@datagrok/peptides 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datagrok/peptides",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "author": {
     "name": "Volodymyr Dyma",
     "email": "vdyma@datagrok.ai"
@@ -12,10 +12,10 @@
     "directory": "packages/Peptides"
   },
   "dependencies": {
-    "@datagrok-libraries/bio": "^3.3.0",
+    "@datagrok-libraries/bio": "^5.0.0",
     "@datagrok-libraries/ml": "^2.0.1",
     "@datagrok-libraries/statistics": "^0.1.6",
-    "@datagrok-libraries/utils": "^0.4.1",
+    "@datagrok-libraries/utils": "^1.10.1",
     "cash-dom": "latest",
     "datagrok-api": "^1.6.0",
     "file-loader": "^6.2.0",
@@ -43,6 +43,10 @@
     "@types/node-fetch": "^2.6.2",
     "node-fetch": "^2.6.7"
   },
+  "grokDependencies": {
+    "@datagrok/bio": "latest",
+    "@datagrok/helm": "latest"
+  },
   "scripts": {
     "link-api": "npm link datagrok-api",
     "link-utils": "npm link @datagrok-libraries/utils",

package/src/model.ts

@@ -5,13 +5,12 @@ import * as DG from 'datagrok-api/dg';
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 
 import * as rxjs from 'rxjs';
-import $ from 'cash-dom';
 
 import * as C from './utils/constants';
 import * as type from './utils/types';
 import {calculateBarsData, getTypedArrayConstructor, isGridCellInvalid, scaleActivity} from './utils/misc';
 import {MutationCliffsViewer, SARViewerBase, MostPotentResiduesViewer} from './viewers/sar-viewer';
-import {renderBarchart, renderMutationCliffCell, setAARRenderer, renderInvaraintMapCell} from './utils/cell-renderer';
+import * as CR from './utils/cell-renderer';
 import {mutationCliffsWidget} from './widgets/mutation-cliffs';
 import {getDistributionAndStats, getDistributionWidget} from './widgets/distribution';
 import {getStats, Stats} from './utils/statistics';
@@ -35,9 +34,11 @@ export class PeptidesModel {
   df: DG.DataFrame;
   splitCol!: DG.Column<boolean>;
   edf: DG.DataFrame | null = null;
-  statsDf!: DG.DataFrame;
+  monomerPositionStatsDf!: DG.DataFrame;
+  clusterStatsDf!: DG.DataFrame;
   _mutationCliffsSelection: type.PositionToAARList = {};
   _invariantMapSelection: type.PositionToAARList = {};
+  _logoSummarySelection: number[] = [];
   substitutionsInfo: type.SubstitutionsInfo = new Map();
   isInitialized = false;
   currentView!: DG.TableView;
@@ -86,7 +87,6 @@ export class PeptidesModel {
     this.df.tags[C.TAGS.SELECTION] = JSON.stringify(selection);
     this.fireBitsetChanged();
     this.invalidateGrids();
-    this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
   }
 
   get invariantMapSelection(): type.PositionToAARList {
@@ -100,6 +100,17 @@ export class PeptidesModel {
     this.invalidateGrids();
   }
 
+  get logoSummarySelection(): number[] {
+    this._logoSummarySelection ??= JSON.parse(this.df.tags[C.TAGS.CLUSTER_SELECTION] || '[]');
+    return this._logoSummarySelection;
+  }
+  set logoSummarySelection(selection: number[]) {
+    this._logoSummarySelection = selection;
+    this.df.tags[C.TAGS.CLUSTER_SELECTION] = JSON.stringify(selection);
+    this.fireBitsetChanged();
+    this.invalidateGrids();
+  }
+
   get usedProperties(): {[propName: string]: string | number | boolean} {
     this._usedProperties = JSON.parse(this.df.tags['sarProperties'] ?? '{}');
     return this._usedProperties;
@@ -171,7 +182,8 @@ export class PeptidesModel {
   }
 
   updateDefault(): void {
-    const proprtyChanged = this.isPropertyChanged(this.mutationCliffsViewer) || this.isPropertyChanged(this.mostPotentResiduesViewer);
+    const proprtyChanged =
+      this.isPropertyChanged(this.mutationCliffsViewer) || this.isPropertyChanged(this.mostPotentResiduesViewer);
     if ((this.sourceGrid && !this._isUpdating && proprtyChanged) || !this.isInitialized) {
       this.isInitialized = true;
       this._isUpdating = true;
@@ -193,7 +205,7 @@ export class PeptidesModel {
       throw new Error(`Source grid is not initialized`);
 
     //Split the aligned sequence into separate AARs
-    const col: DG.Column<string> = this.df.columns.bySemType(C.SEM_TYPES.MACROMOLECULE)!;
+    const col = this.df.getCol(C.COLUMNS_NAMES.MACROMOLECULE);
     const alphabet = col.tags['alphabet'];
     const splitSeqDf = splitAlignedSequences(col);
 
@@ -204,12 +216,7 @@ export class PeptidesModel {
     const activityCol = this.df.columns.bySemType(C.SEM_TYPES.ACTIVITY)!;
     splitSeqDf.columns.add(activityCol);
 
-    this.joinDataFrames(positionColumns, splitSeqDf);
-
-    for (const dfCol of this.df.columns) {
-      if (positionColumns.includes(dfCol.name))
-        setAARRenderer(dfCol, alphabet, this.sourceGrid);
-    }
+    this.joinDataFrames(positionColumns, splitSeqDf, alphabet);
 
     this.sortSourceGrid();
 
@@ -223,11 +230,11 @@ export class PeptidesModel {
     matrixDf = matrixDf.unpivot([], positionColumns, C.COLUMNS_NAMES.POSITION, C.COLUMNS_NAMES.MONOMER);
 
     //statistics for specific AAR at a specific position
-    this.statsDf = this.calculateStatistics(matrixDf);
+    this.monomerPositionStatsDf = this.calculateMonomerPositionStatistics(matrixDf);
 
     // SAR matrix table
     //pivot a table to make it matrix-like
-    matrixDf = this.statsDf.groupBy([C.COLUMNS_NAMES.MONOMER])
+    matrixDf = this.monomerPositionStatsDf.groupBy([C.COLUMNS_NAMES.MONOMER])
       .pivot(C.COLUMNS_NAMES.POSITION)
       .add('first', C.COLUMNS_NAMES.MEAN_DIFFERENCE, '')
       .aggregate();
@@ -244,8 +251,10 @@ export class PeptidesModel {
     [this.mutationCliffsGrid, this.mostPotentResiduesGrid] =
       this.createGrids(matrixDf, sequenceDf, positionColumns, alphabet);
 
-    if (this.df.getTag(C.TAGS.CLUSTERS))
+    if (this.df.getTag(C.TAGS.CLUSTERS)) {
+      this.clusterStatsDf = this.calculateClusterStatistics();
       this.logoSummaryGrid = this.createLogoSummaryGrid();
+    }
 
     // init invariant map & mutation cliffs selections
     this.initSelections(positionColumns);
@@ -360,15 +369,22 @@ export class PeptidesModel {
     }
     this.invariantMapSelection = tempInvariantMapSelection;
     this.mutationCliffsSelection = mutationCliffsSelection;
+    this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
   }
 
-  joinDataFrames(positionColumns: string[], splitSeqDf: DG.DataFrame): void {
+  joinDataFrames(positionColumns: string[], splitSeqDf: DG.DataFrame, alphabet: string): void {
     // append splitSeqDf columns to source table and make sure columns are not added more than once
     const name = this.df.name;
-    const dfColsSet = new Set(this.df.columns.names());
-    if (!positionColumns.every((col: string) => dfColsSet.has(col))) {
-      this.df.join(splitSeqDf, [C.COLUMNS_NAMES.ACTIVITY], [C.COLUMNS_NAMES.ACTIVITY],
-        this.df.columns.names(), positionColumns, 'inner', true);
+    for (const colName of positionColumns) {
+      const col = this.df.col(colName);
+      const newCol = splitSeqDf.getCol(colName);
+      if (col === null)
+        this.df.columns.add(newCol);
+      else {
+        this.df.columns.remove(colName);
+        this.df.columns.add(newCol);
+      }
+      CR.setAARRenderer(newCol, alphabet, this.sourceGrid);
     }
     this.df.name = name;
     this.currentView.name = name;
@@ -393,8 +409,8 @@ export class PeptidesModel {
   }
 
   createScaledCol(activityScaling: string, splitSeqDf: DG.DataFrame): void {
-    const [scaledDf, newColName] =
-      scaleActivity(activityScaling, this.df, this.df.tags[C.COLUMNS_NAMES.ACTIVITY]);
+    const [scaledDf, _, newColName] =
+      scaleActivity(activityScaling, this.df.getCol(C.COLUMNS_NAMES.ACTIVITY));
     //TODO: make another func
     const scaledCol = scaledDf.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
     scaledCol.semType = C.SEM_TYPES.ACTIVITY_SCALED;
@@ -410,7 +426,7 @@ export class PeptidesModel {
     this.sourceGrid.columns.setOrder([newColName]);
   }
 
-  calculateStatistics(matrixDf: DG.DataFrame): DG.DataFrame {
+  calculateMonomerPositionStatistics(matrixDf: DG.DataFrame): DG.DataFrame {
     matrixDf = matrixDf.groupBy([C.COLUMNS_NAMES.POSITION, C.COLUMNS_NAMES.MONOMER]).aggregate();
 
     //calculate p-values based on t-test
@@ -427,7 +443,7 @@ export class PeptidesModel {
     for (let i = 0; i < matrixDf.rowCount; i++) {
       const position: string = posCol.get(i);
       const aar: string = aarCol.get(i);
-      const mask = DG.BitSet.create(sourceDfLen, (j) => this.df.get(position, j) == aar);
+      const mask = DG.BitSet.create(sourceDfLen, (j) => this.df.get(position, j) === aar);
       const stats = getStats(activityCol, mask);
 
       mdCol.set(i, stats.meanDifference);
@@ -436,23 +452,45 @@ export class PeptidesModel {
       ratioCol.set(i, stats.ratio);
     }
 
-    const countThreshold = 4;
-    matrixDf = matrixDf.rows.match(`${C.COLUMNS_NAMES.COUNT} >= ${countThreshold}`).toDataFrame();
-    matrixDf = matrixDf.rows.match(`${C.COLUMNS_NAMES.COUNT} <= ${sourceDfLen - countThreshold}`).toDataFrame();
-
+    const monomerCol = matrixDf.getCol(C.COLUMNS_NAMES.MONOMER);
+    matrixDf = matrixDf.clone(DG.BitSet.create(matrixDf.rowCount, (i) => monomerCol.get(i) ? true : false));
     return matrixDf as DG.DataFrame;
   }
 
+  calculateClusterStatistics(): DG.DataFrame {
+    const originalClustersCol = this.df.getCol(C.COLUMNS_NAMES.CLUSTERS);
+    const statsDf = this.df.groupBy([C.COLUMNS_NAMES.CLUSTERS]).aggregate();
+    const clustersCol = statsDf.getCol(C.COLUMNS_NAMES.CLUSTERS);
+    const statsDfCols = statsDf.columns;
+    const mdCol= statsDfCols.addNewFloat(C.COLUMNS_NAMES.MEAN_DIFFERENCE);
+    const pValCol = statsDfCols.addNewFloat(C.COLUMNS_NAMES.P_VALUE);
+    const countCol = statsDfCols.addNewInt(C.COLUMNS_NAMES.COUNT);
+    const ratioCol = statsDfCols.addNewFloat(C.COLUMNS_NAMES.RATIO);
+    const activityList: number[] = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED).toList();
+
+    for (let rowIdx = 0; rowIdx < clustersCol.length; ++rowIdx) {
+      const cluster = clustersCol.get(rowIdx);
+      const mask = DG.BitSet.create(activityList.length, (bitIdx) => originalClustersCol.get(bitIdx) === cluster);
+      const stats = getStats(activityList, mask);
+
+      mdCol.set(rowIdx, stats.meanDifference);
+      pValCol.set(rowIdx, stats.pValue);
+      countCol.set(rowIdx, stats.count);
+      ratioCol.set(rowIdx, stats.ratio);
+    }
+    return statsDf;
+  }
+
   setCategoryOrder(matrixDf: DG.DataFrame): void {
     let sortArgument: string = C.COLUMNS_NAMES.MEAN_DIFFERENCE;
     if (this.getViewer().bidirectionalAnalysis) {
-      const mdCol = this.statsDf.getCol(sortArgument);
+      const mdCol = this.monomerPositionStatsDf.getCol(sortArgument);
       sortArgument = 'Absolute Mean difference';
-      const absMDCol = this.statsDf.columns.addNewFloat(sortArgument);
+      const absMDCol = this.monomerPositionStatsDf.columns.addNewFloat(sortArgument);
       absMDCol.init((i) => Math.abs(mdCol.get(i)));
     }
 
-    const aarWeightsDf = this.statsDf.groupBy([C.COLUMNS_NAMES.MONOMER]).sum(sortArgument, 'weight')
+    const aarWeightsDf = this.monomerPositionStatsDf.groupBy([C.COLUMNS_NAMES.MONOMER]).sum(sortArgument, 'weight')
       .aggregate();
     const aarList = aarWeightsDf.getCol(C.COLUMNS_NAMES.MONOMER).toList();
     const getWeight = (aar: string): number => aarWeightsDf
@@ -469,7 +507,7 @@ export class PeptidesModel {
     // TODO: aquire ALL of the positions
     const columns = [C.COLUMNS_NAMES.MEAN_DIFFERENCE, C.COLUMNS_NAMES.MONOMER, C.COLUMNS_NAMES.POSITION,
       'Count', 'Ratio', C.COLUMNS_NAMES.P_VALUE];
-    let sequenceDf = this.statsDf.groupBy(columns)
+    let sequenceDf = this.monomerPositionStatsDf.groupBy(columns)
       .where('pValue <= 0.1')
       .aggregate();
 
@@ -505,8 +543,8 @@ export class PeptidesModel {
     pValGridCol.name = 'P-value';
 
     // Setting Monomer column renderer
-    setAARRenderer(mutationCliffsDf.getCol(C.COLUMNS_NAMES.MONOMER), alphabet, mutationCliffsGrid);
-    setAARRenderer(mostPotentResiduesDf.getCol(C.COLUMNS_NAMES.MONOMER), alphabet, mostPotentResiduesGrid);
+    CR.setAARRenderer(mutationCliffsDf.getCol(C.COLUMNS_NAMES.MONOMER), alphabet, mutationCliffsGrid);
+    CR.setAARRenderer(mostPotentResiduesDf.getCol(C.COLUMNS_NAMES.MONOMER), alphabet, mostPotentResiduesGrid);
 
     return [mutationCliffsGrid, mostPotentResiduesGrid];
   }
@@ -514,28 +552,75 @@ export class PeptidesModel {
   createLogoSummaryGrid(): DG.Grid {
     const summaryTable = this.df.groupBy([C.COLUMNS_NAMES.CLUSTERS]).aggregate();
     const summaryTableLength = summaryTable.rowCount;
-    const webLogoCol: DG.Column<string> = summaryTable.columns.addNew('WebLogo', DG.COLUMN_TYPE.STRING);
     const clustersCol: DG.Column<number> = summaryTable.getCol(C.COLUMNS_NAMES.CLUSTERS);
-    clustersCol.name = 'Clusters';
+    const membersCol: DG.Column<number> = summaryTable.columns.addNewInt('Members');
+    const webLogoCol: DG.Column<string> = summaryTable.columns.addNew('WebLogo', DG.COLUMN_TYPE.STRING);
     const tempDfList: DG.DataFrame[] = new Array(summaryTableLength);
     const originalClustersCol = this.df.getCol(C.COLUMNS_NAMES.CLUSTERS);
+    const peptideCol: DG.Column<string> = this.df.getCol(C.COLUMNS_NAMES.MACROMOLECULE);
 
     for (let index = 0; index < summaryTableLength; ++index) {
-      // const tempDf: DG.DataFrame = this.df.rows.match(`${C.COLUMNS_NAMES.CLUSTERS} = ${clustersCol.get(index)}`).toDataFrame();
-      const bs = DG.BitSet.create(this.df.rowCount);
-      bs.init((i) => clustersCol.get(index) === originalClustersCol.get(i));
-      const tempDf = this.df.clone(bs, [C.COLUMNS_NAMES.ALIGNED_SEQUENCE]);
-      tempDfList[index] = tempDf;
+      const indexes: number[] = [];
+      for (let j = 0; j < originalClustersCol.length; ++j) {
+        if (originalClustersCol.get(j) === clustersCol.get(index))
+          indexes.push(j);
+      }
+      const tCol = DG.Column.string('peptides', indexes.length);
+      tCol.init((i) => peptideCol.get(indexes[i]));
+
+      for (const tag of peptideCol.tags)
+        tCol.setTag(tag[0], tag[1]);
+
+      const dfSlice = DG.DataFrame.fromColumns([tCol]);
+      tempDfList[index] = dfSlice;
       webLogoCol.set(index, index.toString());
+      membersCol.set(index, dfSlice.rowCount);
     }
     webLogoCol.setTag(DG.TAGS.CELL_RENDERER, 'html');
 
     const grid = summaryTable.plot.grid();
+    const gridClustersCol = grid.col(C.COLUMNS_NAMES.CLUSTERS)!;
+    gridClustersCol.name = 'Clusters';
+    gridClustersCol.visible = true;
     grid.columns.rowHeader!.visible = false;
     grid.props.rowHeight = 55;
     grid.onCellPrepare((cell) => {
-      if (cell.isTableCell && cell.tableColumn?.name === 'WebLogo') 
-        tempDfList[parseInt(cell.cell.value)].plot.fromType('WebLogo').then((viewer) => cell.element = viewer.root);
+      if (cell.isTableCell && cell.tableColumn?.name === 'WebLogo') {
+        tempDfList[parseInt(cell.cell.value)].plot.fromType('WebLogo', {maxHeight: 50})
+          .then((viewer) => cell.element = viewer.root);
+      }
+    });
+    grid.root.addEventListener('click', (ev) => {
+      const cell = grid.hitTest(ev.offsetX, ev.offsetY);
+      if (!cell || !cell.isTableCell)
+        return;
+
+      const cluster = clustersCol.get(cell.tableRowIndex!)!;
+      summaryTable.currentRowIdx = -1;
+      if (ev.shiftKey)
+        this.modifyClusterSelection(cluster);
+      else
+        this.initClusterSelection(cluster);
+      this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
+    });
+    grid.onCellRender.subscribe((gridCellArgs) => {
+      const gc = gridCellArgs.cell;
+      if (gc.tableColumn?.name !== C.COLUMNS_NAMES.CLUSTERS || gc.isColHeader)
+        return;
+      const canvasContext = gridCellArgs.g;
+      const bound = gridCellArgs.bounds;
+      canvasContext.save();
+      canvasContext.beginPath();
+      canvasContext.rect(bound.x, bound.y, bound.width, bound.height);
+      canvasContext.clip();
+      CR.renderLogoSummaryCell(canvasContext, gc.cell.value, this.logoSummarySelection, bound);
+      gridCellArgs.preventDefault();
+      canvasContext.restore();
+    });
+    grid.onCellTooltip((cell, x, y) => {
+      if (!cell.isColHeader && cell.tableColumn?.name === C.COLUMNS_NAMES.CLUSTERS)
+        this.showTooltipCluster(cell.cell.value, x, y);
+      return true;
     });
     const webLogoGridCol = grid.columns.byName('WebLogo')!;
     webLogoGridCol.cellType = 'html';
@@ -544,6 +629,21 @@ export class PeptidesModel {
     return grid;
   }
 
+  modifyClusterSelection(cluster: number): void {
+    const tempSelection = this.logoSummarySelection;
+    const idx = tempSelection.indexOf(cluster);
+    if (idx !== -1)
+      tempSelection.splice(idx, 1);
+    else
+      tempSelection.push(cluster);
+
+    this.logoSummarySelection = tempSelection;
+  }
+
+  initClusterSelection(cluster: number): void {
+    this.logoSummarySelection = [cluster];
+  }
+
   setBarChartInteraction(): void {
     const eventAction = (ev: MouseEvent): void => {
       const cell = this.sourceGrid.hitTest(ev.offsetX, ev.offsetY);
@@ -578,8 +678,9 @@ export class PeptidesModel {
     const monomer = barPart.monomer;
     const position = barPart.position;
     if (ev.type === 'click') {
-      ev.shiftKey ? this.modifyCurrentSelection(monomer, position, true) :
-        this.initCurrentSelection(monomer, position, true);
+      ev.shiftKey ? this.modifyMonomerPositionSelection(monomer, position, true) :
+        this.initMonomerPositionSelection(monomer, position, true);
+      this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
     } else {
       const bar = `${monomer}:${position}`;
       if (this.cachedBarchartTooltip.bar == bar)
@@ -590,7 +691,7 @@ export class PeptidesModel {
   }
 
   setCellRenderers(renderColNames: string[]): void {
-    const mdCol = this.statsDf.getCol(C.COLUMNS_NAMES.MEAN_DIFFERENCE);
+    const mdCol = this.monomerPositionStatsDf.getCol(C.COLUMNS_NAMES.MEAN_DIFFERENCE);
     //decompose into two different renering funcs
     const renderCell = (args: DG.GridCellRenderArgs): void => {
       const canvasContext = args.g;
@@ -622,14 +723,16 @@ export class PeptidesModel {
 
           const viewer = this.getViewer();
           if (this.isInvariantMap) {
-            const value: number = this.statsDf
+            const value: number = this.monomerPositionStatsDf
               .groupBy([C.COLUMNS_NAMES.POSITION, C.COLUMNS_NAMES.MONOMER, C.COLUMNS_NAMES.COUNT])
               .where(`${C.COLUMNS_NAMES.POSITION} = ${currentPosition} and ${C.COLUMNS_NAMES.MONOMER} = ${currentAAR}`)
               .aggregate().get(C.COLUMNS_NAMES.COUNT, 0);
-            renderInvaraintMapCell(canvasContext, currentAAR, currentPosition, this.invariantMapSelection, value, bound);
+            CR.renderInvaraintMapCell(
+              canvasContext, currentAAR, currentPosition, this.invariantMapSelection, value, bound);
           } else {
-            renderMutationCliffCell(canvasContext, currentAAR, currentPosition, this.statsDf,
-              viewer.bidirectionalAnalysis, mdCol, bound, cellValue, this.mutationCliffsSelection, this.substitutionsInfo);
+            CR.renderMutationCliffCell(
+              canvasContext, currentAAR, currentPosition, this.monomerPositionStatsDf, viewer.bidirectionalAnalysis,
+              mdCol, bound, cellValue, this.mutationCliffsSelection, this.substitutionsInfo);
           }
         }
         args.preventDefault();
@@ -651,7 +754,7 @@ export class PeptidesModel {
       context.clip();
 
       if (gcArgs.cell.isColHeader && col?.semType == C.SEM_TYPES.MONOMER) {
-        const barBounds = renderBarchart(context, col, this.barData[col.name], bounds, this.df.filter.trueCount);
+        const barBounds = CR.renderBarchart(context, col, this.barData[col.name], bounds, this.df.filter.trueCount);
         this.barsBounds[col.name] = barBounds;
         gcArgs.preventDefault();
       }
@@ -708,8 +811,9 @@ export class PeptidesModel {
   }
 
   showTooltipAt(aar: string, position: string, x: number, y: number): HTMLDivElement | null {
-    const currentStatsDf = this.statsDf.rows.match({Pos: position, AAR: aar}).toDataFrame();
+    const currentStatsDf = this.monomerPositionStatsDf.rows.match({Pos: position, AAR: aar}).toDataFrame();
     const activityCol = this.df.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!;
+    //TODO: use bitset instead of splitCol
     const splitCol = DG.Column.bool(C.COLUMNS_NAMES.SPLIT_COL, activityCol.length);
     const currentPosCol = this.df.getCol(position);
     splitCol.init((i) => currentPosCol.get(i) == aar);
@@ -730,15 +834,40 @@ export class PeptidesModel {
     return tooltip;
   }
 
+  showTooltipCluster(cluster: number, x: number, y: number): HTMLDivElement | null {
+    const currentStatsDf = this.clusterStatsDf.rows.match({clusters: cluster}).toDataFrame();
+    const activityCol = this.df.columns.bySemType(C.SEM_TYPES.ACTIVITY_SCALED)!;
+    //TODO: use bitset instead of splitCol
+    const splitCol = DG.Column.bool(C.COLUMNS_NAMES.SPLIT_COL, activityCol.length);
+    const currentClusterCol = this.df.getCol(C.COLUMNS_NAMES.CLUSTERS);
+    splitCol.init((i) => currentClusterCol.get(i) == cluster);
+    const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
+    const stats: Stats = {
+      count: currentStatsDf.get(C.COLUMNS_NAMES.COUNT, 0),
+      ratio: currentStatsDf.get(C.COLUMNS_NAMES.RATIO, 0),
+      pValue: currentStatsDf.get(C.COLUMNS_NAMES.P_VALUE, 0),
+      meanDifference: currentStatsDf.get(C.COLUMNS_NAMES.MEAN_DIFFERENCE, 0),
+    };
+    if (!stats.count)
+      return null;
+
+    const tooltip = getDistributionAndStats(distributionTable, stats, `Cluster: ${cluster}`, 'Other', true);
+
+    ui.tooltip.show(tooltip, x, y);
+
+    return tooltip;
+  }
+
   setInteractionCallback(): void {
     const mutationCliffsDf = this.mutationCliffsGrid.dataFrame;
     const mostPotentResiduesDf = this.mostPotentResiduesGrid.dataFrame;
-    // const invariantMapDf = this.invariantMapGrid.dataFrame;
 
     const chooseAction =
-      (aar: string, position: string, isShiftPressed: boolean, isInvariantMapSelection: boolean = true): void =>
-        isShiftPressed ? this.modifyCurrentSelection(aar, position, isInvariantMapSelection) :
-          this.initCurrentSelection(aar, position, isInvariantMapSelection);
+      (aar: string, position: string, isShiftPressed: boolean, isInvariantMapSelection: boolean = true): void => {
+        isShiftPressed ? this.modifyMonomerPositionSelection(aar, position, isInvariantMapSelection) :
+          this.initMonomerPositionSelection(aar, position, isInvariantMapSelection);
+        this.barData = calculateBarsData(this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER), this.df.selection);
+      };
 
     this.mutationCliffsGrid.root.addEventListener('click', (ev) => {
       const gridCell = this.mutationCliffsGrid.hitTest(ev.offsetX, ev.offsetY);
@@ -758,7 +887,7 @@ export class PeptidesModel {
       const tableRowIdx = gridCell!.tableRowIndex!;
       const position = mostPotentResiduesDf.get(C.COLUMNS_NAMES.POSITION, tableRowIdx);
       const aar = mostPotentResiduesDf.get(C.COLUMNS_NAMES.MONOMER, tableRowIdx);
-      chooseAction(aar, position, ev.shiftKey);
+      chooseAction(aar, position, ev.shiftKey, false);
     });
 
     const cellChanged = (table: DG.DataFrame): void => {
@@ -772,17 +901,14 @@ export class PeptidesModel {
     this.mostPotentResiduesGrid.onCurrentCellChanged.subscribe((_gc) => cellChanged(mostPotentResiduesDf));
   }
 
-  modifyCurrentSelection(aar: string, position: string, isInvariantMapSelection: boolean): void {
+  modifyMonomerPositionSelection(aar: string, position: string, isInvariantMapSelection: boolean): void {
     const tempSelection = isInvariantMapSelection ? this.invariantMapSelection : this.mutationCliffsSelection;
-    if (!tempSelection.hasOwnProperty(position))
-      tempSelection[position] = [aar];
-    else {
-      const tempSelectionAt = tempSelection[position];
-      const aarIndex = tempSelectionAt.indexOf(aar);
-      aarIndex == -1 ? tempSelectionAt.push(aar) :
-        tempSelectionAt.length == 1 ? delete tempSelection[position] :
-          tempSelectionAt.splice(aarIndex, 1);
-    }
+    const tempSelectionAt = tempSelection[position];
+    const aarIndex = tempSelectionAt.indexOf(aar);
+    if (aarIndex === -1)
+      tempSelectionAt.push(aar);
+    else
+      tempSelectionAt.splice(aarIndex, 1);
 
     if (isInvariantMapSelection)
       this.invariantMapSelection = tempSelection;
@@ -790,8 +916,10 @@ export class PeptidesModel {
       this.mutationCliffsSelection = tempSelection;
   }
 
-  initCurrentSelection(aar: string, position: string, isInvariantMapSelection: boolean): void {
-    const tempSelection: type.PositionToAARList = {};
+  initMonomerPositionSelection(aar: string, position: string, isInvariantMapSelection: boolean): void {
+    const tempSelection = isInvariantMapSelection ? this.invariantMapSelection : this.mutationCliffsSelection;
+    for (const key of Object.keys(tempSelection))
+      tempSelection[key] = [];
     tempSelection[position] = [aar];
 
     if (isInvariantMapSelection)
@@ -803,8 +931,8 @@ export class PeptidesModel {
   invalidateGrids(): void {
     this.mutationCliffsGrid.invalidate();
     this.mostPotentResiduesGrid.invalidate();
+    this.logoSummaryGrid?.invalidate();
     this.sourceGrid?.invalidate();
-    //TODO: this.peptideSpaceGrid.invalidate();
   }
 
   setBitsetCallback(): void {
@@ -812,6 +940,7 @@ export class PeptidesModel {
       return;
     const selection = this.df.selection;
     const filter = this.df.filter;
+    const clusterCol = this.df.col(C.COLUMNS_NAMES.CLUSTERS);
 
     const changeSelectionBitset = (currentBitset: DG.BitSet): void => {
       const edfSelection = this.edf?.selection;
@@ -830,11 +959,6 @@ export class PeptidesModel {
       };
 
       const positionList = Object.keys(this.mutationCliffsSelection);
-      if (positionList.length == 0) {
-        currentBitset.init(() => false, false);
-        updateEdfSelection();
-        return;
-      }
 
       //TODO: move out
       const getBitAt = (i: number): boolean => {
@@ -843,6 +967,8 @@ export class PeptidesModel {
           if (this._mutationCliffsSelection[position].includes(positionCol.get(i)!))
             return true;
         }
+        if (this._logoSummarySelection.includes(clusterCol?.get(i)!))
+          return true;
         return false;
       };
       currentBitset.init(getBitAt, false);
@@ -885,10 +1011,9 @@ export class PeptidesModel {
       for (let i = 0; i < colNum; ++i) {
         const col = girdCols.byIndex(i)!;
         const colName = col.name;
-        if (grid == this.mostPotentResiduesGrid && colName !== 'Diff' && colName !== C.COLUMNS_NAMES.MONOMER)
-          col.width = 50;
-        else
-          col.width = gridProps.rowHeight + 10;
+        col.width =
+          grid == this.mostPotentResiduesGrid && colName !== 'Diff' && colName !== C.COLUMNS_NAMES.MONOMER ? 50 :
+            gridProps.rowHeight + 10;
       }
     }
 
@@ -951,7 +1076,9 @@ export class PeptidesModel {
       return;
 
     this.df.tags[C.PEPTIDES_ANALYSIS] = 'true';
-    this.sourceGrid.col(C.COLUMNS_NAMES.ACTIVITY_SCALED)!.name = this.df.tags[C.COLUMNS_NAMES.ACTIVITY_SCALED];
+    const scaledGridCol = this.sourceGrid.col(C.COLUMNS_NAMES.ACTIVITY_SCALED)!;
+    scaledGridCol.name = this.df.tags[C.COLUMNS_NAMES.ACTIVITY_SCALED];
+    scaledGridCol.format = '#.000';
     this.sourceGrid.columns.setOrder([this.df.tags[C.COLUMNS_NAMES.ACTIVITY_SCALED]]);
     this.sourceGrid.props.allowColSelection = false;
 
@@ -966,10 +1093,9 @@ export class PeptidesModel {
     };
 
     for (let i = 0; i < this.sourceGrid.columns.length; i++) {
-      const aarCol = this.sourceGrid.columns.byIndex(i);
-      if (aarCol && aarCol.name && aarCol.column?.semType !== C.SEM_TYPES.MONOMER &&
-        aarCol.name !== this.df.tags[C.COLUMNS_NAMES.ACTIVITY_SCALED])
-        aarCol.visible = false;
+      const currentCol = this.sourceGrid.columns.byIndex(i);
+      if (currentCol?.column?.getTag(C.TAGS.VISIBLE) === '0')
+        currentCol.visible = false;
     }
 
     const options = {scaling: this.df.tags['scaling']};
@@ -986,14 +1112,6 @@ export class PeptidesModel {
       dockManager.dock(logoSummary, DG.DOCK_TYPE.RIGHT, null, 'Logo Summary Table');
     }
 
-    // TODO: completely remove this viewer?
-    // if (this.df.rowCount <= 10000) {
-    //   const peptideSpaceViewerOptions = {method: 'UMAP', measure: 'Levenshtein', cyclesCount: 100};
-    //   const peptideSpaceViewer =
-    //     await this.df.plot.fromType('peptide-space-viewer', peptideSpaceViewerOptions) as PeptideSpaceViewer;
-    //   dockManager.dock(peptideSpaceViewer, DG.DOCK_TYPE.RIGHT, null, 'Peptide Space Viewer');
-    // }
-
     this.updateDefault();
 
     const mcNode =

package/src/package.ts

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 
 import * as C from './utils/constants';
 
-import {analyzePeptidesWidget} from './widgets/analyze-peptides';
+import {analyzePeptidesWidget} from './widgets/peptides';
 import {PeptideSimilaritySpaceWidget} from './utils/peptide-similarity-space';
 import {manualAlignmentWidget} from './widgets/manual-alignment';
 import {MutationCliffsViewer, MostPotentResiduesViewer} from './viewers/sar-viewer';
@@ -155,7 +155,8 @@ export function getPeptidesStructure(col: DG.Column): DG.Widget {
 
 function getOrDefine(dataframe?: DG.DataFrame, column?: DG.Column | null): [DG.DataFrame, DG.Column] {
   dataframe ??= grok.shell.t;
-  column ??= dataframe.columns.bySemType(C.SEM_TYPES.MACROMOLECULE);
+  // column ??= dataframe.columns.bySemType(C.SEM_TYPES.MACROMOLECULE);
+  column ??= dataframe.getCol(C.COLUMNS_NAMES.MACROMOLECULE);
   if (column === null)
     throw new Error('Table does not contain aligned sequence columns');