@datagrok/peptides 1.7.2 → 1.8.1

package/src/model.ts

@@ -2,27 +2,36 @@ import * as ui from 'datagrok-api/ui';
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
+import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
+import {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
+import {pickUpPalette, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
+import {DistanceMatrix} from '@datagrok-libraries/bio/src/trees/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 wu from 'wu';
 import * as rxjs from 'rxjs';
 import * as uuid from 'uuid';
 
 import * as C from './utils/constants';
 import * as type from './utils/types';
-import {calculateSelected, extractMonomerInfo, scaleActivity, wrapDistroAndStatsDefault} from './utils/misc';
+import {calculateSelected, extractMonomerInfo, scaleActivity, getStatsSummary} from './utils/misc';
 import {MonomerPosition, MostPotentResiduesViewer} from './viewers/sar-viewer';
 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';
-import {LogoSummary} from './viewers/logo-summary';
+import {getActivityDistribution, getDistributionLegend, getDistributionWidget, getStatsTableMap,
+} from './widgets/distribution';
+import {getAggregatedValue, getStats, Stats} from './utils/statistics';
+import {LogoSummaryTable} from './viewers/logo-summary';
 import {getSettingsDialog} from './widgets/settings';
-import {getMonomerWorks} from './package';
+import {_package, getMonomerWorksInstance, getTreeHelperInstance} from './package';
 import {findMutations} from './utils/algorithms';
-import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
-import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
-import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
-import {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
-import {pickUpPalette, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {createDistanceMatrixWorker} from './utils/worker-creator';
+import BitArray from '@datagrok-libraries/utils/src/bit-array';
 
 export type SummaryStats = {
   minCount: number, maxCount: number,
@@ -32,35 +41,47 @@ export type SummaryStats = {
 };
 export type PositionStats = { [monomer: string]: Stats } & { general: SummaryStats };
 export type MonomerPositionStats = { [position: string]: PositionStats } & { general: SummaryStats };
+export type ClusterStats = {[cluster: string]: Stats};
+export enum CLUSTER_TYPE {
+  ORIGINAL = 'original',
+  CUSTOM = 'custom',
+};
+export type ClusterType = `${CLUSTER_TYPE}`;
+export type ClusterTypeStats = {[clusterType in ClusterType]: ClusterStats};
+export enum VIEWER_TYPE {
+  MONOMER_POSITION = 'Monomer-Position',
+  MOST_POTENT_RESIDUES = 'Most Potent Residues',
+  LOGO_SUMMARY_TABLE = 'Logo Summary Table',
+  DENDROGRAM = 'Dendrogram',
+};
+
+export const getAggregatedColName = (aggF: string, colName: string): string => `${aggF}(${colName})`;
 
 export class PeptidesModel {
   static modelName = 'peptidesModel';
 
-  settingsSubject: rxjs.Subject<type.PeptidesSettings> = new rxjs.Subject();
-  _mutatinCliffsSelectionSubject: 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();
+  _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;
+  isUserChangedSelection = true;
 
   df: DG.DataFrame;
   splitCol!: DG.Column<boolean>;
-  edf: DG.DataFrame | null = null;
   _monomerPositionStats?: MonomerPositionStats;
-  _clusterStats?: {[cluster: string]: Stats};
-  _mutationCliffsSelection!: type.PositionToAARList;
-  _invariantMapSelection!: type.PositionToAARList;
-  _logoSummarySelection!: string[];
-  _substitutionsInfo?: type.SubstitutionsInfo;
+  _clusterStats?: ClusterTypeStats;
+  _monomerPositionSelection!: type.PositionToAARList;
+  _monomerPositionFilter!: type.PositionToAARList;
+  _clusterSelection!: string[];
+  _mutationCliffs?: type.MutationCliffs;
   isInitialized = false;
   _analysisView?: DG.TableView;
 
-  isPeptideSpaceChangingBitset = false;
-  isChangingEdfBitset = false;
-
   monomerMap: { [key: string]: { molfile: string, fullName: string } } = {};
   monomerLib: IMonomerLib | null = null; // To get monomers from lib(s)
   monomerWorks: MonomerWorks | null = null; // To get processed monomers
@@ -79,6 +100,9 @@ export class PeptidesModel {
   _mostPotentResiduesDf?: DG.DataFrame;
   _matrixDf?: DG.DataFrame;
   _splitSeqDf?: DG.DataFrame;
+  _distanceMatrix!: DistanceMatrix;
+  _treeHelper!: ITreeHelper;
+  _dm!: DistanceMatrix;
 
   private constructor(dataFrame: DG.DataFrame) {
     this.df = dataFrame;
@@ -91,6 +115,11 @@ export class PeptidesModel {
     return dataFrame.temp[PeptidesModel.modelName] as PeptidesModel;
   }
 
+  get treeHelper(): ITreeHelper {
+    this._treeHelper ??= getTreeHelperInstance();
+    return this._treeHelper;
+  }
+
   get monomerPositionDf(): DG.DataFrame {
     this._monomerPositionDf ??= this.createMonomerPositionDf();
     return this._monomerPositionDf;
@@ -141,27 +170,27 @@ export class PeptidesModel {
     return col.getTag(bioTAGS.alphabet);
   }
 
-  get substitutionsInfo(): type.SubstitutionsInfo {
-    if (this._substitutionsInfo)
-      return this._substitutionsInfo;
+  get mutationCliffs(): type.MutationCliffs {
+    if (this._mutationCliffs)
+      return this._mutationCliffs;
 
     const scaledActivityCol: DG.Column<number> = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
     //TODO: set categories ordering the same to share compare indexes instead of strings
     const monomerColumns: type.RawColumn[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER).map(extractMonomerInfo);
-    this._substitutionsInfo = findMutations(scaledActivityCol.getRawData(), monomerColumns, this.settings);
-    return this._substitutionsInfo;
+    this._mutationCliffs = findMutations(scaledActivityCol.getRawData(), monomerColumns, this.settings);
+    return this._mutationCliffs;
   }
 
-  set substitutionsInfo(si: type.SubstitutionsInfo) {
-    this._substitutionsInfo = si;
+  set mutationCliffs(si: type.MutationCliffs) {
+    this._mutationCliffs = si;
   }
 
-  get clusterStats(): {[cluster: string]: Stats} {
+  get clusterStats(): ClusterTypeStats {
     this._clusterStats ??= this.calculateClusterStatistics();
     return this._clusterStats;
   }
 
-  set clusterStats(clusterStats: {[cluster: string]: Stats}) {
+  set clusterStats(clusterStats: ClusterTypeStats) {
     this._clusterStats = clusterStats;
   }
 
@@ -184,12 +213,12 @@ export class PeptidesModel {
     return this._analysisView;
   }
 
-  get onMutationCliffsSelectionChanged(): rxjs.Observable<undefined> {
-    return this._mutatinCliffsSelectionSubject.asObservable();
+  get onMonomerPositionSelectionChanged(): rxjs.Observable<undefined> {
+    return this._monomerPositionSelectionSubject.asObservable();
   }
 
   get onSettingsChanged(): rxjs.Observable<type.PeptidesSettings> {
-    return this.settingsSubject.asObservable();
+    return this._settingsSubject.asObservable();
   }
 
   get onNewCluster(): rxjs.Observable<undefined> {
@@ -204,40 +233,40 @@ export class PeptidesModel {
     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 mutationCliffsSelection(selection: type.PositionToAARList) {
-    this._mutationCliffsSelection = selection;
+  set monomerPositionSelection(selection: type.PositionToAARList) {
+    this._monomerPositionSelection = selection;
     this.df.tags[C.TAGS.SELECTION] = JSON.stringify(selection);
     this.fireBitsetChanged();
-    this._mutatinCliffsSelectionSubject.next();
+    this._monomerPositionSelectionSubject.next();
     this.analysisView.grid.invalidate();
   }
 
-  get invariantMapSelection(): type.PositionToAARList {
-    this._invariantMapSelection ??= JSON.parse(this.df.tags[C.TAGS.FILTER] || '{}');
-    return this._invariantMapSelection;
+  get monomerPositionFilter(): type.PositionToAARList {
+    this._monomerPositionFilter ??= JSON.parse(this.df.tags[C.TAGS.FILTER] || '{}');
+    return this._monomerPositionFilter;
   }
 
-  set invariantMapSelection(selection: type.PositionToAARList) {
-    this._invariantMapSelection = selection;
+  set monomerPositionFilter(selection: type.PositionToAARList) {
+    this._monomerPositionFilter = selection;
     this.df.tags[C.TAGS.FILTER] = JSON.stringify(selection);
     this.isInvariantMapTrigger = true;
-    this.fireBitsetChanged(false, true);
+    this.fireBitsetChanged(true);
     this.isInvariantMapTrigger = false;
     this.analysisView.grid.invalidate();
   }
 
-  get logoSummarySelection(): string[] {
-    this._logoSummarySelection ??= JSON.parse(this.df.tags[C.TAGS.CLUSTER_SELECTION] || '[]');
-    return this._logoSummarySelection;
+  get clusterSelection(): string[] {
+    this._clusterSelection ??= JSON.parse(this.df.tags[C.TAGS.CLUSTER_SELECTION] || '[]');
+    return this._clusterSelection;
   }
 
-  set logoSummarySelection(selection: string[]) {
-    this._logoSummarySelection = selection;
+  set clusterSelection(selection: string[]) {
+    this._clusterSelection = selection;
     this.df.tags[C.TAGS.CLUSTER_SELECTION] = JSON.stringify(selection);
     this.fireBitsetChanged();
     this.analysisView.grid.invalidate();
@@ -263,24 +292,16 @@ export class PeptidesModel {
     this.df.tags['distributionSplit'] = `${splitByAARFlag}${flag ? 1 : 0}`;
   }
 
-  get isInvariantMap(): boolean {
-    return this.df.getTag('isInvariantMap') === '1';
-  }
-
-  set isInvariantMap(x: boolean) {
-    this.df.setTag('isInvariantMap', x ? '1' : '0');
-  }
-
-  get isMutationCliffSelectionEmpty(): boolean {
-    for (const aarList of Object.values(this.mutationCliffsSelection)) {
+  get isMonomerPositionSelectionEmpty(): boolean {
+    for (const aarList of Object.values(this.monomerPositionSelection)) {
       if (aarList.length !== 0)
         return false;
     }
     return true;
   }
 
-  get isLogoSummarySelectionEmpty(): boolean {
-    return this.logoSummarySelection.length === 0;
+  get isClusterSelectionEmpty(): boolean {
+    return this.clusterSelection.length === 0;
   }
 
   get customClusters(): Iterable<DG.Column<boolean>> {
@@ -290,7 +311,7 @@ export class PeptidesModel {
   }
 
   get settings(): type.PeptidesSettings {
-    this._settings ??= JSON.parse(this.df.getTag('settings') || '{}');
+    this._settings ??= JSON.parse(this.df.getTag('settings')!);
     return this._settings;
   }
 
@@ -305,17 +326,28 @@ export class PeptidesModel {
         updateVars.add('mutationCliffs');
         updateVars.add('stats');
         break;
-        // case 'columns':
-        //   updateVars.add('grid');
-        //   break;
+      case 'columns':
+        updateVars.add('grid');
+        break;
       case 'maxMutations':
       case 'minActivityDelta':
         updateVars.add('mutationCliffs');
         break;
+      case 'showDendrogram':
+        updateVars.add('dendrogram');
+        break;
+      case 'showLogoSummaryTable':
+        updateVars.add('logoSummaryTable');
+        break;
+      case 'showMonomerPosition':
+        updateVars.add('monomerPosition');
+        break;
+      case 'showMostPotentResidues':
+        updateVars.add('mostPotentResidues');
+        break;
       }
     }
     this.df.setTag('settings', JSON.stringify(this._settings));
-    // this.updateDefault();
     for (const variable of updateVars) {
       switch (variable) {
       case 'activity':
@@ -324,8 +356,8 @@ export class PeptidesModel {
       case 'mutationCliffs':
         const scaledActivityCol: DG.Column<number> = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
         //TODO: set categories ordering the same to share compare indexes instead of strings
-        const monomerColumns: type.RawColumn[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER).map(extractMonomerInfo);
-        this.substitutionsInfo = findMutations(scaledActivityCol.getRawData(), monomerColumns, this.settings);
+        const monomerCols: type.RawColumn[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER).map(extractMonomerInfo);
+        this.mutationCliffs = findMutations(scaledActivityCol.getRawData(), monomerCols, this.settings);
         break;
       case 'stats':
         this.monomerPositionStats = this.calculateMonomerPositionStatistics();
@@ -334,22 +366,34 @@ export class PeptidesModel {
         this.clusterStats = this.calculateClusterStatistics();
         break;
       case 'grid':
-        this.updateGrid();
+        this.postProcessGrids();
+        break;
+      case 'dendrogram':
+        this.settings.showDendrogram ? this.addDendrogram() : this.closeViewer(VIEWER_TYPE.DENDROGRAM);
+        break;
+      case 'logoSummaryTable':
+        this.settings.showLogoSummaryTable ? this.addLogoSummaryTable() :
+          this.closeViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE);
+        break;
+      case 'monomerPosition':
+        this.settings.showMonomerPosition ? this.addMonomerPosition() :
+          this.closeViewer(VIEWER_TYPE.MONOMER_POSITION);
+        break;
+      case 'mostPotentResidues':
+        this.settings.showMostPotentResidues ? this.addMostPotentResidues() :
+          this.closeViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES);
         break;
       }
     }
 
     //TODO: handle settings change
-    this.settingsSubject.next(this.settings);
+    this._settingsSubject.next(this.settings);
   }
 
   createMonomerPositionDf(): DG.DataFrame {
     const positions = this.splitSeqDf.columns.names();
     const matrixDf = this.matrixDf
       .groupBy([C.COLUMNS_NAMES.MONOMER])
-      // .pivot(C.COLUMNS_NAMES.POSITION)
-      // .add('values')
-      // .add('first', C.COLUMNS_NAMES.MEAN_DIFFERENCE, '')
       .aggregate();
     for (const pos of positions)
       matrixDf.columns.addNewString(pos);
@@ -384,7 +428,7 @@ export class PeptidesModel {
     return splitSeqDf;
   }
 
-  getCompoundBitest(): DG.BitSet {
+  getCompoundBitset(): DG.BitSet {
     return this.df.selection.clone().and(this.df.filter);
   }
 
@@ -395,17 +439,19 @@ export class PeptidesModel {
 
     const acc = ui.accordion();
     acc.root.style.width = '100%';
-    const filterAndSelectionBs = trueModel.getCompoundBitest();
+    const filterAndSelectionBs = trueModel.getCompoundBitset();
     const filteredTitlePart = trueModel.df.filter.anyFalse ? ` among ${trueModel.df.filter.trueCount} filtered` : '';
     acc.addTitle(ui.h1(`${filterAndSelectionBs.trueCount} selected rows${filteredTitlePart}`));
     if (filterAndSelectionBs.anyTrue) {
       acc.addPane('Actions', () => {
-        const newViewButton = ui.button('New view', async () => await trueModel.createNewView(),
+        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]);
       });
     }
@@ -423,7 +469,8 @@ export class PeptidesModel {
 
     this.createScaledCol();
 
-    this.initSelections();
+    this.initMonomerPositionFilter({notify: false});
+    this.initMonomerPositionSelection({notify: false});
 
     this.setWebLogoInteraction();
     this.webLogoBounds = {};
@@ -437,16 +484,38 @@ export class PeptidesModel {
     this.postProcessGrids();
   }
 
-  initSelections(): void {
-    const tempInvariantMapSelection: type.PositionToAARList = this.invariantMapSelection;
-    const mutationCliffsSelection: type.PositionToAARList = this.mutationCliffsSelection;
+  initMonomerPositionFilter(options: {cleanInit?: boolean, notify?: boolean} = {}): void {
+    options.cleanInit ??= false;
+    options.notify ??= true;
+
+    const tempFilter: type.PositionToAARList = this.monomerPositionFilter;
     const positionColumns = this.splitSeqDf.columns.names();
     for (const pos of positionColumns) {
-      tempInvariantMapSelection[pos] ??= [];
-      mutationCliffsSelection[pos] ??= [];
+      if (options.cleanInit || !tempFilter.hasOwnProperty(pos))
+        tempFilter[pos] = [];
     }
-    this.invariantMapSelection = tempInvariantMapSelection;
-    this.mutationCliffsSelection = mutationCliffsSelection;
+
+    if (options.notify)
+      this.monomerPositionFilter = tempFilter;
+    else
+      this._monomerPositionFilter = tempFilter;
+  }
+
+  initMonomerPositionSelection(options: {cleanInit?: boolean, notify?: boolean} = {}): void {
+    options.cleanInit ??= false;
+    options.notify ??= true;
+
+    const tempSelection: type.PositionToAARList = this.monomerPositionSelection;
+    const positionColumns = this.splitSeqDf.columns.names();
+    for (const pos of positionColumns) {
+      if (options.cleanInit || !tempSelection.hasOwnProperty(pos))
+        tempSelection[pos] = [];
+    }
+
+    if (options.notify)
+      this.monomerPositionSelection = tempSelection;
+    else
+      this._monomerPositionSelection = tempSelection;
   }
 
   joinDataFrames(): void {
@@ -505,31 +574,17 @@ export class PeptidesModel {
 
     for (const posCol of positionColumns) {
       const posColData = posCol.getRawData();
-      const currentMonomerSet = posCol.categories;
+      const posColCateogries = posCol.categories;
       const currentPositionObject = {general: {}} as PositionStats & { general: SummaryStats };
 
-      for (const [categoryIndex, monomer] of currentMonomerSet.entries()) {
+      for (let categoryIndex = 0; categoryIndex < posColCateogries.length; ++categoryIndex) {
+        const monomer = posColCateogries[categoryIndex];
         if (monomer == '')
           continue;
 
-        const mask: boolean[] = new Array(sourceDfLen);
-        let trueCount = 0;
-        for (let j = 0; j < sourceDfLen; ++j) {
-          mask[j] = posColData[j] == categoryIndex;
-
-          if (mask[j])
-            ++trueCount;
-        }
-
-        const maskInfo = {
-          trueCount: trueCount,
-          falseCount: sourceDfLen - trueCount,
-          mask: mask,
-        };
-
-        const stats = getStats(activityColData, maskInfo);
+        const bitArray = BitArray.fromSeq(sourceDfLen, (i: number) => posColData[i] === categoryIndex);
+        const stats = getStats(activityColData, bitArray);
         currentPositionObject[monomer] = stats;
-
         this.getSummaryStats(currentPositionObject.general, stats);
       }
       monomerPositionObject[posCol.name] = currentPositionObject;
@@ -538,93 +593,87 @@ export class PeptidesModel {
     return monomerPositionObject;
   }
 
-  getSummaryStats(generalObj: SummaryStats, stats: Stats | null = null, summaryStats: SummaryStats | null = null): void {
+  getSummaryStats(genObj: SummaryStats, stats: Stats | null = null, summaryStats: SummaryStats | null = null): void {
     if (stats == null && summaryStats == null)
       throw new Error(`MonomerPositionStatsError: either stats or summaryStats must be present`);
 
     const possibleMaxCount = stats?.count ?? summaryStats!.maxCount;
-    generalObj.maxCount ??= possibleMaxCount;
-    if (generalObj.maxCount < possibleMaxCount)
-      generalObj.maxCount = possibleMaxCount;
+    genObj.maxCount ??= possibleMaxCount;
+    if (genObj.maxCount < possibleMaxCount)
+      genObj.maxCount = possibleMaxCount;
 
     const possibleMinCount = stats?.count ?? summaryStats!.minCount;
-    generalObj.minCount ??= possibleMinCount;
-    if (generalObj.minCount > possibleMinCount)
-      generalObj.minCount = possibleMinCount;
+    genObj.minCount ??= possibleMinCount;
+    if (genObj.minCount > possibleMinCount)
+      genObj.minCount = possibleMinCount;
 
     const possibleMaxMeanDifference = stats?.meanDifference ?? summaryStats!.maxMeanDifference;
-    generalObj.maxMeanDifference ??= possibleMaxMeanDifference;
-    if (generalObj.maxMeanDifference < possibleMaxMeanDifference)
-      generalObj.maxMeanDifference = possibleMaxMeanDifference;
+    genObj.maxMeanDifference ??= possibleMaxMeanDifference;
+    if (genObj.maxMeanDifference < possibleMaxMeanDifference)
+      genObj.maxMeanDifference = possibleMaxMeanDifference;
 
     const possibleMinMeanDifference = stats?.meanDifference ?? summaryStats!.minMeanDifference;
-    generalObj.minMeanDifference ??= possibleMinMeanDifference;
-    if (generalObj.minMeanDifference > possibleMinMeanDifference)
-      generalObj.minMeanDifference = possibleMinMeanDifference;
+    genObj.minMeanDifference ??= possibleMinMeanDifference;
+    if (genObj.minMeanDifference > possibleMinMeanDifference)
+      genObj.minMeanDifference = possibleMinMeanDifference;
 
     const possibleMaxPValue = stats?.pValue ?? summaryStats!.maxPValue;
-    generalObj.maxPValue ??= possibleMaxPValue;
-    if (generalObj.maxPValue < possibleMaxPValue)
-      generalObj.maxPValue = possibleMaxPValue;
+    genObj.maxPValue ??= possibleMaxPValue;
+    if (genObj.maxPValue < possibleMaxPValue)
+      genObj.maxPValue = possibleMaxPValue;
 
     const possibleMinPValue = stats?.pValue ?? summaryStats!.minPValue;
-    generalObj.minPValue ??= possibleMinPValue;
-    if (generalObj.minPValue > possibleMinPValue)
-      generalObj.minPValue = possibleMinPValue;
+    genObj.minPValue ??= possibleMinPValue;
+    if (genObj.minPValue > possibleMinPValue)
+      genObj.minPValue = possibleMinPValue;
 
     const possibleMaxRatio = stats?.ratio ?? summaryStats!.maxRatio;
-    generalObj.maxRatio ??= possibleMaxRatio;
-    if (generalObj.maxRatio < possibleMaxRatio)
-      generalObj.maxRatio = possibleMaxRatio;
+    genObj.maxRatio ??= possibleMaxRatio;
+    if (genObj.maxRatio < possibleMaxRatio)
+      genObj.maxRatio = possibleMaxRatio;
 
     const possibleMinRatio = stats?.ratio ?? summaryStats!.minRatio;
-    generalObj.minRatio ??= possibleMinRatio;
-    if (generalObj.minRatio > possibleMinRatio)
-      generalObj.minRatio = possibleMinRatio;
+    genObj.minRatio ??= possibleMinRatio;
+    if (genObj.minRatio > possibleMinRatio)
+      genObj.minRatio = possibleMinRatio;
   }
 
-  calculateClusterStatistics(): {[cluster: string]: Stats} {
-    const originalClustersCol = this.df.getCol(this.settings.clustersColumnName!);
-    const originalClustersColData = originalClustersCol.getRawData();
-    const originalClustersColCategories = originalClustersCol.categories;
+  calculateClusterStatistics(): ClusterTypeStats {
+    const rowCount = this.df.rowCount;
 
-    const customClustersColumnsList = wu(this.customClusters).toArray();
+    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));
+    for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx)
+      origClustMasks[origClustColData[rowIdx]].setTrue(rowIdx);
 
-    const activityColData: type.RawData = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED).getRawData();
-    const activityColLen = activityColData.length;
-
-    // const resultStats: Stats[] = new Array(originalClustersColCategories.length + customClustersColumnsList.length);
-    const resultStats: {[cluster: string]: Stats} = {};
-
-    const clusterCount = originalClustersColCategories.length + customClustersColumnsList.length;
-    for (let clusterIdx = 0; clusterIdx < clusterCount; ++clusterIdx) {
-      const customClusterIdx = clusterIdx - originalClustersColCategories.length;
-      const customClusterColData = customClustersColumnsList[customClusterIdx]?.toList();
-      const isAcitvityIdxValid = customClusterIdx < 0 ?
-        (i: number) => clusterIdx == originalClustersColData[i] :
-        (i: number) => customClusterColData[i];
-
-      const mask: boolean[] = new Array(activityColLen);
-      let trueCount = 0;
-      for (let maskIdx = 0; maskIdx < activityColLen; ++maskIdx) {
-        mask[maskIdx] = isAcitvityIdxValid(maskIdx);
-
-        if (mask[maskIdx])
-          ++trueCount;
-      }
 
-      const maskInfo = {
-        trueCount: trueCount,
-        falseCount: activityColLen - trueCount,
-        mask: mask,
-      };
+    const customClustColList = wu(this.customClusters).toArray();
+    const customClustMasks = customClustColList.map(
+      (v) => BitArray.fromUint32Array(rowCount, v.getRawData() as Uint32Array));
+    const customClustColNamesList = customClustColList.map((v) => v.name);
+
+    const activityColData: type.RawData = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED).getRawData();
 
-      const stats = getStats(activityColData, maskInfo);
-      const clusterName = customClusterIdx < 0 ? originalClustersColCategories[clusterIdx] :
-        customClustersColumnsList[customClusterIdx].name;
-      resultStats[clusterName] = stats;
+    const origClustStats: ClusterStats = {};
+    const customClustStats: ClusterStats = {};
+
+    for (let clustType = 0; clustType < 2; ++clustType) {
+      const masks = clustType == 0 ? origClustMasks : customClustMasks;
+      const clustNames = clustType == 0 ? origClustColCat : customClustColNamesList;
+      const resultStats = clustType == 0 ? origClustStats : customClustStats;
+      for (let maskIdx = 0; maskIdx < masks.length; ++maskIdx) {
+        const mask = masks[maskIdx];
+        const stats = getStats(activityColData, mask);
+        resultStats[clustNames[maskIdx]] = stats;
+      }
     }
 
+    const resultStats = {} as ClusterTypeStats;
+    resultStats[CLUSTER_TYPE.ORIGINAL] = origClustStats;
+    resultStats[CLUSTER_TYPE.CUSTOM] = customClustStats;
     return resultStats;
   }
 
@@ -671,18 +720,23 @@ export class PeptidesModel {
   }
 
   modifyClusterSelection(cluster: string): void {
-    const tempSelection = this.logoSummarySelection;
+    const tempSelection = this.clusterSelection;
     const idx = tempSelection.indexOf(cluster);
     if (idx !== -1)
       tempSelection.splice(idx, 1);
     else
       tempSelection.push(cluster);
 
-    this.logoSummarySelection = tempSelection;
+    this.clusterSelection = tempSelection;
   }
 
-  initClusterSelection(cluster: string): void {
-    this.logoSummarySelection = [cluster];
+  initClusterSelection(options: {notify?: boolean} = {}): void {
+    options.notify ??= true;
+
+    if (options.notify)
+      this.clusterSelection = [];
+    else
+      this._clusterSelection = [];
   }
 
   setWebLogoInteraction(): void {
@@ -714,14 +768,16 @@ export class PeptidesModel {
     return null;
   }
 
-  requestBarchartAction(ev: MouseEvent, barPart: { position: string, monomer: string } | null): void {
+  requestBarchartAction(ev: MouseEvent, barPart: {position: string, monomer: string} | null): void {
     if (!barPart)
       return;
     const monomer = barPart.monomer;
     const position = barPart.position;
     if (ev.type === 'click') {
-      ev.shiftKey ? this.modifyMonomerPositionSelection(monomer, position, false) :
-        this.initMonomerPositionSelection(monomer, position, false);
+      if (!ev.shiftKey)
+        this.initMonomerPositionSelection({cleanInit: true, notify: false});
+
+      this.modifyMonomerPositionSelection(monomer, position, false);
     } else {
       const bar = `${position} = ${monomer}`;
       if (this.cachedWebLogoTooltip.bar == bar)
@@ -760,12 +816,13 @@ 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, sortedStatsOrder, this.df.rowCount,
+            this.cp, this.headerSelectedMonomers[col.name]);
           gcArgs.preventDefault();
         }
       } catch (e) {
-        console.warn(`PeptidesHeaderLogoError: couldn't render WebLogo for column \`${col!.name}\`. See original error below.`);
+        console.warn(`PeptidesHeaderLogoError: couldn't render WebLogo for column \`${col!.name}\`. ` +
+          `See original error below.`);
         console.warn(e);
       } finally {
         ctx.restore();
@@ -783,12 +840,12 @@ export class PeptidesModel {
     });
   }
 
-  showMonomerTooltip(aar: string, x: number, y: number): void {
+  showMonomerTooltip(aar: string, x: number, y: number): boolean {
     const tooltipElements: HTMLDivElement[] = [];
     const monomerName = aar.toLowerCase();
 
-    const mw = getMonomerWorks();
-    const mol = mw?.getCappedRotatedMonomer('PEPTIDE', aar);
+    const mw = getMonomerWorksInstance();
+    const mol = mw.getCappedRotatedMonomer('PEPTIDE', aar);
 
     if (mol) {
       tooltipElements.push(ui.div(monomerName));
@@ -798,6 +855,8 @@ export class PeptidesModel {
       tooltipElements.push(ui.div(aar));
 
     ui.tooltip.show(ui.divV(tooltipElements), x, y);
+
+    return mol !== null;
   }
 
   //TODO: move out to viewer code
@@ -807,92 +866,44 @@ export class PeptidesModel {
       return null;
 
     const activityCol = this.df.getCol(C.COLUMNS_NAMES.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);
-    const indexes: number[] = [];
-    splitCol.init((i) => {
-      const sameMonomer = currentPosCol.get(i) == aar;
-      if (sameMonomer)
-        indexes.push(i);
-
-      return sameMonomer;
-    });
-    const colResults: { [colName: string]: number } = {};
-    for (const [col, agg] of Object.entries(this.settings.columns || {})) {
-      const currentCol = this.df.getCol(col);
-      const currentColData = currentCol.getRawData();
-      const tempCol = DG.Column.float('', indexes.length);
-      tempCol.init((i) => currentColData[indexes[i]]);
-      colResults[`${agg}(${col})`] = tempCol.stats[agg as keyof DG.Stats] as number;
-    }
-
-    const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
-    const das = getDistributionAndStats(distributionTable, stats, `${position} : ${aar}`, 'Other', true);
-    const resultMap: { [key: string]: any } = {...das.tableMap, ...colResults};
-    const distroStatsElem = wrapDistroAndStatsDefault(das.labels, das.histRoot, resultMap);
+    const posCol = this.df.getCol(position);
+    const posColCategories = posCol.categories;
+    const aarCategoryIndex = posColCategories.indexOf(aar);
+    const posColData = posCol.getRawData();
+    const mask = DG.BitSet.create(activityCol.length, (i) => posColData[i] === aarCategoryIndex);
+
+    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 resultMap = {...tableMap, ...aggregatedColMap};
+    const distroStatsElem = getStatsSummary(labels, hist, resultMap, true);
 
     ui.tooltip.show(distroStatsElem, x, y);
 
     return distroStatsElem;
   }
 
-  showTooltipCluster(cluster: number, x: number, y: number, clusterName: string): HTMLDivElement | null {
-    const bs = this.df.filter;
-    const filteredDf = bs.anyFalse ? this.df.clone(bs) : this.df;
-    
-    const activityCol = filteredDf.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
-    const activityColData = activityCol.getRawData();
-    //TODO: use bitset instead of splitCol
-    const clusterCol = filteredDf.getCol(this.settings.clustersColumnName!);
-    const clusterColData = clusterCol.getRawData();
-    let splitCol = DG.Column.bool(C.COLUMNS_NAMES.SPLIT_COL, activityCol.length);
-    const indexes: number[] = [];
-    splitCol.init((i) => {
-      const result = clusterColData[i] == cluster;
-      if (result)
-        indexes.push(i);
-      return result;
-    });
-    if (splitCol.max == 0)
-      splitCol = filteredDf.getCol(clusterName);
-    const distDf = DG.DataFrame.fromColumns([activityCol, splitCol]);
-
-    let stats: Stats;
-    if (bs.anyFalse) {
-      const trueCount = splitCol.stats.sum;
-      const maskInfo = {
-        trueCount: trueCount,
-        falseCount: activityColData.length - trueCount,
-        mask: splitCol.toList() as boolean[],
-      };
-      stats = getStats(activityColData, maskInfo);
-    } else
-      stats = this.clusterStats[clusterName];
+  getAggregatedColumnValues(options: {filterDf?: boolean, mask?: DG.BitSet, fractionDigits?: number} = {},
+  ): StringDictionary {
+    options.filterDf ??= false;
 
-    if (!stats.count)
-      return null;
+    const filteredDf = options.filterDf && this.df.filter.anyFalse ? this.df.clone(this.df.filter) : this.df;
 
-    const colResults: {[colName: string]: number} = {};
-    for (const [col, agg] of Object.entries(this.settings.columns || {})) {
-      const currentCol = filteredDf.getCol(col);
-      const currentColData = currentCol.getRawData();
-      const tempCol = DG.Column.float('', indexes.length);
-      tempCol.init((i) => currentColData[indexes[i]]);
-      colResults[`${agg}(${col})`] = tempCol.stats[agg as keyof DG.Stats] as number;
+    const colResults: StringDictionary = {};
+    for (const [colName, aggFn] of Object.entries(this.settings.columns!)) {
+      const newColName = getAggregatedColName(aggFn, colName);
+      const value = getAggregatedValue(filteredDf.getCol(colName), aggFn, options.mask);
+      colResults[newColName] = value.toFixed(options.fractionDigits);
     }
-
-    const das = getDistributionAndStats(distDf, stats, `Cluster: ${clusterName}`, 'Other', true, splitCol.name);
-    const resultMap: {[key: string]: any} = {...das.tableMap, ...colResults};
-    const tooltip = wrapDistroAndStatsDefault(das.labels, das.histRoot, resultMap, true);
-
-    ui.tooltip.show(tooltip, x, y);
-
-    return tooltip;
+    return colResults;
   }
 
-  modifyMonomerPositionSelection(aar: string, position: string, isInvariantMapSelection: boolean): void {
-    const tempSelection = isInvariantMapSelection ? this.invariantMapSelection : this.mutationCliffsSelection;
+  modifyMonomerPositionSelection(aar: string, position: string, isFilter: boolean): void {
+    const tempSelection = isFilter ? this.monomerPositionFilter : this.monomerPositionSelection;
     const tempSelectionAt = tempSelection[position];
     const aarIndex = tempSelectionAt.indexOf(aar);
     if (aarIndex === -1)
@@ -900,22 +911,10 @@ export class PeptidesModel {
     else
       tempSelectionAt.splice(aarIndex, 1);
 
-    if (isInvariantMapSelection)
-      this.invariantMapSelection = tempSelection;
+    if (isFilter)
+      this.monomerPositionFilter = tempSelection;
     else
-      this.mutationCliffsSelection = tempSelection;
-  }
-
-  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)
-      this.invariantMapSelection = tempSelection;
-    else
-      this.mutationCliffsSelection = tempSelection;
+      this.monomerPositionSelection = tempSelection;
   }
 
   setBitsetCallback(): void {
@@ -925,51 +924,56 @@ export class PeptidesModel {
     const filter = this.df.filter;
     const clusterCol = this.df.col(this.settings.clustersColumnName!);
 
-    const changeSelectionBitset = (currentBitset: DG.BitSet): void => {
-      const clusterColCategories = clusterCol?.categories;
-      const clusterColData = clusterCol?.getRawData();
-
-      const edfSelection = this.edf?.selection;
-      if (this.isPeptideSpaceChangingBitset) {
-        if (edfSelection == null)
-          return;
-
-        currentBitset.init((i) => edfSelection.get(i) || false, false);
-        return;
-      }
+    const changeSelectionBitset = (currentBitset: DG.BitSet, posList: type.RawColumn[], 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 updateEdfSelection = (): void => {
-        this.isChangingEdfBitset = true;
-        edfSelection?.copyFrom(currentBitset);
-        this.isChangingEdfBitset = false;
-      };
+        const currentOrigClust = clustColCat[clustColData[i]];
+        if (typeof currentOrigClust === undefined)
+          return false;
 
-      const positionList = Object.keys(this.mutationCliffsSelection);
+        for (const clust of this.clusterSelection) {
+          if (clust === currentOrigClust)
+            return true;
 
-      //TODO: move out
-      const getBitAt = (i: number): boolean => {
-        for (const position of positionList) {
-          const positionCol: DG.Column<string> = this.df.getCol(position);
-          if (this.mutationCliffsSelection[position].includes(positionCol.get(i)!))
+          if (Object.hasOwn(customClust, clust) && customClust[clust].getBit(i))
             return true;
         }
-        return (typeof clusterColData != 'undefined' && typeof clusterColCategories != 'undefined' &&
-          this.logoSummarySelection.includes(clusterColCategories![clusterColData![i]])) ||
-          this.logoSummarySelection.some((cluster) => this.df.columns.contains(cluster) && this.df.get(cluster, i));
+
+        return false;
       };
       currentBitset.init((i) => getBitAt(i), false);
-
-      updateEdfSelection();
     };
 
-    selection.onChanged.subscribe(() => changeSelectionBitset(selection));
+    selection.onChanged.subscribe(() => {
+      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} = {};
+      const rowCount = this.df.rowCount;
+      for (const clust of this.customClusters)
+        customClust[clust.name] = BitArray.fromUint32Array(rowCount, clust.getRawData() as Uint32Array);
+
+      changeSelectionBitset(selection, positionList, clustColCat, clustColData, customClust);
+    });
 
     filter.onChanged.subscribe(() => {
-      const positionList = Object.keys(this.invariantMapSelection);
+      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.invariantMapSelection[position];
+          const aarList = this.monomerPositionFilter[position];
           result &&= aarList.length === 0 || aarList.includes(this.df.get(position, index));
           if (!result)
             return result;
@@ -988,8 +992,8 @@ export class PeptidesModel {
     this.isBitsetChangedInitialized = true;
   }
 
-  fireBitsetChanged(isPeptideSpaceSource: boolean = false, fireFilterChanged: boolean = false): void {
-    this.isPeptideSpaceChangingBitset = isPeptideSpaceSource;
+  fireBitsetChanged(fireFilterChanged: boolean = false): void {
+    this.isUserChangedSelection = false;
     this.df.selection.fireChanged();
     if (fireFilterChanged)
       this.df.filter.fireChanged();
@@ -1002,8 +1006,7 @@ export class PeptidesModel {
       for (const pane of acc.panes)
         pane.expanded = true;
     }
-
-    this.isPeptideSpaceChangingBitset = false;
+    this.isUserChangedSelection = true;
   }
 
   postProcessGrids(): void {
@@ -1015,7 +1018,6 @@ export class PeptidesModel {
     const sourceGridProps = sourceGrid.props;
     sourceGridProps.allowColSelection = false;
     sourceGridProps.allowEdit = false;
-    sourceGridProps.allowRowResizing = false;
     sourceGridProps.showCurrentRowIndicator = false;
     this.df.temp[C.EMBEDDING_STATUS] = false;
     for (let colIdx = 1; colIdx < sourceGridColsLen; ++colIdx) {
@@ -1023,7 +1025,41 @@ export class PeptidesModel {
       const tableColName = gridCol.column!.name;
       gridCol.visible = posCols.includes(tableColName) || (tableColName === C.COLUMNS_NAMES.ACTIVITY_SCALED) ||
         visibleColumns.includes(tableColName);
-      gridCol.width = 60;
+    }
+  }
+
+  closeViewer(viewerType: VIEWER_TYPE): void {
+    const viewer = this.findViewer(viewerType);
+    viewer?.detach();
+    viewer?.close();
+  }
+
+  findViewerNode(viewerType: VIEWER_TYPE): DG.DockNode | null {
+    for (const node of this.analysisView.dockManager.rootNode.children) {
+      if (node.container.containerElement.innerHTML.includes(viewerType))
+        return node;
+    }
+    return null;
+  }
+
+  async addDendrogram(): Promise<void> {
+    const pi = DG.TaskBarProgressIndicator.create('Calculating distance matrix...');
+    try {
+      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');
+
+      this.df.setTag(treeTAGS.NEWICK, this.treeHelper.toNewick(treeNode));
+      const leafOrdering = this.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;
+
+      this.analysisView.dockManager.dock(dendrogramViewer, DG.DOCK_TYPE.LEFT, null, 'Dendrogram', 0.25);
+    } catch (e) {
+      _package.logger.error(e as string);
+    } finally {
+      pi.close();
     }
   }
 
@@ -1051,41 +1087,61 @@ 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();
-    this.fireBitsetChanged(false, true);
+    this.fireBitsetChanged(true);
     this.analysisView.grid.invalidate();
   }
 
-  async addViewers(): Promise<void> {
-    const dockManager = this.analysisView.dockManager;
-    const dfPlt = this.df.plot;
-
-    const mutationCliffsViewer = await dfPlt.fromType('peptide-sar-viewer') as MonomerPosition;
-    const mostPotentResiduesViewer = await dfPlt.fromType('peptide-sar-viewer-vertical') as MostPotentResiduesViewer;
-    if (this.settings.clustersColumnName)
-      await this.addLogoSummaryTableViewer();
+  findViewer(viewerType: VIEWER_TYPE): DG.Viewer | null {
+    return wu(this.analysisView.viewers).find((v) => v.type === viewerType) || null;
+  }
 
-    const mcNode = dockManager.dock(mutationCliffsViewer, DG.DOCK_TYPE.DOWN, null, mutationCliffsViewer.name);
+  async addLogoSummaryTable(): Promise<void> {
+    this.closeViewer(VIEWER_TYPE.MONOMER_POSITION);
+    this.closeViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES);
+    const logoSummaryTable = await this.df.plot.fromType(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable;
+    this.analysisView.dockManager.dock(logoSummaryTable, DG.DOCK_TYPE.RIGHT, null, VIEWER_TYPE.LOGO_SUMMARY_TABLE);
+    if (this.settings.showMonomerPosition)
+      await this.addMonomerPosition();
+    if (this.settings.showMostPotentResidues)
+      await this.addMostPotentResidues();
+  }
 
-    dockManager.dock(mostPotentResiduesViewer, DG.DOCK_TYPE.RIGHT, mcNode, mostPotentResiduesViewer.name, 0.3);
+  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 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];
+    dm.dock(monomerPosition, dockType, refNode, VIEWER_TYPE.MONOMER_POSITION, ratio);
   }
 
-  async addLogoSummaryTableViewer(): Promise<void> {
-    const logoSummary = await this.df.plot.fromType('logo-summary-viewer') as LogoSummary;
-    this.analysisView.dockManager.dock(logoSummary, DG.DOCK_TYPE.RIGHT, null, 'Logo Summary Table');
+  async addMostPotentResidues(): Promise<void> {
+    const mostPotentResidues =
+      await this.df.plot.fromType(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResiduesViewer;
+    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] :
+      [DG.DOCK_TYPE.RIGHT, this.findViewerNode(VIEWER_TYPE.MONOMER_POSITION), 0.3];
+    dm.dock(mostPotentResidues, dockType, refNode, VIEWER_TYPE.MOST_POTENT_RESIDUES, ratio);
   }
 
   addNewCluster(clusterName: string): void {
-    const newClusterCol = DG.Column.fromBitSet(clusterName, this.getCompoundBitest());
+    const newClusterCol = DG.Column.fromBitSet(clusterName, this.getCompoundBitset());
     newClusterCol.setTag(C.TAGS.CUSTOM_CLUSTER, '1');
     this.df.columns.add(newClusterCol);
     this.analysisView.grid.col(newClusterCol.name)!.visible = false;
   }
 
-  async createNewView(): Promise<void> {
-    const rowMask = this.getCompoundBitest();
+  createNewView(): void {
+    const rowMask = this.getCompoundBitset();
     if (!rowMask.anyTrue)
       return grok.shell.warning('Cannot create a new view, there are no visible selected rows in your dataset');