@datagrok/peptides 1.9.2 → 1.11.3

package/src/model.ts

@@ -12,15 +12,17 @@ import {DistanceMatrix} from '@datagrok-libraries/ml/src/distance-matrix';
 import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
 import {TAGS as treeTAGS} from '@datagrok-libraries/bio/src/trees';
+import BitArray from '@datagrok-libraries/utils/src/bit-array';
 
 import wu from 'wu';
 import * as rxjs from 'rxjs';
 import * as uuid from 'uuid';
+import $ from 'cash-dom';
 
 import * as C from './utils/constants';
 import * as type from './utils/types';
-import {calculateSelected, extractColInfo, scaleActivity, getStatsSummary} from './utils/misc';
-import {MONOMER_POSITION_PROPERTIES, MonomerPosition, MostPotentResiduesViewer} from './viewers/sar-viewer';
+import {calculateSelected, extractColInfo, scaleActivity, getStatsSummary, prepareTableForHistogram, getTemplate} from './utils/misc';
+import {MONOMER_POSITION_PROPERTIES, MonomerPosition, MostPotentResidues} from './viewers/sar-viewer';
 import * as CR from './utils/cell-renderer';
 import {mutationCliffsWidget} from './widgets/mutation-cliffs';
 import {getActivityDistribution, getDistributionLegend, getDistributionWidget, getStatsTableMap,
@@ -31,7 +33,8 @@ import {getSettingsDialog} from './widgets/settings';
 import {_package, getMonomerWorksInstance, getTreeHelperInstance} from './package';
 import {findMutations} from './utils/algorithms';
 import {createDistanceMatrixWorker} from './utils/worker-creator';
-import BitArray from '@datagrok-libraries/utils/src/bit-array';
+import {calculateIdentity, calculateSimilarity} from './widgets/similarity';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
 
 export type SummaryStats = {
   minCount: number, maxCount: number,
@@ -60,12 +63,6 @@ export const getAggregatedColName = (aggF: string, colName: string): string => `
 export class PeptidesModel {
   static modelName = 'peptidesModel';
 
-  _settingsSubject: rxjs.Subject<type.PeptidesSettings> = new rxjs.Subject();
-  _monomerPositionSelectionSubject: rxjs.Subject<undefined> = new rxjs.Subject();
-  _newClusterSubject: rxjs.Subject<undefined> = new rxjs.Subject();
-  _removeClusterSubject: rxjs.Subject<undefined> = new rxjs.Subject();
-  _filterChangedSubject: rxjs.Subject<undefined> = new rxjs.Subject();
-
   _isUpdating: boolean = false;
   isBitsetChangedInitialized = false;
   isCellChanging = false;
@@ -75,8 +72,8 @@ export class PeptidesModel {
   splitCol!: DG.Column<boolean>;
   _monomerPositionStats?: MonomerPositionStats;
   _clusterStats?: ClusterTypeStats;
-  _monomerPositionSelection!: type.PositionToAARList;
-  _monomerPositionFilter!: type.PositionToAARList;
+  _mutationCliffsSelection!: type.PositionToAARList;
+  _invariantMapSelection!: type.PositionToAARList;
   _clusterSelection!: string[];
   _mutationCliffs: type.MutationCliffs | null = null;
   isInitialized = false;
@@ -90,8 +87,6 @@ export class PeptidesModel {
   isRibbonSet = false;
 
   _cp?: SeqPalette;
-  initBitset: DG.BitSet;
-  isInvariantMapTrigger: boolean = false;
   headerSelectedMonomers: type.MonomerSelectionStats = {};
   webLogoBounds: {[positon: string]: {[monomer: string]: DG.Rect}} = {};
   cachedWebLogoTooltip: {bar: string, tooltip: HTMLDivElement | null} = {bar: '', tooltip: null};
@@ -101,12 +96,12 @@ export class PeptidesModel {
   _matrixDf?: DG.DataFrame;
   _splitSeqDf?: DG.DataFrame;
   _distanceMatrix!: DistanceMatrix;
-  _treeHelper!: ITreeHelper;
   _dm!: DistanceMatrix;
+  _layoutEventInitialized = false;
+  isToolboxSet: boolean = false;
 
   private constructor(dataFrame: DG.DataFrame) {
     this.df = dataFrame;
-    this.initBitset = this.df.filter.clone();
   }
 
   static getInstance(dataFrame: DG.DataFrame): PeptidesModel {
@@ -123,11 +118,6 @@ export class PeptidesModel {
     return id;
   }
 
-  get treeHelper(): ITreeHelper {
-    this._treeHelper ??= getTreeHelperInstance();
-    return this._treeHelper;
-  }
-
   get monomerPositionDf(): DG.DataFrame {
     this._monomerPositionDf ??= this.createMonomerPositionDf();
     return this._monomerPositionDf;
@@ -146,15 +136,6 @@ export class PeptidesModel {
     this._monomerPositionStats = mps;
   }
 
-  get matrixDf(): DG.DataFrame {
-    this._matrixDf ??= this.buildMatrixDf();
-    return this._matrixDf;
-  }
-
-  set matrixDf(df: DG.DataFrame) {
-    this._matrixDf = df;
-  }
-
   get splitSeqDf(): DG.DataFrame {
     this._splitSeqDf ??= this.buildSplitSeqDf();
     return this._splitSeqDf;
@@ -179,10 +160,6 @@ export class PeptidesModel {
   }
 
   get mutationCliffs(): type.MutationCliffs | null {
-    // if (this._mutationCliffs)
-    //   return this._mutationCliffs;
-
-    // this.updateMutationCliffs(false);
     return this._mutationCliffs!;
   }
 
@@ -209,59 +186,55 @@ export class PeptidesModel {
   }
 
   get analysisView(): DG.TableView {
-    this._analysisView ??=
-      wu(grok.shell.tableViews).find(({dataFrame}) => dataFrame.getTag(C.TAGS.UUID) === this.id) ??
-        grok.shell.addTableView(this.df);
-    if (this.df.getTag(C.TAGS.MULTIPLE_VIEWS) !== '1')
+    if (this._analysisView === undefined) {
+      this._analysisView = wu(grok.shell.tableViews).find(({dataFrame}) => dataFrame?.getTag(C.TAGS.UUID) === this.id);
+      if (this._analysisView === undefined) {
+        this._analysisView = grok.shell.addTableView(this.df);
+        const posCols = this.splitSeqDf.columns.names();
+
+        for (let colIdx = 1; colIdx < this._analysisView.grid.columns.length; ++colIdx) {
+          const gridCol = this._analysisView.grid.columns.byIndex(colIdx)!;
+          gridCol.visible =
+            posCols.includes(gridCol.column!.name) || (gridCol.column!.name === C.COLUMNS_NAMES.ACTIVITY_SCALED);
+        }
+      }
+    }
+
+    if (this.df.getTag(C.TAGS.MULTIPLE_VIEWS) !== '1' && !this._layoutEventInitialized)
       grok.shell.v = this._analysisView;
 
+    this._analysisView.grid.invalidate();
     return this._analysisView;
   }
 
-  get onMonomerPositionSelectionChanged(): rxjs.Observable<undefined> {
-    return this._monomerPositionSelectionSubject.asObservable();
-  }
-
-  get onSettingsChanged(): rxjs.Observable<type.PeptidesSettings> {
-    return this._settingsSubject.asObservable();
-  }
-
-  get onNewCluster(): rxjs.Observable<undefined> {
-    return this._newClusterSubject.asObservable();
-  }
-
-  get onRemoveCluster(): rxjs.Observable<undefined> {
-    return this._removeClusterSubject.asObservable();
-  }
-
-  get onFilterChanged(): rxjs.Observable<undefined> {
-    return this._filterChangedSubject.asObservable();
+  get mutationCliffsSelection(): type.PositionToAARList {
+    this._mutationCliffsSelection ??= JSON.parse(this.df.tags[C.TAGS.SELECTION] || '{}');
+    return this._mutationCliffsSelection;
   }
 
-  get monomerPositionSelection(): type.PositionToAARList {
-    this._monomerPositionSelection ??= JSON.parse(this.df.tags[C.TAGS.SELECTION] || '{}');
-    return this._monomerPositionSelection;
-  }
-
-  set monomerPositionSelection(selection: type.PositionToAARList) {
-    this._monomerPositionSelection = selection;
+  set mutationCliffsSelection(selection: type.PositionToAARList) {
+    this._mutationCliffsSelection = selection;
     this.df.tags[C.TAGS.SELECTION] = JSON.stringify(selection);
     this.fireBitsetChanged();
-    this._monomerPositionSelectionSubject.next();
+
+    const mpViewer = this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
+    mpViewer?.viewerGrid.invalidate();
+    const mprViewer = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues | null;
+    mprViewer?.viewerGrid.invalidate();
+
     this.analysisView.grid.invalidate();
   }
 
-  get monomerPositionFilter(): type.PositionToAARList {
-    this._monomerPositionFilter ??= JSON.parse(this.df.tags[C.TAGS.FILTER] || '{}');
-    return this._monomerPositionFilter;
+  get invariantMapSelection(): type.PositionToAARList {
+    this._invariantMapSelection ??=
+      JSON.parse(this.df.tags[C.TAGS.INVARIANT_MAP_SELECTION] || this.df.tags[C.TAGS.FILTER] || '{}');
+    return this._invariantMapSelection;
   }
 
-  set monomerPositionFilter(selection: type.PositionToAARList) {
-    this._monomerPositionFilter = selection;
-    this.df.tags[C.TAGS.FILTER] = JSON.stringify(selection);
-    this.isInvariantMapTrigger = true;
-    this.fireBitsetChanged(true);
-    this.isInvariantMapTrigger = false;
+  set invariantMapSelection(selection: type.PositionToAARList) {
+    this._invariantMapSelection = selection;
+    this.df.tags[C.TAGS.INVARIANT_MAP_SELECTION] = JSON.stringify(selection);
+    this.fireBitsetChanged();
     this.analysisView.grid.invalidate();
   }
 
@@ -298,7 +271,7 @@ export class PeptidesModel {
   }
 
   get isMonomerPositionSelectionEmpty(): boolean {
-    for (const aarList of Object.values(this.monomerPositionSelection)) {
+    for (const aarList of Object.values(this.mutationCliffsSelection)) {
       if (aarList.length !== 0)
         return false;
     }
@@ -326,6 +299,7 @@ export class PeptidesModel {
     for (const [key, value] of newSettingsEntries) {
       this._settings[key as keyof type.PeptidesSettings] = value as any;
       switch (key) {
+      case 'activityColumnName':
       case 'scaling':
         updateVars.add('activity');
         updateVars.add('mutationCliffs');
@@ -363,12 +337,11 @@ export class PeptidesModel {
         break;
       case 'stats':
         this.monomerPositionStats = this.calculateMonomerPositionStatistics();
-        this.monomerPositionDf = this.createMonomerPositionDf();
         this.mostPotentResiduesDf = this.createMostPotentResiduesDf();
         this.clusterStats = this.calculateClusterStatistics();
         break;
       case 'grid':
-        this.postProcessGrids();
+        this.setGridProperties();
         break;
       case 'dendrogram':
         this.settings.showDendrogram ? this.addDendrogram() : this.closeViewer(VIEWER_TYPE.DENDROGRAM);
@@ -389,7 +362,23 @@ export class PeptidesModel {
     }
 
     //TODO: handle settings change
-    this._settingsSubject.next(this.settings);
+    const mpViewer = this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
+    mpViewer?.createMonomerPositionGrid();
+    mpViewer?.render();
+    const mprViewer = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues | null;
+    mprViewer?.createMostPotentResiduesGrid();
+    mprViewer?.render();
+    const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+    lstViewer?.createLogoSummaryTableGrid();
+    lstViewer?.render();
+  }
+
+  get identityTemplate(): string {
+    return this.df.getTag(C.TAGS.IDENTITY_TEMPLATE) ?? '';
+  }
+
+  set identityTemplate(template: string) {
+    this.df.setTag(C.TAGS.IDENTITY_TEMPLATE, template);
   }
 
   updateMutationCliffs(notify: boolean = true): void {
@@ -409,34 +398,23 @@ export class PeptidesModel {
   }
 
   createMonomerPositionDf(): DG.DataFrame {
-    const positions = this.splitSeqDf.columns.names();
-    const matrixDf = this.matrixDf
-      .groupBy([C.COLUMNS_NAMES.MONOMER])
-      .aggregate();
-    for (const pos of positions)
-      matrixDf.columns.addNewString(pos);
-
-    const monomerCol = matrixDf.getCol(C.COLUMNS_NAMES.MONOMER);
-    for (let i = 0; i < monomerCol.length; ++i) {
-      if (monomerCol.get(i) === '') {
-        matrixDf.rows.removeAt(i);
-        break;
+    const uniqueMonomers = new Set<string>();
+    const splitSeqCols = this.splitSeqDf.columns;
+    for (const col of splitSeqCols) {
+      const colCat = col.categories;
+      for (const cat of colCat) {
+        if (cat !== '')
+          uniqueMonomers.add(cat);
       }
     }
-    matrixDf.name = 'SAR';
 
-    return matrixDf;
-  }
+    const monomerCol = DG.Column.fromStrings(C.COLUMNS_NAMES.MONOMER, Array.from(uniqueMonomers));
+    const monomerPositionDf = DG.DataFrame.fromColumns([monomerCol]);
+    monomerPositionDf.name = 'SAR';
+    for (const col of splitSeqCols)
+      monomerPositionDf.columns.addNewBool(col.name);
 
-  buildMatrixDf(): DG.DataFrame {
-    const splitSeqDfColumns = this.splitSeqDf.columns;
-    const positionColumns = splitSeqDfColumns.names();
-    return this.splitSeqDf
-      .groupBy(positionColumns)
-      .aggregate()
-      .unpivot([], positionColumns, C.COLUMNS_NAMES.POSITION, C.COLUMNS_NAMES.MONOMER)
-      .groupBy([C.COLUMNS_NAMES.POSITION, C.COLUMNS_NAMES.MONOMER])
-      .aggregate();
+    return monomerPositionDf;
   }
 
   buildSplitSeqDf(): DG.DataFrame {
@@ -462,19 +440,35 @@ export class PeptidesModel {
     acc.addTitle(ui.h1(`${filterAndSelectionBs.trueCount} selected rows${filteredTitlePart}`));
     if (filterAndSelectionBs.anyTrue) {
       acc.addPane('Actions', () => {
-        const newViewButton = ui.button('New view', () => trueModel.createNewView(),
-          'Creates a new view from current selection');
-        const newCluster = ui.button('New cluster', () => trueModel._newClusterSubject.next(),
-          'Creates a new cluster from selection');
-        const removeCluster = ui.button('Remove cluster', () => trueModel._removeClusterSubject.next(),
-          'Removes currently selected custom cluster');
-        removeCluster.disabled = trueModel.clusterSelection.length === 0 ||
-          !wu(this.customClusters).some((c) => trueModel.clusterSelection.includes(c.name));
-        return ui.divV([newViewButton, newCluster, removeCluster]);
+        const newView = ui.label('New view');
+        $(newView).addClass('d4-link-action');
+        newView.onclick = () => trueModel.createNewView();
+        newView.onmouseover = (ev) => ui.tooltip.show('Creates a new view from current selection', ev.clientX + 5, ev.clientY + 5);
+        const newCluster = ui.label('New cluster');
+        $(newCluster).addClass('d4-link-action');
+        newCluster.onclick = () => {
+          const lstViewer = trueModel.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+          if (lstViewer === null)
+            throw new Error('Logo summary table viewer is not found');
+          lstViewer.clusterFromSelection();
+        };
+        newCluster.onmouseover = (ev) => ui.tooltip.show('Creates a new cluster from selection', ev.clientX + 5, ev.clientY + 5);
+        const removeCluster = ui.label('Remove cluster');
+        $(removeCluster).addClass('d4-link-action');
+        removeCluster.onclick = () => {
+          const lstViewer = trueModel.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+          if (lstViewer === null)
+            throw new Error('Logo summary table viewer is not found');
+          lstViewer.removeCluster();
+        };
+        removeCluster.onmouseover = (ev) => ui.tooltip.show('Removes currently selected custom cluster', ev.clientX + 5, ev.clientY + 5);
+        removeCluster.style.visibility = trueModel.clusterSelection.length === 0 ||
+          !wu(this.customClusters).some((c) => trueModel.clusterSelection.includes(c.name)) ? 'hidden' : 'visible';
+        return ui.divV([newView, newCluster, removeCluster]);
       });
     }
     const table = trueModel.df.filter.anyFalse ? trueModel.df.clone(trueModel.df.filter, null, true) : trueModel.df;
-    acc.addPane('Mutation Cliff pairs', () => mutationCliffsWidget(trueModel.df, trueModel).root);
+    acc.addPane('Mutation Cliffs pairs', () => mutationCliffsWidget(trueModel.df, trueModel).root);
     acc.addPane('Distribution', () => getDistributionWidget(table, trueModel).root);
 
     return acc;
@@ -483,12 +477,10 @@ export class PeptidesModel {
   updateGrid(): void {
     this.joinDataFrames();
 
-    this.sortSourceGrid();
-
     this.createScaledCol();
 
-    this.initMonomerPositionFilter({notify: false});
-    this.initMonomerPositionSelection({notify: false});
+    this.initInvariantMapSelection({notify: false});
+    this.initMutationCliffsSelection({notify: false});
 
     this.setWebLogoInteraction();
     this.webLogoBounds = {};
@@ -499,14 +491,14 @@ export class PeptidesModel {
 
     this.setBitsetCallback();
 
-    this.postProcessGrids();
+    this.setGridProperties();
   }
 
-  initMonomerPositionFilter(options: {cleanInit?: boolean, notify?: boolean} = {}): void {
+  initInvariantMapSelection(options: {cleanInit?: boolean, notify?: boolean} = {}): void {
     options.cleanInit ??= false;
     options.notify ??= true;
 
-    const tempFilter: type.PositionToAARList = this.monomerPositionFilter;
+    const tempFilter: type.PositionToAARList = this.invariantMapSelection;
     const positionColumns = this.splitSeqDf.columns.names();
     for (const pos of positionColumns) {
       if (options.cleanInit || !tempFilter.hasOwnProperty(pos))
@@ -514,16 +506,16 @@ export class PeptidesModel {
     }
 
     if (options.notify)
-      this.monomerPositionFilter = tempFilter;
+      this.invariantMapSelection = tempFilter;
     else
-      this._monomerPositionFilter = tempFilter;
+      this._invariantMapSelection = tempFilter;
   }
 
-  initMonomerPositionSelection(options: {cleanInit?: boolean, notify?: boolean} = {}): void {
+  initMutationCliffsSelection(options: {cleanInit?: boolean, notify?: boolean} = {}): void {
     options.cleanInit ??= false;
     options.notify ??= true;
 
-    const tempSelection: type.PositionToAARList = this.monomerPositionSelection;
+    const tempSelection: type.PositionToAARList = this.mutationCliffsSelection;
     const positionColumns = this.splitSeqDf.columns.names();
     for (const pos of positionColumns) {
       if (options.cleanInit || !tempSelection.hasOwnProperty(pos))
@@ -531,9 +523,9 @@ export class PeptidesModel {
     }
 
     if (options.notify)
-      this.monomerPositionSelection = tempSelection;
+      this.mutationCliffsSelection = tempSelection;
     else
-      this._monomerPositionSelection = tempSelection;
+      this._mutationCliffsSelection = tempSelection;
   }
 
   joinDataFrames(): void {
@@ -542,39 +534,19 @@ export class PeptidesModel {
     const cols = this.df.columns;
     const positionColumns = this.splitSeqDf.columns.names();
     for (const colName of positionColumns) {
-      const col = this.df.col(colName);
+      let col = this.df.col(colName);
       const newCol = this.splitSeqDf.getCol(colName);
-      if (col === null)
-        cols.add(newCol);
-      else {
+      if (col !== null)
         cols.remove(colName);
-        cols.add(newCol);
-      }
-      CR.setAARRenderer(newCol, this.alphabet);
+
+      const newColCat = newCol.categories;
+      const newColData = newCol.getRawData();
+      col = cols.addNew(newCol.name, newCol.type).init((i) => newColCat[newColData[i]]);
+      CR.setAARRenderer(col, this.alphabet);
     }
     this.df.name = name;
   }
 
-  sortSourceGrid(): void {
-    const colNames: DG.GridColumn[] = [];
-    const sourceGridCols = this.analysisView.grid.columns;
-    const sourceGridColsCount = sourceGridCols.length;
-    for (let i = 1; i < sourceGridColsCount; i++)
-      colNames.push(sourceGridCols.byIndex(i)!);
-
-    colNames.sort((a, b) => {
-      if (a.column!.semType === C.SEM_TYPES.MONOMER) {
-        if (b.column!.semType === C.SEM_TYPES.MONOMER)
-          return 0;
-        return -1;
-      }
-      if (b.column!.semType === C.SEM_TYPES.MONOMER)
-        return 1;
-      return 0;
-    });
-    sourceGridCols.setOrder(colNames.map((v) => v.name));
-  }
-
   createScaledCol(): void {
     const sourceGrid = this.analysisView.grid;
     const scaledCol = scaleActivity(this.df.getCol(this.settings.activityColumnName!), this.settings.scaling);
@@ -586,9 +558,9 @@ export class PeptidesModel {
 
   calculateMonomerPositionStatistics(): MonomerPositionStats {
     const positionColumns = this.splitSeqDf.columns.toList();
+    const sourceDfLen = this.df.rowCount;
     const monomerPositionObject = {general: {}} as MonomerPositionStats & { general: SummaryStats };
     const activityColData = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED).getRawData();
-    const sourceDfLen = activityColData.length;
 
     for (const posCol of positionColumns) {
       const posColData = posCol.getRawData();
@@ -600,7 +572,12 @@ export class PeptidesModel {
         if (monomer === '')
           continue;
 
-        const bitArray = BitArray.fromSeq(sourceDfLen, (i: number) => posColData[i] === categoryIndex);
+        const boolArray: boolean[] = new Array(sourceDfLen).fill(false);
+        for (let i = 0; i < sourceDfLen; ++i) {
+          if (posColData[i] === categoryIndex)
+            boolArray[i] = true;
+        }
+        const bitArray = BitArray.fromValues(boolArray);
         const stats = getStats(activityColData, bitArray);
         currentPositionObject[monomer] = stats;
         this.getSummaryStats(currentPositionObject.general, stats);
@@ -658,12 +635,11 @@ export class PeptidesModel {
 
   calculateClusterStatistics(): ClusterTypeStats {
     const rowCount = this.df.rowCount;
-
     const origClustCol = this.df.getCol(this.settings.clustersColumnName!);
     const origClustColData = origClustCol.getRawData();
     const origClustColCat = origClustCol.categories;
     const origClustMasks: BitArray[] = Array.from({length: origClustColCat.length},
-      () => BitArray.fromSeq(rowCount, (_: number) => false));
+      () => new BitArray(rowCount, false));
     for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx)
       origClustMasks[origClustColData[rowIdx]].setTrue(rowIdx);
 
@@ -793,9 +769,9 @@ export class PeptidesModel {
     const position = barPart.position;
     if (ev.type === 'click') {
       if (!ev.shiftKey)
-        this.initMonomerPositionSelection({cleanInit: true, notify: false});
+        this.initInvariantMapSelection({cleanInit: true, notify: false});
 
-      this.modifyMonomerPositionSelection(monomer, position, false);
+      this.modifyMonomerPositionSelection(monomer, position, true);
     } else {
       const bar = `${position} = ${monomer}`;
       if (this.cachedWebLogoTooltip.bar === bar)
@@ -811,7 +787,7 @@ export class PeptidesModel {
   setCellRenderers(): void {
     const sourceGrid = this.analysisView.grid;
     sourceGrid.setOptions({'colHeaderHeight': 130});
-    sourceGrid.onCellRender.subscribe((gcArgs) => {
+    const headerRenderer = (gcArgs: DG.GridCellRenderArgs): void => {
       const ctx = gcArgs.g;
       const bounds = gcArgs.bounds;
       const col = gcArgs.cell.tableColumn;
@@ -834,8 +810,8 @@ export class PeptidesModel {
             return 0;
           }).filter((v) => v !== 'general');
 
-          this.webLogoBounds[col.name] = CR.drawLogoInBounds(ctx, bounds, stats, sortedStatsOrder, this.df.rowCount,
-            this.cp, this.headerSelectedMonomers[col.name]);
+          this.webLogoBounds[col.name] = CR.drawLogoInBounds(ctx, bounds, stats, col.name, sortedStatsOrder,
+            this.df.rowCount, this.cp, this.headerSelectedMonomers[col.name]);
           gcArgs.preventDefault();
         }
       } catch (e) {
@@ -845,15 +821,28 @@ export class PeptidesModel {
       } finally {
         ctx.restore();
       }
-    });
+    };
+    sourceGrid.onCellRender.subscribe((gcArgs) => headerRenderer(gcArgs));
+
+    if (!this._layoutEventInitialized) {
+      grok.events.onViewLayoutApplied.subscribe((layout) => {
+        if (layout.view.id === this.analysisView.id) {
+          // this.analysisView.grid.onCellRender.subscribe((gcArgs) => headerRenderer(gcArgs));
+          this.updateGrid();
+        }
+      });
+      this._layoutEventInitialized = true;
+    }
   }
 
   setTooltips(): void {
     this.analysisView.grid.onCellTooltip((cell, x, y) => {
-      const col = cell.tableColumn;
-      const cellValue = cell.cell.value;
-      if (cellValue && col && col.semType === C.SEM_TYPES.MONOMER)
-        this.showMonomerTooltip(cellValue, x, y);
+      if (cell.isColHeader && cell.tableColumn!.semType === C.SEM_TYPES.MONOMER)
+        return true;
+      if (!(cell.isTableCell && cell.tableColumn!.semType === C.SEM_TYPES.MONOMER))
+        return false;
+
+      this.showMonomerTooltip(cell.cell.value, x, y);
       return true;
     });
   }
@@ -863,18 +852,21 @@ export class PeptidesModel {
     const monomerName = aar.toLowerCase();
 
     const mw = getMonomerWorksInstance();
-    const mol = mw.getCappedRotatedMonomer('PEPTIDE', aar);
+    const mol = mw?.getCappedRotatedMonomer('PEPTIDE', aar);
 
     if (mol) {
       tooltipElements.push(ui.div(monomerName));
       const options = {autoCrop: true, autoCropMargin: 0, suppressChiralText: true};
       tooltipElements.push(grok.chem.svgMol(mol, undefined, undefined, options));
-    } else
+    } else if (aar !== '')
       tooltipElements.push(ui.div(aar));
+    else
+      return true;
+
 
     ui.tooltip.show(ui.divV(tooltipElements), x, y);
 
-    return mol !== null;
+    return true;
   }
 
   //TODO: move out to viewer code
@@ -893,12 +885,12 @@ export class PeptidesModel {
     const distributionTable = DG.DataFrame.fromColumns(
       [activityCol, DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask)]);
     const labels = getDistributionLegend(`${position} : ${aar}`, 'Other');
-    const hist = getActivityDistribution(distributionTable, true);
-    const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
-    const aggregatedColMap = this.getAggregatedColumnValues({mask: mask, fractionDigits: 2});
+    const hist = getActivityDistribution(prepareTableForHistogram(distributionTable), true);
+    const tableMap = getStatsTableMap(stats);
+    const aggregatedColMap = this.getAggregatedColumnValues({mask: mask});
 
     const resultMap = {...tableMap, ...aggregatedColMap};
-    const distroStatsElem = getStatsSummary(labels, hist, resultMap, true);
+    const distroStatsElem = getStatsSummary(labels, hist, resultMap);
 
     ui.tooltip.show(distroStatsElem, x, y);
 
@@ -908,6 +900,7 @@ export class PeptidesModel {
   getAggregatedColumnValues(options: {filterDf?: boolean, mask?: DG.BitSet, fractionDigits?: number} = {},
   ): StringDictionary {
     options.filterDf ??= false;
+    options.fractionDigits ??= 3;
 
     const filteredDf = options.filterDf && this.df.filter.anyFalse ? this.df.clone(this.df.filter) : this.df;
 
@@ -920,8 +913,11 @@ export class PeptidesModel {
     return colResults;
   }
 
-  modifyMonomerPositionSelection(aar: string, position: string, isFilter: boolean): void {
-    const tempSelection = isFilter ? this.monomerPositionFilter : this.monomerPositionSelection;
+  modifyMonomerPositionSelection(aar: string, position: string, isInvariantMap: boolean): void {
+    if (this.df.getCol(position).categories.indexOf(aar) === -1)
+      return;
+
+    const tempSelection = isInvariantMap ? this.invariantMapSelection : this.mutationCliffsSelection;
     const tempSelectionAt = tempSelection[position];
     const aarIndex = tempSelectionAt.indexOf(aar);
     if (aarIndex === -1)
@@ -929,10 +925,10 @@ export class PeptidesModel {
     else
       tempSelectionAt.splice(aarIndex, 1);
 
-    if (isFilter)
-      this.monomerPositionFilter = tempSelection;
+    if (isInvariantMap)
+      this.invariantMapSelection = tempSelection;
     else
-      this.monomerPositionSelection = tempSelection;
+      this.mutationCliffsSelection = tempSelection;
   }
 
   setBitsetCallback(): void {
@@ -942,14 +938,45 @@ export class PeptidesModel {
     const filter = this.df.filter;
     const clusterCol = this.df.col(this.settings.clustersColumnName!);
 
-    const changeSelectionBitset = (currentBitset: DG.BitSet, posList: type.RawColumn[], clustColCat: string[],
+    const changeSelectionBitset = (currentBitset: DG.BitSet, clustColCat: string[],
       clustColData: type.RawData, customClust: {[key: string]: BitArray}): void => {
-      const getBitAt = (i: number): boolean => {
-        for (const posRawCol of posList) {
-          if (this.monomerPositionSelection[posRawCol.name].includes(posRawCol.cat![posRawCol.rawData[i]]))
-            return true;
+      const indexes = new Set<number>();
+      for (const [position, monomerList] of Object.entries(this.mutationCliffsSelection)) {
+        for (const monomer of monomerList) {
+          const substitutions = this.mutationCliffs?.get(monomer)?.get(position) ?? null;
+          if (substitutions === null)
+            continue;
+          for (const [key, value] of substitutions.entries()) {
+            indexes.add(key);
+            for (const v of value)
+              indexes.add(v);
+          }
+        }
+      }
+
+      const positionList = Object.keys(this.invariantMapSelection);
+      const rowCount = this.df.rowCount;
+      for (const position of positionList) {
+        const positionCol: DG.Column<string> = this.df.getCol(position);
+        const positionColData = positionCol.getRawData();
+        const positionColCat = positionCol.categories;
+        const aarList = this.invariantMapSelection[position];
+        for (const aar of aarList) {
+          const aarIndex = positionColCat.indexOf(aar);
+          if (aarIndex === -1)
+            continue;
+          for (let i = 0; i < rowCount; ++i) {
+            if (positionColData[i] === aarIndex)
+              indexes.add(i);
+          }
         }
+      }
 
+      const getBitAt = (i: number): boolean => {
+        if (indexes.has(i))
+          return true;
+
+        //TODO: preprocess
         const currentOrigClust = clustColCat[clustColData[i]];
         if (typeof currentOrigClust === undefined)
           return false;
@@ -971,11 +998,6 @@ export class PeptidesModel {
       if (this.isUserChangedSelection)
         return;
 
-      const positionList: type.RawColumn[] = Object.keys(this.monomerPositionSelection).map((pos) => {
-        const posCol = this.df.getCol(pos);
-        return {name: pos, cat: posCol.categories, rawData: posCol.getRawData()};
-      });
-
       const clustColCat = clusterCol?.categories ?? [];
       const clustColData = clusterCol?.getRawData() ?? new Int32Array(0);
       const customClust: {[key: string]: BitArray} = {};
@@ -983,29 +1005,15 @@ export class PeptidesModel {
       for (const clust of this.customClusters)
         customClust[clust.name] = BitArray.fromUint32Array(rowCount, clust.getRawData() as Uint32Array);
 
-      changeSelectionBitset(selection, positionList, clustColCat, clustColData, customClust);
+      changeSelectionBitset(selection, clustColCat, clustColData, customClust);
     });
 
     filter.onChanged.subscribe(() => {
-      const positionList = Object.keys(this.monomerPositionFilter);
-      const invariantMapBitset = DG.BitSet.create(filter.length, (index) => {
-        let result = true;
-        for (const position of positionList) {
-          const aarList = this.monomerPositionFilter[position];
-          result &&= aarList.length === 0 || aarList.includes(this.df.get(position, index));
-          if (!result)
-            return result;
-        }
-        return result;
-      });
-
-      if (!this.isInvariantMapTrigger)
-        this.initBitset = filter.clone();
-
-      const temp = invariantMapBitset.and(this.initBitset);
-      filter.init((i) => temp.get(i), false);
-
-      this._filterChangedSubject.next();
+      const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+      if (lstViewer !== null && typeof lstViewer.model !== 'undefined') {
+        lstViewer.createLogoSummaryTableGrid();
+        lstViewer.render();
+      }
     });
     this.isBitsetChangedInitialized = true;
   }
@@ -1027,23 +1035,13 @@ export class PeptidesModel {
     this.isUserChangedSelection = true;
   }
 
-  postProcessGrids(): void {
-    const posCols = this.splitSeqDf.columns.names();
+  setGridProperties(props?: DG.IGridLookSettings): void {
     const sourceGrid = this.analysisView.grid;
-    const sourceGridCols = sourceGrid.columns;
-    const sourceGridColsLen = sourceGridCols.length;
-    const visibleColumns = Object.keys(this.settings.columns || {});
     const sourceGridProps = sourceGrid.props;
-    sourceGridProps.allowColSelection = false;
-    sourceGridProps.allowEdit = false;
-    sourceGridProps.showCurrentRowIndicator = false;
+    sourceGridProps.allowColSelection = props?.allowColSelection ?? false;
+    sourceGridProps.allowEdit = props?.allowEdit ?? false;
+    sourceGridProps.showCurrentRowIndicator = props?.showCurrentRowIndicator ?? false;
     this.df.temp[C.EMBEDDING_STATUS] = false;
-    for (let colIdx = 1; colIdx < sourceGridColsLen; ++colIdx) {
-      const gridCol = sourceGridCols.byIndex(colIdx)!;
-      const tableColName = gridCol.column!.name;
-      gridCol.visible = posCols.includes(tableColName) || (tableColName === C.COLUMNS_NAMES.ACTIVITY_SCALED) ||
-        visibleColumns.includes(tableColName);
-    }
   }
 
   closeViewer(viewerType: VIEWER_TYPE): void {
@@ -1066,10 +1064,11 @@ export class PeptidesModel {
       const pepColValues: string[] = this.df.getCol(this.settings.sequenceColumnName!).toList();
       this._dm ??= new DistanceMatrix(await createDistanceMatrixWorker(pepColValues, StringMetricsNames.Levenshtein));
       const leafCol = this.df.col('~leaf-id') ?? this.df.columns.addNewString('~leaf-id').init((i) => i.toString());
-      const treeNode = await this.treeHelper.hierarchicalClusteringByDistance(this._dm, 'ward');
+      const treeHelper: ITreeHelper = getTreeHelperInstance()!;
+      const treeNode = await treeHelper.hierarchicalClusteringByDistance(this._dm, 'ward');
 
-      this.df.setTag(treeTAGS.NEWICK, this.treeHelper.toNewick(treeNode));
-      const leafOrdering = this.treeHelper.getLeafList(treeNode).map((leaf) => parseInt(leaf.name));
+      this.df.setTag(treeTAGS.NEWICK, treeHelper.toNewick(treeNode));
+      const leafOrdering = treeHelper.getLeafList(treeNode).map((leaf) => parseInt(leaf.name));
       this.analysisView.grid.setRowOrder(leafOrdering);
       const dendrogramViewer = await this.df.plot.fromType('Dendrogram', {nodeColumnName: leafCol.name}) as DG.JsViewer;
 
@@ -1105,18 +1104,88 @@ export class PeptidesModel {
       const settingsButton = ui.iconFA('wrench', () => getSettingsDialog(this), 'Peptides analysis settings');
       this.analysisView.setRibbonPanels([[settingsButton]], false);
       this.isRibbonSet = true;
-      grok.events.onResetFilterRequest.subscribe(() => {
-        this.isInvariantMapTrigger = true;
-        this.initMonomerPositionFilter({cleanInit: true});
-        this.isInvariantMapTrigger = false;
-      });
+      this.updateGrid();
+    }
+
+    if (!this.isToolboxSet && this.df.getTag(C.TAGS.MULTIPLE_VIEWS) !== '1') {
+      let template: ISeqSplitted;
+      const sequencesCol = this.df.getCol(this.settings.sequenceColumnName!);
+      const minTemplateLength = this.splitSeqDf.columns.toList()
+        .filter((col) => col.stats.missingValueCount === 0).length;
+      const calculateIdentityBtn = ui.button('Identity', async () => {
+        let identityScoresCol = calculateIdentity(template, this.splitSeqDf);
+        identityScoresCol.name = this.df.columns.getUnusedName(identityScoresCol.name);
+        identityScoresCol = this.df.columns.add(identityScoresCol);
+        identityScoresCol.setTag(C.TAGS.IDENTITY_TEMPLATE, new Array(template).join(' '));
+      }, 'Calculate identity');
+      const calculateSimilarityBtn = ui.button('Similarity', async () => {
+        let similarityScoresCol = await calculateSimilarity(template, this.splitSeqDf);
+        similarityScoresCol.name = this.df.columns.getUnusedName(similarityScoresCol.name);
+        similarityScoresCol = this.df.columns.add(similarityScoresCol);
+        similarityScoresCol.setTag(C.TAGS.SIMILARITY_TEMPLATE, new Array(template).join(' '));
+      }, 'Calculate similarity');
+      const templateInput = ui.stringInput('Template', this.identityTemplate, async () => {
+        this.identityTemplate = templateInput.value;
+        if (isNaN(parseInt(templateInput.value))) {
+          if (templateInput.value.length === 0) {
+            calculateIdentityBtn.disabled = true;
+            calculateSimilarityBtn.disabled = true;
+            return;
+          }
+          try {
+            template ??= await getTemplate(this.identityTemplate, sequencesCol);
+            if (template.length < minTemplateLength) {
+              grok.shell.warning(`Template length should be at least ${minTemplateLength} amino acids.`);
+              calculateIdentityBtn.disabled = true;
+              calculateSimilarityBtn.disabled = true;
+              return;
+            } else if (new Array(template).includes('') || new Array(template).includes('-')) {
+              grok.shell.warning('Template shouldn\'t contain gaps or empty cells.');
+              calculateIdentityBtn.disabled = true;
+              calculateSimilarityBtn.disabled = true;
+              return;
+            }
+          } catch (e) {
+            grok.shell.warning(`Only ${sequencesCol.getTag(DG.TAGS.UNITS)} sequence format is supported.`);
+            grok.log.warning(e as string);
+            calculateIdentityBtn.disabled = true;
+            return;
+          }
+        } else {
+          const rowIndex = parseInt(templateInput.value) - 1;
+          const selectedIndexes = this.df.filter.getSelectedIndexes();
+          if (rowIndex < 0 || rowIndex >= selectedIndexes.length) {
+            grok.shell.warning('Invalid row index');
+            calculateIdentityBtn.disabled = true;
+            calculateSimilarityBtn.disabled = true;
+            return;
+          }
+          this.identityTemplate = sequencesCol.get(selectedIndexes[rowIndex]);
+        }
+        try {
+          template = await getTemplate(this.identityTemplate, sequencesCol);
+        } catch (e) {
+          grok.shell.warning('Couldn\'t recognize sequence format.');
+          grok.log.warning(e as string);
+          calculateIdentityBtn.disabled = true;
+          calculateSimilarityBtn.disabled = true;
+          return;
+        }
+        calculateIdentityBtn.disabled = false;
+        calculateSimilarityBtn.disabled = false;
+      }, {placeholder: 'Sequence or row index...'});
+      templateInput.setTooltip('Template sequence. Can be row index, peptide ID or sequence.');
+      templateInput.fireChanged();
+      const acc = this.analysisView.toolboxPage.accordion;
+      acc.addPane('Sequence Identity and Similarity',
+        () => ui.divV([ui.form([templateInput]), calculateIdentityBtn, calculateSimilarityBtn]), true, acc.panes[0]);
+      this.isToolboxSet = true;
     }
 
-    this.updateGrid();
     this.fireBitsetChanged(true);
-    this.analysisView.grid.invalidate();
     if (typeof this.settings.targetColumnName === 'undefined')
       this.updateMutationCliffs();
+    this.analysisView.grid.invalidate();
   }
 
   findViewer(viewerType: VIEWER_TYPE): DG.Viewer | null {
@@ -1132,11 +1201,12 @@ export class PeptidesModel {
       await this.addMonomerPosition();
     if (this.settings.showMostPotentResidues)
       await this.addMostPotentResidues();
+    logoSummaryTable.viewerGrid.invalidate();
   }
 
   async addMonomerPosition(): Promise<void> {
     const monomerPosition = await this.df.plot.fromType(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition;
-    const mostPotentResidues = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResiduesViewer | null;
+    const mostPotentResidues = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues | null;
     const dm = this.analysisView.dockManager;
     const [dockType, refNode, ratio] = mostPotentResidues === null ? [DG.DOCK_TYPE.DOWN, null, undefined] :
       [DG.DOCK_TYPE.LEFT, this.findViewerNode(VIEWER_TYPE.MOST_POTENT_RESIDUES), 0.7];
@@ -1151,7 +1221,7 @@ export class PeptidesModel {
 
   async addMostPotentResidues(): Promise<void> {
     const mostPotentResidues =
-      await this.df.plot.fromType(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResiduesViewer;
+      await this.df.plot.fromType(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues;
     const monomerPosition = this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
     const dm = this.analysisView.dockManager;
     const [dockType, refNode, ratio] = monomerPosition === null ? [DG.DOCK_TYPE.DOWN, null, undefined] :