@datagrok/peptides 1.16.0 → 1.17.1

package/src/model.ts

@@ -1,311 +1,188 @@
 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 {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
-import {pickUpPalette, TAGS as bioTAGS, monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {
+  monomerToShort,
+  NOTATION,
+  pickUpPalette,
+  TAGS as bioTAGS,
+} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {calculateScores, SCORE} from '@datagrok-libraries/bio/src/utils/macromolecule/scoring';
 import {Options} from '@datagrok-libraries/utils/src/type-declarations';
 import {DistanceMatrix} from '@datagrok-libraries/ml/src/distance-matrix';
-import {StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
+import {BitArrayMetrics, 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 {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 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 {COLUMN_NAME, COLUMNS_NAMES} from './utils/constants';
 import * as type from './utils/types';
-import {calculateSelected, extractColInfo, scaleActivity} from './utils/misc';
-import {MONOMER_POSITION_PROPERTIES, MonomerPosition, MostPotentResidues, SELECTION_MODE} from './viewers/sar-viewer';
+import {PeptidesSettings} from './utils/types';
+import {
+  areParametersEqual,
+  calculateSelected,
+  getSelectionBitset,
+  highlightMonomerPosition,
+  initSelection,
+  modifySelection,
+  mutationCliffsToMaskInfo,
+  scaleActivity,
+} from './utils/misc';
+import {ISARViewer, MonomerPosition, MostPotentResidues, SARViewer} from './viewers/sar-viewer';
 import * as CR from './utils/cell-renderer';
 import {mutationCliffsWidget} from './widgets/mutation-cliffs';
-import {getDistributionWidget} from './widgets/distribution';
-import {ClusterTypeStats, MonomerPositionStats, PositionStats} from './utils/statistics';
-import {LogoSummaryTable} from './viewers/logo-summary';
+import {getDistributionWidget, PeptideViewer} from './widgets/distribution';
+import {CLUSTER_TYPE, ILogoSummaryTable, LogoSummaryTable, LST_PROPERTIES} from './viewers/logo-summary';
 import {getSettingsDialog} from './widgets/settings';
 import {_package, getTreeHelperInstance} from './package';
-import {calculateClusterStatistics, calculateMonomerPositionStatistics, findMutations} from './utils/algorithms';
+import {calculateMonomerPositionStatistics} from './utils/algorithms';
 import {createDistanceMatrixWorker} from './utils/worker-creator';
 import {getSelectionWidget} from './widgets/selection';
 
-import {MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
-import {BitArrayMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
+import {mmDistanceFunctions, MmDistanceFunctionsNames} from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 import {DimReductionMethods, ITSNEOptions, IUMAPOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {showMonomerTooltip} from './utils/tooltips';
+import {AggregationColumns, MonomerPositionStats} from './utils/statistics';
+import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 
-export enum CLUSTER_TYPE {
-  ORIGINAL = 'original',
-  CUSTOM = 'custom',
-};
-export type ClusterType = `${CLUSTER_TYPE}`;
 export enum VIEWER_TYPE {
   MONOMER_POSITION = 'Monomer-Position',
   MOST_POTENT_RESIDUES = 'Most Potent Residues',
   LOGO_SUMMARY_TABLE = 'Logo Summary Table',
   DENDROGRAM = 'Dendrogram',
-};
+}
+
+export type CachedWebLogoTooltip = { bar: string, tooltip: HTMLDivElement | null };
 
+/**
+ * Peptides model class
+ * Controls analysis settings and initialization, collaborative filtering and property panel.
+ */
 export class PeptidesModel {
+  // Tag for storing model instance in DataFrame temp
   static modelName = 'peptidesModel';
 
+  // Prevents firing bitset changed event if not initialized
   isBitsetChangedInitialized = false;
+  // Prevents overriding user selection
   isUserChangedSelection = true;
 
   df: DG.DataFrame;
-  _monomerPositionStats?: MonomerPositionStats;
-  _clusterStats?: ClusterTypeStats;
-  _mutationCliffsSelection!: type.Selection;
-  _invariantMapSelection!: type.Selection;
-  _clusterSelection!: type.Selection;
-  _mutationCliffs: type.MutationCliffs | null = null;
+  _dm: DistanceMatrix | null = null;
+  // Prevents redundant intialization
   isInitialized = false;
-  _analysisView?: DG.TableView;
-
-
-  _settings!: type.PeptidesSettings;
+  // Prevents duplicating ribbon
   isRibbonSet = false;
-
-  _cp?: SeqPalette;
-  headerSelectedMonomers: type.SelectionStats = {};
+  // Cached stats for WebLogo selection for efficient rendering
+  webLogoSelectedMonomers: type.SelectionStats = {};
+  // WebLogo bounds used for interactivity (e.g. tooltips, selection)
   webLogoBounds: CR.WebLogoBounds = {};
-  cachedWebLogoTooltip: {bar: string, tooltip: HTMLDivElement | null} = {bar: '', tooltip: null};
-  _alphabet?: string;
-  _dm!: DistanceMatrix;
+  // Cached WebLogo tooltip. Because tooltip is requested for each mouse movement, it is cached unless mouse entered
+  // bounds of other monomer in WebLogo
+  cachedWebLogoTooltip: CachedWebLogoTooltip = {bar: '', tooltip: null};
+  // Prevents from redundant grid processing
   _layoutEventInitialized = false;
-
+  // Stores subscriptions to remove after analysis is closed
   subs: rxjs.Subscription[] = [];
+  // Prevents from redundant unhilight operation
   isHighlighting: boolean = false;
-  latestSelectionItem: (type.SelectionItem & {kind: SELECTION_MODE | 'Cluster'}) | null = null;
+  // Fires bitset changed to properly render selection in scroller bar
   controlFire: boolean = false;
-
+  // Indicates the source of accordion construction
+  accordionSource: VIEWER_TYPE | null = null;
+  // sequence space viewer
+  _sequenceSpaceViewer: DG.ScatterPlotViewer | null = null;
+  /**
+   * @param dataFrame - DataFrame to use for analysis
+   */
   private constructor(dataFrame: DG.DataFrame) {
     this.df = dataFrame;
   }
 
-  static getInstance(dataFrame: DG.DataFrame): PeptidesModel {
-    dataFrame.temp[PeptidesModel.modelName] ??= new PeptidesModel(dataFrame);
-    (dataFrame.temp[PeptidesModel.modelName] as PeptidesModel).init();
-    return dataFrame.temp[PeptidesModel.modelName] as PeptidesModel;
-  }
-
-  get id(): string {
-    const id = this.df.getTag(C.TAGS.UUID);
-    if (id === null || id === '')
-      throw new Error('PeptidesError: UUID is not defined');
-
-    return id;
-  }
-
-  get monomerPositionStats(): MonomerPositionStats {
-    this._monomerPositionStats ??= calculateMonomerPositionStatistics(this.df, this.positionColumns.toArray());
-    return this._monomerPositionStats!;
-  }
+  // Monomer-Position statistics cache
+  _monomerPositionStats: MonomerPositionStats | null = null;
 
-  set monomerPositionStats(mps: MonomerPositionStats) {
-    this._monomerPositionStats = mps;
-  }
-
-  get positionColumns(): wu.WuIterable<DG.Column> {
-    return wu(this.df.columns.byTags({[C.TAGS.POSITION_COL]: `${true}`}));
-  }
-
-  get alphabet(): string {
-    const col = this.df.getCol(this.settings.sequenceColumnName!);
-    return col.getTag(bioTAGS.alphabet);
-  }
-
-  get mutationCliffs(): type.MutationCliffs | null {
-    return this._mutationCliffs!;
-  }
+  /**
+   * @return - Monomer-Position statistics
+   */
+  get monomerPositionStats(): MonomerPositionStats | null {
+    if (this._monomerPositionStats !== null) {
+      return this._monomerPositionStats;
+    }
 
-  set mutationCliffs(si: type.MutationCliffs | null) {
-    this._mutationCliffs = si;
-  }
 
-  get clusterStats(): ClusterTypeStats {
-    this._clusterStats ??= calculateClusterStatistics(this.df, this.settings.clustersColumnName!,
-      this.customClusters.toArray());
-    return this._clusterStats!;
-  }
+    const scaledActivityColumn = this.getScaledActivityColumn();
+    if (this.positionColumns === null || scaledActivityColumn === null) {
+      return null;
+    }
 
-  set clusterStats(clusterStats: ClusterTypeStats) {
-    this._clusterStats = clusterStats;
-  }
 
-  get cp(): SeqPalette {
-    this._cp ??= pickUpPalette(this.df.getCol(this.settings.sequenceColumnName!));
-    return this._cp;
+    this._monomerPositionStats ??= calculateMonomerPositionStatistics(scaledActivityColumn,
+      this.df.filter, this.positionColumns);
+    return this._monomerPositionStats;
   }
 
-  set cp(_cp: SeqPalette) {
-    this._cp = _cp;
-  }
+  // Analysis Table View
+  _analysisView?: DG.TableView;
 
+  /**
+   * @return - Analysis table view
+   */
   get analysisView(): DG.TableView {
     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 = wu(grok.shell.tableViews).find(({dataFrame}) => dataFrame?.getTag(DG.TAGS.ID) === this.id);
+      if (typeof this._analysisView === 'undefined') {
         this._analysisView = grok.shell.addTableView(this.df);
-        const posCols = this.positionColumns.toArray().map((col) => col.name);
-
-        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)
+    if (this.df.getTag(C.TAGS.MULTIPLE_VIEWS) !== '1' && !this._layoutEventInitialized) {
       grok.shell.v = this._analysisView;
-
-    this._analysisView.grid.invalidate();
-    return this._analysisView;
-  }
-
-  get mutationCliffsSelection(): type.Selection {
-    const tagSelection = this.df.getTag(C.TAGS.MUTATION_CLIFFS_SELECTION) ?? this.df.getTag(C.TAGS.SELECTION);
-    if (tagSelection === null)
-      this.initMutationCliffsSelection({notify: false});
-    this._mutationCliffsSelection ??= JSON.parse(tagSelection ?? this.df.getTag(C.TAGS.MUTATION_CLIFFS_SELECTION) ?? this.df.getTag(C.TAGS.SELECTION)!);
-    return this._mutationCliffsSelection;
-  }
-
-  set mutationCliffsSelection(selection: type.Selection) {
-    this._mutationCliffsSelection = selection;
-    // TODO: Remove in 1.14.0
-    this.df.setTag(C.TAGS.SELECTION, JSON.stringify(selection));
-    this.df.setTag(C.TAGS.MUTATION_CLIFFS_SELECTION, JSON.stringify(selection));
-    this.fireBitsetChanged();
-
-    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 invariantMapSelection(): type.Selection {
-    const tagSelection = this.df.getTag(C.TAGS.INVARIANT_MAP_SELECTION) ?? this.df.getTag(C.TAGS.FILTER);
-    if (tagSelection === null)
-      this.initInvariantMapSelection({notify: false});
-    this._invariantMapSelection ??= JSON.parse(tagSelection ?? this.df.getTag(C.TAGS.INVARIANT_MAP_SELECTION) ?? this.df.getTag(C.TAGS.FILTER)!);
-    return this._invariantMapSelection;
-  }
-
-  set invariantMapSelection(selection: type.Selection) {
-    this._invariantMapSelection = selection;
-    this.df.setTag(C.TAGS.INVARIANT_MAP_SELECTION, JSON.stringify(selection));
-    // TODO: Remove in 1.14.0
-    this.df.setTag(C.TAGS.FILTER, JSON.stringify(selection));
-    this.fireBitsetChanged();
-    this.analysisView.grid.invalidate();
-  }
-
-  get clusterSelection(): type.Selection {
-    const tagSelection = this.df.getTag(C.TAGS.CLUSTER_SELECTION);
-    if (tagSelection === null)
-      this.initClusterSelection({notify: false});
-    this._clusterSelection ??= JSON.parse(tagSelection ?? this.df.getTag(C.TAGS.CLUSTER_SELECTION)!);
-    // TODO: Remove in 1.14.0
-    if (Array.isArray(this._clusterSelection)) {
-      const newSelection: type.Selection = {};
-      newSelection[CLUSTER_TYPE.ORIGINAL] = [];
-      newSelection[CLUSTER_TYPE.CUSTOM] = [];
-      for (const cluster of this._clusterSelection) {
-        if (wu(this.customClusters).some((col) => col.name === cluster))
-          newSelection[CLUSTER_TYPE.CUSTOM].push(cluster);
-        else
-          newSelection[CLUSTER_TYPE.ORIGINAL].push(cluster);
-      }
-      this._clusterSelection = newSelection;
     }
-    return this._clusterSelection;
-  }
-
-  set clusterSelection(selection: type.Selection) {
-    this._clusterSelection = selection;
-    this.df.tags[C.TAGS.CLUSTER_SELECTION] = JSON.stringify(selection);
-    this.fireBitsetChanged();
-    this.analysisView.grid.invalidate();
-  }
-
-  get splitByPos(): boolean {
-    const splitByPosFlag = (this.df.tags['distributionSplit'] || '00')[0];
-    return splitByPosFlag === '1' ? true : false;
-  }
 
-  set splitByPos(flag: boolean) {
-    const splitByMonomerFlag = (this.df.tags['distributionSplit'] || '00')[1];
-    this.df.tags['distributionSplit'] = `${flag ? 1 : 0}${splitByMonomerFlag}`;
-  }
-
-  get splitByMonomer(): boolean {
-    const splitByPosFlag = (this.df.tags['distributionSplit'] || '00')[1];
-    return splitByPosFlag === '1' ? true : false;
-  }
 
-  set splitByMonomer(flag: boolean) {
-    const splitByMonomerFlag = (this.df.tags['distributionSplit'] || '00')[0];
-    this.df.tags['distributionSplit'] = `${splitByMonomerFlag}${flag ? 1 : 0}`;
+    this._analysisView.grid.invalidate();
+    return this._analysisView;
   }
 
-  get isMutationCliffsSelectionEmpty(): boolean {
-    for (const monomerList of Object.values(this.mutationCliffsSelection)) {
-      if (monomerList.length !== 0)
-        return false;
-    }
-    return true;
-  }
+  // Peptides analysis settings
+  _settings: type.PeptidesSettings | null = null;
+  _sequenceSpaceCols: string[] = [];
 
-  get isInvariantMapSelectionEmpty(): boolean {
-    for (const monomerList of Object.values(this.invariantMapSelection)) {
-      if (monomerList.length !== 0)
-        return false;
+  /**
+   * @return - Peptides analysis settings
+   */
+  get settings(): type.PeptidesSettings | null {
+    const settingsStr = this.df.getTag(C.TAGS.SETTINGS);
+    if (settingsStr == null) {
+      return null;
     }
-    return true;
-  }
-
-  get isClusterSelectionEmpty(): boolean {
-    return (this.clusterSelection[CLUSTER_TYPE.ORIGINAL].length + this.clusterSelection[CLUSTER_TYPE.CUSTOM].length) === 0;
-  }
 
-  get customClusters(): wu.WuIterable<DG.Column<boolean>> {
-    const query: { [key: string]: string } = {};
-    query[C.TAGS.CUSTOM_CLUSTER] = '1';
-    return wu(this.df.columns.byTags(query));
-  }
 
-  get settings(): type.PeptidesSettings {
-    this._settings ??= JSON.parse(this.df.getTag('settings')!);
-    return this._settings;
+    this._settings ??= JSON.parse(settingsStr);
+    return this._settings!;
   }
 
-  set settings(s: type.PeptidesSettings) {
-    const newSettingsEntries = Object.entries(s);
+  /**
+   * @param s - Peptides analysis settings
+   */
+  set settings(s: type.PartialPeptidesSettings) {
+    const newSettingsEntries = Object.entries(s) as ([keyof type.PeptidesSettings, never])[];
+    // Holds updated settings categories
     const updateVars: Set<string> = new Set();
     for (const [key, value] of newSettingsEntries) {
-      this._settings[key as keyof type.PeptidesSettings] = value as any;
+      this.settings![key] = value;
       switch (key) {
       case 'activityColumnName':
-      case 'scaling':
+      case 'activityScaling':
         updateVars.add('activity');
-        updateVars.add('mutationCliffs');
         updateVars.add('stats');
         break;
-      case 'columns':
-        updateVars.add('grid');
-        break;
-      case 'maxMutations':
-      case 'minActivityDelta':
-        updateVars.add('mutationCliffs');
-        break;
       case 'showDendrogram':
         updateVars.add('dendrogram');
         break;
@@ -318,164 +195,441 @@ export class PeptidesModel {
       case 'showMostPotentResidues':
         updateVars.add('mostPotentResidues');
         break;
+      case 'columns':
+        updateVars.add('columns');
+        break;
+      case 'sequenceSpaceParams':
+        updateVars.add('sequenceSpaceParams');
       }
     }
+    // Write updated settings
     this.df.setTag('settings', JSON.stringify(this._settings));
-    let updateViewersData = false;
+    if (!this.isInitialized) {
+      return;
+    }
+
+
+    // Apply new settings
     for (const variable of updateVars) {
       switch (variable) {
       case 'activity':
         this.createScaledCol();
-        updateViewersData = true;
-        break;
-      case 'mutationCliffs':
-        this.updateMutationCliffs();
         break;
       case 'stats':
-        this.monomerPositionStats = calculateMonomerPositionStatistics(this.df, this.positionColumns.toArray());
-        this.clusterStats = calculateClusterStatistics(this.df, this.settings.clustersColumnName!,
-          this.customClusters.toArray());
-        updateViewersData = true;
-        break;
-      case 'grid':
-        this.setGridProperties();
-        const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
-        lstViewer?.createLogoSummaryTableGrid();
-        lstViewer?.render();
+        this.webLogoSelection = initSelection(this.positionColumns!);
+        this.webLogoBounds = {};
+        this.cachedWebLogoTooltip = {
+          bar: '',
+          tooltip: null,
+        };
+        // Invalidate monomer-position statistics. The next time it gets accessed with getter, it will be recalculated
+        this._monomerPositionStats = null;
         break;
       case 'dendrogram':
-        this.settings.showDendrogram ? this.addDendrogram() : this.closeViewer(VIEWER_TYPE.DENDROGRAM);
+        this.settings!.showDendrogram ? this.addDendrogram() : this.closeViewer(VIEWER_TYPE.DENDROGRAM);
         break;
       case 'logoSummaryTable':
-        this.settings.showLogoSummaryTable ? this.addLogoSummaryTable() :
+        this.settings!.showLogoSummaryTable ? this.addLogoSummaryTable() :
           this.closeViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE);
         break;
       case 'monomerPosition':
-        this.settings.showMonomerPosition ? this.addMonomerPosition() :
+        this.settings!.showMonomerPosition ? this.addMonomerPosition() :
           this.closeViewer(VIEWER_TYPE.MONOMER_POSITION);
         break;
       case 'mostPotentResidues':
-        this.settings.showMostPotentResidues ? this.addMostPotentResidues() :
+        this.settings!.showMostPotentResidues ? this.addMostPotentResidues() :
           this.closeViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES);
         break;
+      case 'columns':
+        const lst = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable;
+        lst._viewerGrid = null;
+        lst._logoSummaryTable = null;
+        lst.render();
+        const mpr = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as LogoSummaryTable;
+        mpr._viewerGrid = null;
+        mpr.render();
+        break;
+      case 'sequenceSpaceParams':
+        this.addSequenceSpace();
+        break;
       }
     }
+  }
 
-    //TODO: handle settings change
-    const mpViewer = this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
-    if (updateViewersData)
-      mpViewer?.createMonomerPositionGrid();
-    mpViewer?.render();
-    const mprViewer = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues | null;
-    if (updateViewersData)
-      mprViewer?.createMostPotentResiduesGrid();
-    mprViewer?.render();
-    const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
-    if (updateViewersData)
-      lstViewer?.createLogoSummaryTableGrid();
-    lstViewer?.render();
+  // Current Monomer-Position selection that came from WebLogo in header
+  _webLogoSelection: type.Selection | null = null;
+
+  /**
+   * @return - Current Monomer-Position selection that came from WebLogo in header
+   */
+  get webLogoSelection(): type.Selection {
+    const tagSelection = this.df.getTag(`${C.SUFFIXES.WL}${C.TAGS.INVARIANT_MAP_SELECTION}`);
+    this._webLogoSelection ??= tagSelection === null && this.positionColumns !== null ?
+      initSelection(this.positionColumns) : JSON.parse(tagSelection ?? `{}`);
+    return this._webLogoSelection!;
   }
 
-  get identityTemplate(): string {
-    return this.df.getTag(C.TAGS.IDENTITY_TEMPLATE) ?? '';
+  /**
+   * @param selection - Current Monomer-Position selection that came from WebLogo in header
+   */
+  set webLogoSelection(selection: type.Selection) {
+    this._webLogoSelection = selection;
+    this.df.setTag(`${C.SUFFIXES.WL}${C.TAGS.INVARIANT_MAP_SELECTION}`, JSON.stringify(selection));
+    this.fireBitsetChanged(null);
+    this.analysisView.grid.invalidate();
   }
 
-  set identityTemplate(template: string) {
-    this.df.setTag(C.TAGS.IDENTITY_TEMPLATE, template);
+  /**
+   * @return - Array of columns that represent monomers at specific position in sequences
+   */
+  get positionColumns(): DG.Column<string>[] | null {
+    const positionColumns = wu(this.df.columns.byTags({[C.TAGS.POSITION_COL]: `${true}`})).toArray();
+    if (positionColumns.length === 0) {
+      return null;
+    }
+
+
+    return positionColumns;
   }
 
-  async updateMutationCliffs(notify: boolean = true): Promise<void> {
-    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 monomerCols: type.RawColumn[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER).map(extractColInfo);
-    const targetCol = typeof this.settings.targetColumnName !== 'undefined' ?
-      extractColInfo(this.df.getCol(this.settings.targetColumnName)) : null;
-    let mpViewer = this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
-    const currentTarget = mpViewer?.getProperty(MONOMER_POSITION_PROPERTIES.TARGET)?.get(mpViewer) as string | undefined;
-    const targetOptions = {targetCol: targetCol, currentTarget: currentTarget};
-    const mutationCliffs = await findMutations(scaledActivityCol.getRawData(), monomerCols, this.settings, targetOptions);
-    if (notify)
-      this.mutationCliffs = mutationCliffs;
-    else
-      this._mutationCliffs = mutationCliffs;
+  /**
+   * @return - DataFrame ID
+   */
+  get id(): string {
+    return this.df.getTag(DG.TAGS.ID)!;
+  }
 
-    mpViewer ??= this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
-    mpViewer?.render(true);
-    const mostPotentViewer = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues | null;
-    mostPotentViewer?.render(true);
+  /**
+   * @return - Sequence alphabet
+   */
+  get alphabet(): string {
+    const col = this.df.getCol(this.settings!.sequenceColumnName);
+    return col.getTag(bioTAGS.alphabet);
   }
 
-  buildSplitSeqDf(): DG.DataFrame {
-    const sequenceCol = this.df.getCol(this.settings.sequenceColumnName!);
-    const splitSeqDf = splitAlignedSequences(sequenceCol);
+  /**
+   * Creates an instance of PeptidesModel or returns existing if present
+   * @param dataFrame - DataFrame to use for analysis
+   * @return - PeptidesModel instance
+   */
+  static getInstance(dataFrame: DG.DataFrame): PeptidesModel {
+    if (dataFrame.columns.contains(C.COLUMNS_NAMES.ACTIVITY_SCALED) &&
+      !dataFrame.columns.contains(C.COLUMNS_NAMES.ACTIVITY)) {
+      dataFrame.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED).name = C.COLUMNS_NAMES.ACTIVITY;
+    }
 
-    return splitSeqDf;
+
+    dataFrame.temp[PeptidesModel.modelName] ??= new PeptidesModel(dataFrame);
+    return dataFrame.temp[PeptidesModel.modelName] as PeptidesModel;
   }
 
-  getCompoundBitset(): DG.BitSet {
+  /**
+   * Modifies WebLogo selection. If shift and ctrl keys are both pressed, it removes WebLogo from
+   * selection. If only shift key is pressed, it adds WebLogo to selection. If only ctrl key is pressed, it
+   * changes WebLogo presence in selection. If none of the keys is pressed, it sets the WebLogo as the
+   * only selected one.
+   * @param monomerPosition - cluster to modify selection with.
+   * @param options - selection options.
+   * @param notify - flag indicating if bitset changed event should fire.
+   */
+  modifyWebLogoSelection(monomerPosition: type.SelectionItem, options: type.SelectionOptions = {
+    shiftPressed: false,
+    ctrlPressed: false,
+  }, notify: boolean = true): void {
+    if (notify) {
+      this.webLogoSelection = modifySelection(this.webLogoSelection, monomerPosition, options);
+    } else {
+      this._webLogoSelection = modifySelection(this.webLogoSelection, monomerPosition, options);
+    }
+  }
+
+  /**
+   * @return - Bitset of visible selection
+   */
+  getVisibleSelection(): DG.BitSet {
     return this.df.selection.clone().and(this.df.filter);
   }
 
+  /**
+   * @return - Accordion with analysis info based on current selection
+   */
   createAccordion(): DG.Accordion | null {
     const trueModel: PeptidesModel | undefined = grok.shell.t?.temp[PeptidesModel.modelName];
-    if (!trueModel)
+    if (!trueModel) {
       return null;
+    }
 
-    const acc = ui.accordion();
+
+    const acc = ui.accordion('Peptides analysis panel');
     acc.root.style.width = '100%';
-    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}`));
+    const filterAndSelectionBs = trueModel.getVisibleSelection();
+    const filteredTitlePart = trueModel.df.filter.anyFalse ? ` among ${trueModel.df.filter.trueCount} filtered` :
+      '';
+    const getSelectionString = (selection: type.Selection): string => {
+      const selectedMonomerPositions: string[] = [];
+      for (const [pos, monomerList] of Object.entries(selection)) {
+        for (const monomer of monomerList) {
+          selectedMonomerPositions.push(`${pos}:${monomer}`);
+        }
+      }
+      return selectedMonomerPositions.join(', ');
+    };
+
+    // Logo Summary Table viewer selection overview
+    const trueLSTViewer = trueModel.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+    const selectionDescription: HTMLElement[] = [];
+    const selectedClusters: string = (trueLSTViewer === null ? [] :
+      trueLSTViewer.clusterSelection[CLUSTER_TYPE.ORIGINAL].concat(trueLSTViewer.clusterSelection[CLUSTER_TYPE.CUSTOM]))
+      .join(', ');
+    if (selectedClusters.length !== 0) {
+      selectionDescription.push(ui.h1('Logo summary table selection'));
+      selectionDescription.push(ui.divText(`Selected clusters: ${selectedClusters}`));
+    }
+
+    // Monomer-Position viewer selection overview
+    const trueMPViewer = trueModel.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
+    const selectedMonomerPositions = getSelectionString(trueMPViewer?.invariantMapSelection ?? {});
+    const selectedMutationCliffs = getSelectionString(trueMPViewer?.mutationCliffsSelection ?? {});
+    if (selectedMonomerPositions.length !== 0 || selectedMutationCliffs.length !== 0) {
+      selectionDescription.push(ui.h1('Monomer-Position viewer selection'));
+    }
+
+
+    if (selectedMonomerPositions.length !== 0) {
+      selectionDescription.push(ui.divText(`Selected monomer-positions: ${selectedMonomerPositions}`));
+    }
+
+
+    if (selectedMutationCliffs.length !== 0) {
+      selectionDescription.push(ui.divText(`Selected mutation cliffs pairs: ${selectedMutationCliffs}`));
+    }
+
+
+    // Most Potent Residues viewer selection overview
+    const trueMPRViewer = trueModel.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues | null;
+    const selectedMPRMonomerPositions = getSelectionString(trueMPRViewer?.mutationCliffsSelection ?? {});
+    if (selectedMPRMonomerPositions.length !== 0) {
+      selectionDescription.push(ui.h1('Most Potent Residues viewer selection'));
+      selectionDescription.push(ui.divText(`Selected monomer-positions: ${selectedMPRMonomerPositions}`));
+    }
+
+    // WebLogo selection overview
+    const selectedMonomers = getSelectionString(trueModel.webLogoSelection);
+    if (selectedMonomers.length !== 0) {
+      selectionDescription.push(ui.h1('WebLogo selection'));
+      selectionDescription.push(ui.divText(`Selected monomers: ${selectedMonomers}`));
+    }
+
+    const descritionsHost = ui.div(ui.divV(selectionDescription));
+    acc.addTitle(ui.divV([
+      ui.h1(`${filterAndSelectionBs.trueCount} selected rows${filteredTitlePart}`),
+      descritionsHost,
+    ], 'css-gap-small'));
+
     if (filterAndSelectionBs.anyTrue) {
       acc.addPane('Actions', () => {
         const newView = ui.label('New view');
         $(newView).addClass('d4-link-action');
         newView.onclick = (): string => trueModel.createNewView();
-        newView.onmouseover =
-          (ev): void => ui.tooltip.show('Creates a new view from current selection', ev.clientX + 5, ev.clientY + 5);
+        newView.onmouseover = (ev): void =>
+          ui.tooltip.show('Creates a new view from current selection', ev.clientX + 5, ev.clientY + 5);
+        if (trueLSTViewer === null) {
+          return ui.divV([newView]);
+        }
+
+
         const newCluster = ui.label('New cluster');
         $(newCluster).addClass('d4-link-action');
         newCluster.onclick = (): void => {
-          const lstViewer = trueModel.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
-          if (lstViewer === null)
+          if (trueLSTViewer === null) {
             throw new Error('Logo summary table viewer is not found');
-          lstViewer.clusterFromSelection();
+          }
+
+
+          trueLSTViewer.clusterFromSelection();
         };
-        newCluster.onmouseover =
-          (ev): void => ui.tooltip.show('Creates a new cluster from selection', ev.clientX + 5, ev.clientY + 5);
+        newCluster.onmouseover = (ev): void =>
+          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 = (): void => {
           const lstViewer = trueModel.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
-          if (lstViewer === null)
+          if (lstViewer === null) {
             throw new Error('Logo summary table viewer is not found');
+          }
+
+
           lstViewer.removeCluster();
         };
-        removeCluster.onmouseover =
-          (ev): void => ui.tooltip.show('Removes currently selected custom cluster', ev.clientX + 5, ev.clientY + 5);
-        removeCluster.style.visibility = trueModel.clusterSelection[CLUSTER_TYPE.CUSTOM].length === 0 ? 'hidden' : 'visible';
+        removeCluster.onmouseover = (ev): void =>
+          ui.tooltip.show('Removes currently selected custom cluster', ev.clientX + 5, ev.clientY + 5);
+        removeCluster.style.visibility = trueLSTViewer.clusterSelection[CLUSTER_TYPE.CUSTOM].length === 0 ? 'hidden' :
+          'visible';
+
         return ui.divV([newView, newCluster, removeCluster]);
+      }, true);
+    }
+
+    // Get the source of the bitset change and find viewers that share the same parameters as source
+    let requestSource: SARViewer | LogoSummaryTable | PeptidesSettings | null = trueModel.settings;
+    const viewers: (PeptideViewer | PeptidesSettings | null)[] = [trueMPViewer, trueMPRViewer, trueLSTViewer]
+      .filter((v) => {
+        if (v === null) {
+          return false;
+        }
+
+
+        if (v.type !== this.accordionSource) {
+          return true;
+        }
+
+
+        requestSource = v;
+        return false;
       });
+
+    if (requestSource === null) {
+      throw new Error('PeptidesError: Model is the source of accordion but is not initialized');
+    }
+
+
+    if (requestSource !== trueModel.settings) {
+      viewers.push(trueModel.settings);
+    }
+
+
+    const notEmpty = (v: PeptideViewer | PeptidesSettings | null): v is PeptideViewer | PeptidesSettings =>
+      v !== null && areParametersEqual(requestSource!, v) && (v !== trueModel.settings || trueModel.isInitialized);
+    const panelDataSources = viewers.filter(notEmpty);
+    panelDataSources.push(requestSource);
+    const combinedBitset: DG.BitSet | null = DG.BitSet.create(trueModel.df.rowCount);
+    for (const panelDataSource of panelDataSources) {
+      const bitset =
+        (panelDataSource === this.settings) ? getSelectionBitset(this.webLogoSelection, this.monomerPositionStats!) :
+          (panelDataSource instanceof LogoSummaryTable) ?
+            getSelectionBitset(panelDataSource.clusterSelection, panelDataSource.clusterStats) :
+            (panelDataSource instanceof SARViewer) ?
+              getSelectionBitset(panelDataSource.mutationCliffsSelection,
+                mutationCliffsToMaskInfo(panelDataSource.mutationCliffs ?? new Map(), trueModel.df.rowCount)) :
+              null;
+      if (bitset !== null) {
+        combinedBitset.or(bitset);
+      }
+
+
+      if (panelDataSource instanceof MonomerPosition) {
+        const invariantMapSelectionBitset = getSelectionBitset(panelDataSource.invariantMapSelection,
+          panelDataSource.monomerPositionStats);
+        if (invariantMapSelectionBitset !== null) {
+          combinedBitset.or(invariantMapSelectionBitset);
+        }
+      }
     }
-    const table = trueModel.df.filter.anyFalse ? trueModel.df.clone(trueModel.df.filter, null, true) : trueModel.df;
-    acc.addPane('Mutation Cliffs pairs', () => mutationCliffsWidget(trueModel.df, trueModel).root);
-    acc.addPane('Distribution', () => getDistributionWidget(table, trueModel).root);
-    acc.addPane('Selection', () => getSelectionWidget(trueModel.df, trueModel));
 
+    const sarViewer = requestSource as any as SARViewer | LogoSummaryTable;
+    if (requestSource !== trueModel.settings && !(sarViewer instanceof LogoSummaryTable) &&
+      sarViewer.mutationCliffs != null) {
+      // MC and Selection are left
+      acc.addPane('Mutation Cliffs pairs', () => mutationCliffsWidget(trueModel.df, {
+        mutationCliffs: sarViewer.mutationCliffs!,
+        mutationCliffsSelection: sarViewer.mutationCliffsSelection,
+        gridColumns: trueModel.analysisView.grid.columns,
+        sequenceColumnName: sarViewer.sequenceColumnName,
+        positionColumns: sarViewer.positionColumns,
+        activityCol: sarViewer.getScaledActivityColumn(),
+      }).root, true);
+    }
+    const isModelSource = requestSource === trueModel.settings;
+    const totalMonomerPositionSelection = isModelSource ? this.webLogoSelection :
+      (requestSource instanceof MonomerPosition) ? requestSource.invariantMapSelection : {};
+    const clusterSelection = (requestSource instanceof LogoSummaryTable) ? requestSource.clusterSelection :
+      trueLSTViewer?.clusterSelection ?? {};
+    acc.addPane('Distribution', () => getDistributionWidget(trueModel.df, {
+      peptideSelection: combinedBitset,
+      columns: isModelSource ? trueModel.settings!.columns ?? {} :
+        (requestSource as PeptideViewer).getAggregationColumns(),
+      activityCol: isModelSource ? trueModel.getScaledActivityColumn()! :
+        (requestSource as PeptideViewer).getScaledActivityColumn(),
+      monomerPositionSelection: totalMonomerPositionSelection,
+      clusterSelection: clusterSelection,
+      clusterColName: trueLSTViewer?.clustersColumnName,
+    }), true);
+    const areObjectsEqual = (o1?: AggregationColumns | null, o2?: AggregationColumns | null): boolean => {
+      if (o1 == null || o2 == null) {
+        return false;
+      }
+
+
+      for (const [key, value] of Object.entries(o1)) {
+        if (value !== o2[key]) {
+          return false;
+        }
+      }
+      return true;
+    };
+    acc.addPane('Selection', () => getSelectionWidget(trueModel.df, {
+      positionColumns: isModelSource ? trueModel.positionColumns! :
+        (requestSource as SARViewer | LogoSummaryTable).positionColumns,
+      columns: isModelSource ? trueModel.settings!.columns ?? {} :
+        (requestSource as SARViewer | LogoSummaryTable).getAggregationColumns(),
+      activityColumn: isModelSource ? trueModel.getScaledActivityColumn()! :
+        (requestSource as SARViewer | LogoSummaryTable).getScaledActivityColumn(),
+      gridColumns: trueModel.analysisView.grid.columns,
+      colorPalette: pickUpPalette(trueModel.df.getCol(isModelSource ? trueModel.settings!.sequenceColumnName :
+        (requestSource as SARViewer | LogoSummaryTable).sequenceColumnName)),
+      tableSelection: trueModel.getCombinedSelection(),
+      isAnalysis: trueModel.settings !== null && (isModelSource ||
+        areObjectsEqual(trueModel.settings.columns, (requestSource as PeptideViewer).getAggregationColumns())),
+    }), true);
     return acc;
   }
 
+  /**
+   * @param [isFiltered] - Whether to return filtered activity column
+   * @return - Scaled activity column
+   */
+  getScaledActivityColumn(isFiltered: boolean = false): DG.Column<number> | null {
+    const scaledActivityColumn = this.df.col(C.COLUMNS_NAMES.ACTIVITY);
+    if (isFiltered && scaledActivityColumn !== null) {
+      return DG.DataFrame.fromColumns([scaledActivityColumn]).clone(this.df.filter)
+        .getCol(scaledActivityColumn.name) as DG.Column<number>;
+    }
+    return scaledActivityColumn as DG.Column<number> | null;
+  }
+
+  /**
+   * Sets grid properties such as column semtypes, visibility, order, width, renderers and tooltips
+   */
   updateGrid(): void {
     this.joinDataFrames();
     this.createScaledCol();
-    // this.setWebLogoInteraction();
     this.webLogoBounds = {};
 
-    CR.setWebLogoRenderer(this.analysisView.grid, this);
+    const cellRendererOptions: CR.WebLogoCellRendererOptions = {
+      selectionCallback: (monomerPosition: type.SelectionItem, options: type.SelectionOptions): void =>
+        this.modifyWebLogoSelection(monomerPosition, options),
+      unhighlightCallback: (): void => this.unhighlight(),
+      colorPalette: () => pickUpPalette(this.df.getCol(this.settings!.sequenceColumnName)),
+      webLogoBounds: () => this.webLogoBounds,
+      cachedWebLogoTooltip: () => this.cachedWebLogoTooltip,
+      highlightCallback: (mp: type.SelectionItem, df: DG.DataFrame, mpStats: MonomerPositionStats): void =>
+        highlightMonomerPosition(mp, df, mpStats),
+      isSelectionTable: false,
+      headerSelectedMonomers: () => this.webLogoSelectedMonomers,
+    };
+    if (this.monomerPositionStats === null || this.positionColumns === null) {
+      throw new Error('PeptidesError: Could not updage grid: monomerPositionStats or positionColumns are null');
+    }
+
+
+    CR.setWebLogoRenderer(this.analysisView.grid, this.monomerPositionStats, this.positionColumns,
+      this.getScaledActivityColumn()!, cellRendererOptions);
     if (!this._layoutEventInitialized) {
       grok.events.onViewLayoutApplied.subscribe((layout) => {
-        if (layout.view.id === this.analysisView.id)
+        if (layout.view.id === this.analysisView.id) {
           this.updateGrid();
+        }
       });
       this._layoutEventInitialized = true;
     }
@@ -485,45 +639,22 @@ export class PeptidesModel {
     this.setGridProperties();
   }
 
-  initInvariantMapSelection(options: {notify?: boolean} = {}): void {
-    options.notify ??= true;
-
-    const tempSelection: type.Selection = {};
-    const positionColumns = this.positionColumns.toArray().map((col) => col.name);
-    for (const pos of positionColumns)
-      tempSelection[pos] = [];
-
-    if (options.notify)
-      this.invariantMapSelection = tempSelection;
-    else
-      this._invariantMapSelection = tempSelection;
-  }
-
-  initMutationCliffsSelection(options: {notify?: boolean} = {}): void {
-    options.notify ??= true;
-
-    const tempSelection: type.Selection = {};
-    const positionColumns = this.positionColumns.toArray().map((col) => col.name);
-    for (const pos of positionColumns)
-      tempSelection[pos] = [];
-
-    if (options.notify)
-      this.mutationCliffsSelection = tempSelection;
-    else
-      this._mutationCliffsSelection = tempSelection;
-  }
-
+  /**
+   * Splits sequences and adds position columns to this.df.
+   */
   joinDataFrames(): void {
     // append splitSeqDf columns to source table and make sure columns are not added more than once
     const name = this.df.name;
     const cols = this.df.columns;
-    const splitSeqDf = this.buildSplitSeqDf();
+    const splitSeqDf = splitAlignedSequences(this.df.getCol(this.settings!.sequenceColumnName));
     const positionColumns = splitSeqDf.columns.names();
     for (const colName of positionColumns) {
       let col = this.df.col(colName);
       const newCol = splitSeqDf.getCol(colName);
-      if (col !== null)
+      if (col !== null) {
         cols.remove(colName);
+      }
+
 
       const newColCat = newCol.categories;
       const newColData = newCol.getRawData();
@@ -535,143 +666,140 @@ export class PeptidesModel {
     this.df.name = name;
   }
 
+  /**
+   * Creates scaled activity column
+   */
   createScaledCol(): void {
     const sourceGrid = this.analysisView.grid;
-    const scaledCol = scaleActivity(this.df.getCol(this.settings.activityColumnName!), this.settings.scaling);
+    const scaledCol = scaleActivity(this.df.getCol(this.settings!.activityColumnName),
+      this.settings!.activityScaling);
     //TODO: make another func
-    this.df.columns.replace(C.COLUMNS_NAMES.ACTIVITY_SCALED, scaledCol);
+    this.df.columns.replace(COLUMNS_NAMES.ACTIVITY, scaledCol);
 
     sourceGrid.columns.setOrder([scaledCol.name]);
   }
 
-  initClusterSelection(options: {notify?: boolean} = {}): void {
-    options.notify ??= true;
-
-    const newClusterSelection = {} as type.Selection;
-    newClusterSelection[CLUSTER_TYPE.ORIGINAL] = [];
-    newClusterSelection[CLUSTER_TYPE.CUSTOM] = [];
-    if (options.notify)
-      this.clusterSelection = newClusterSelection;
-    else
-      this._clusterSelection = newClusterSelection;
-  }
-
-  highlightMonomerPosition(monomerPosition: type.SelectionItem): void {
-    const bitArray = new BitArray(this.df.rowCount);
-    if (monomerPosition.positionOrClusterType === C.COLUMNS_NAMES.MONOMER) {
-      const positionStats = Object.values(this.monomerPositionStats);
-      for (const posStat of positionStats) {
-        const monomerPositionStats = (posStat as PositionStats)[monomerPosition.monomerOrCluster];
-        if (monomerPositionStats ?? false)
-          bitArray.or(monomerPositionStats!.mask);
-      }
-    } else {
-      const monomerPositionStats = this.monomerPositionStats[monomerPosition.positionOrClusterType]![monomerPosition.monomerOrCluster];
-      if (monomerPositionStats ?? false)
-        bitArray.or(monomerPositionStats!.mask);
+  /**
+   * Resets rows highlighting
+   */
+  unhighlight(): void {
+    if (!this.isHighlighting) {
+      return;
     }
 
-    this.df.rows.highlight((i) => bitArray.getBit(i));
-    this.isHighlighting = true;
-  }
-
-  highlightCluster(cluster: type.SelectionItem): void {
-    const bitArray = this.clusterStats[cluster.positionOrClusterType as ClusterType][cluster.monomerOrCluster].mask;
-    this.df.rows.highlight((i) => bitArray.getBit(i));
-    this.isHighlighting = true;
-  }
 
-  unhighlight(): void {
-    if (!this.isHighlighting)
-      return;
     this.df.rows.highlight(null);
     this.isHighlighting = false;
   }
 
+  /**
+   * Sets tooltips to analysis grid
+   */
   setTooltips(): void {
     this.analysisView.grid.onCellTooltip((cell, x, y) => {
-      if (cell.isColHeader && cell.tableColumn!.semType === C.SEM_TYPES.MONOMER)
+      if (cell.isColHeader && cell.tableColumn?.semType === C.SEM_TYPES.MONOMER) {
         return true;
-      if (!(cell.isTableCell && cell.tableColumn!.semType === C.SEM_TYPES.MONOMER))
+      }
+
+
+      if (!(cell.isTableCell && cell.tableColumn?.semType === C.SEM_TYPES.MONOMER)) {
         return false;
+      }
+
 
       showMonomerTooltip(cell.cell.value, x, y);
       return true;
     });
   }
 
-  setBitsetCallback(): void {
-    if (this.isBitsetChangedInitialized)
-      return;
-    const selection = this.df.selection;
-    const filter = this.df.filter;
-
-    const getCombinedSelection = (): DG.BitSet => {
-      const combinedSelection = new BitArray(this.df.rowCount, false);
-      // Invariant map selection
-      for (const [position, monomerList] of Object.entries(this.invariantMapSelection)) {
+  /**
+   * Builds total analysis selection that comes from viewers and components
+   * @return - Total analysis selection
+   */
+  getCombinedSelection(): DG.BitSet {
+    const combinedSelection = new BitArray(this.df.rowCount, false);
+    // Invariant map selection
+    const addInvariantMapSelection = (selection: type.Selection, stats: MonomerPositionStats | null): void => {
+      for (const [position, monomerList] of Object.entries(selection)) {
         for (const monomer of monomerList) {
-          const monomerPositionStats = this.monomerPositionStats[position]![monomer]!;
+          const positionStats = stats?.[position];
+          if (typeof positionStats === 'undefined') {
+            continue;
+          }
+
+
+          const monomerPositionStats = positionStats[monomer];
+          if (typeof monomerPositionStats === 'undefined') {
+            continue;
+          }
+
+
           combinedSelection.or(monomerPositionStats.mask);
         }
       }
+    };
 
-      // Mutation cliffs selection
-      for (const [position, monomerList] of Object.entries(this.mutationCliffsSelection)) {
+    addInvariantMapSelection(this.webLogoSelection, this.monomerPositionStats);
+    const mpViewer = this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
+    addInvariantMapSelection(mpViewer?.invariantMapSelection ?? {}, mpViewer?.monomerPositionStats ?? null);
+
+    // Mutation cliffs selection
+    const addMutationCliffsSelection = (selection: type.Selection, mc: type.MutationCliffs | null): void => {
+      for (const [position, monomerList] of Object.entries(selection)) {
         for (const monomer of monomerList) {
-          const substitutions = this.mutationCliffs?.get(monomer)?.get(position) ?? null;
-          if (substitutions === null)
+          const substitutions = mc?.get(monomer)?.get(position) ?? null;
+          if (substitutions === null) {
             continue;
+          }
+
+
           for (const [key, value] of substitutions.entries()) {
             combinedSelection.setTrue(key);
-            for (const v of value)
+            for (const v of value) {
               combinedSelection.setTrue(v);
+            }
           }
         }
       }
+    };
+    addMutationCliffsSelection(mpViewer?.mutationCliffsSelection ?? {}, mpViewer?.mutationCliffs ?? null);
 
-      // Cluster selection
-      for (const clustType of Object.keys(this.clusterSelection)) {
-        for (const clust of this.clusterSelection[clustType]) {
-          const clusterStats = this.clusterStats[clustType as CLUSTER_TYPE][clust]!;
-          combinedSelection.or(clusterStats.mask);
-        }
+    const mprViewer = this.findViewer(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues | null;
+    addMutationCliffsSelection(mprViewer?.mutationCliffsSelection ?? {}, mprViewer?.mutationCliffs ?? null);
+
+    // Cluster selection
+    const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+    for (const clustType of Object.keys(lstViewer?.clusterSelection ?? {})) {
+      for (const clust of lstViewer!.clusterSelection[clustType] ?? []) {
+        const clusterStats = lstViewer!.clusterStats[clustType as CLUSTER_TYPE][clust];
+        combinedSelection.or(clusterStats.mask);
       }
+    }
 
-      return DG.BitSet.fromBytes(combinedSelection.buffer.buffer, combinedSelection.length);
-    };
+    return DG.BitSet.fromBytes(combinedSelection.buffer.buffer, combinedSelection.length);
+  }
+
+
+  /**
+   * Sets selection and filter changed callbacks
+   */
+  setBitsetCallback(): void {
+    if (this.isBitsetChangedInitialized) {
+      return;
+    }
 
-    const getLatestSelection = (): DG.BitSet => {
-      if (this.latestSelectionItem === null)
-        return getCombinedSelection();
-      if (this.latestSelectionItem.kind === SELECTION_MODE.INVARIANT_MAP) {
-        const monomerPositionStats = this.monomerPositionStats[this.latestSelectionItem.positionOrClusterType]![this.latestSelectionItem.monomerOrCluster]!;
-        return DG.BitSet.fromBytes(monomerPositionStats.mask.buffer.buffer, monomerPositionStats.mask.length);
-      } else if (this.latestSelectionItem.kind === SELECTION_MODE.MUTATION_CLIFFS) {
-        const substitutions = this.mutationCliffs?.get(this.latestSelectionItem.monomerOrCluster)?.get(this.latestSelectionItem.positionOrClusterType) ?? null;
-        if (substitutions === null)
-          throw new Error(`Couldn't find substitutions for ${this.latestSelectionItem.monomerOrCluster} at ${this.latestSelectionItem.positionOrClusterType}`);
-        const latestSelection = new BitArray(this.df.rowCount, false);
-        for (const [key, value] of substitutions.entries()) {
-          latestSelection.setTrue(key);
-          for (const v of value)
-            latestSelection.setTrue(v);
-        }
-        return DG.BitSet.fromBytes(latestSelection.buffer.buffer, latestSelection.length);
-      } else if (this.latestSelectionItem.kind === 'Cluster') {
-        const clusterStats = this.clusterStats[this.latestSelectionItem.positionOrClusterType as CLUSTER_TYPE][this.latestSelectionItem.monomerOrCluster]!;
-        return DG.BitSet.fromBytes(clusterStats.mask.buffer.buffer, clusterStats.mask.length);
-      }
-      throw new Error(`Unknown selection kind: ${this.latestSelectionItem.kind}`);
-    };
+
+    const selection = this.df.selection;
+    const filter = this.df.filter;
 
     const showAccordion = (): void => {
       const acc = this.createAccordion();
-      if (acc === null)
+      if (acc === null) {
         return;
+      }
+
+
       grok.shell.o = acc.root;
-      for (const pane of acc.panes)
-        pane.expanded = true;
     };
 
     selection.onChanged.subscribe(() => {
@@ -679,87 +807,163 @@ export class PeptidesModel {
         this.controlFire = false;
         return;
       }
-      if (!this.isUserChangedSelection)
-        selection.copyFrom(getLatestSelection(), false);
-      showAccordion();
-      this.isUserChangedSelection = true;
+      try {
+        if (!this.isUserChangedSelection) {
+          selection.copyFrom(this.getCombinedSelection(), false);
+        }
+      } catch (e) {
+        _package.logger.debug('Peptides: Error on selection changed');
+        _package.logger.debug(e as string);
+      } finally {
+        showAccordion();
+      }
     });
 
     filter.onChanged.subscribe(() => {
-      if (this.controlFire) {
-        this.controlFire = false;
-        return;
-      }
-      const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
-      if (lstViewer !== null && typeof lstViewer.model !== 'undefined') {
-        lstViewer.createLogoSummaryTableGrid();
-        lstViewer.render();
+      try {
+        if (this.controlFire) {
+          this.controlFire = false;
+          return;
+        }
+        const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+        if (lstViewer !== null && typeof lstViewer.model !== 'undefined') {
+          lstViewer.createLogoSummaryTableGrid();
+          lstViewer.render();
+        }
+      } catch (e) {
+        _package.logger.debug('Peptides: Error on filter changed');
+        _package.logger.debug(e as string);
+      } finally {
+        showAccordion();
       }
-      showAccordion();
     });
 
     this.isBitsetChangedInitialized = true;
   }
 
-  fireBitsetChanged(fireFilterChanged: boolean = false): void {
+  /**
+   * Fires bitset changed event and rebuilds accordion in context panel
+   * @param source - Source of bitset changed event
+   * @param fireFilterChanged - Whether to fire filter changed event
+   */
+  fireBitsetChanged(source: VIEWER_TYPE | null, fireFilterChanged: boolean = false): void {
+    this.accordionSource = source;
+    if (!this.isBitsetChangedInitialized) {
+      this.setBitsetCallback();
+    }
+
+
     this.isUserChangedSelection = false;
     this.df.selection.fireChanged();
-    if (fireFilterChanged)
+    if (fireFilterChanged) {
       this.df.filter.fireChanged();
+    }
+
 
     // Fire bitset changed event again to update UI
     this.controlFire = true;
     this.df.selection.fireChanged();
-    if (fireFilterChanged)
+    if (fireFilterChanged) {
       this.df.filter.fireChanged();
+    }
+
 
-    this.headerSelectedMonomers = calculateSelected(this.df);
+    this.isUserChangedSelection = true;
+    this.webLogoSelectedMonomers = calculateSelected(this.df);
   }
 
+  /**
+   * Sets grid properties such
+   * @param props - Grid properties
+   */
   setGridProperties(props?: DG.IGridLookSettings): void {
     const sourceGrid = this.analysisView.grid;
     const sourceGridProps = sourceGrid.props;
     sourceGridProps.allowColSelection = props?.allowColSelection ?? false;
     sourceGridProps.allowEdit = props?.allowEdit ?? false;
+    sourceGridProps.showReadOnlyNotifications = props?.showReadOnlyNotifications ?? false;
     sourceGridProps.showCurrentRowIndicator = props?.showCurrentRowIndicator ?? false;
-    this.df.temp[C.EMBEDDING_STATUS] = false;
-    const positionCols = this.positionColumns.toArray();
+    const positionCols = this.positionColumns;
+    if (positionCols === null) {
+      throw new Error('PeptidesError: Could not set grid properties: positionColumns are null');
+    }
+
+
     let maxWidth = 10;
     const canvasContext = sourceGrid.canvas.getContext('2d');
+    if (canvasContext === null) {
+      throw new Error('PeptidesError: Could not set grid properties: canvas context is null');
+    }
+
+
     for (const positionCol of positionCols) {
       // Longest category
       const maxCategory = monomerToShort(positionCol.categories.reduce((a, b) => a.length > b.length ? a : b), 6);
       // Measure text width of longest category
-      const width = Math.ceil(canvasContext!.measureText(maxCategory).width);
+      const width = Math.ceil(canvasContext.measureText(maxCategory).width);
       maxWidth = Math.max(maxWidth, width);
     }
+
+    const posCols = positionCols.map((col) => col.name);
+    for (let colIdx = 1; colIdx < this.analysisView.grid.columns.length; ++colIdx) {
+      const gridCol = this.analysisView.grid.columns.byIndex(colIdx);
+      if (gridCol === null) {
+        throw new Error(`PeptidesError: Could not get analysis view: grid column with index '${colIdx}' is null`);
+      } else if (gridCol.column === null) {
+        throw new Error(`PeptidesError: Could not get analysis view: grid column with index '${colIdx}' has null ` +
+          `column`);
+      }
+      gridCol.visible = posCols.includes(gridCol.column.name) || (gridCol.column.name === C.COLUMNS_NAMES.ACTIVITY);
+    }
+
     setTimeout(() => {
-      for (const positionCol of positionCols)
-        sourceGrid.col(positionCol.name)!.width = maxWidth + 15;
+      for (const positionCol of positionCols) {
+        const gridCol = sourceGrid.col(positionCol.name);
+        if (gridCol === null) {
+          throw new Error(`PeptidesError: Could not set column width: grid column '${positionCol.name}' is null`);
+        }
+
+
+        gridCol.width = maxWidth + 15;
+      }
     }, 100);
   }
 
+  /**
+   * Closes peptides viewer
+   * @param viewerType - Viewer type to close
+   */
   closeViewer(viewerType: VIEWER_TYPE): void {
     const viewer = this.findViewer(viewerType);
     viewer?.detach();
     viewer?.close();
   }
 
+  /**
+   * Finds viewer node in the analysis view
+   * @param viewerType - Viewer type to find
+   * @return - Viewer node or null if not found
+   */
   findViewerNode(viewerType: VIEWER_TYPE): DG.DockNode | null {
     for (const node of this.analysisView.dockManager.rootNode.children) {
-      if (node.container.containerElement.innerHTML.includes(viewerType))
+      if (node.container.containerElement.innerHTML.includes(viewerType)) {
         return node;
+      }
     }
     return null;
   }
 
+  /**
+   * Adds Dendrogram viewer to the analysis view
+   * @returns
+   */
   async addDendrogram(): Promise<void> {
     const pi = DG.TaskBarProgressIndicator.create('Calculating distance matrix...');
     try {
-      const pepColValues: string[] = this.df.getCol(this.settings.sequenceColumnName!).toList();
+      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 treeHelper: ITreeHelper = getTreeHelperInstance()!;
+      const treeHelper: ITreeHelper = getTreeHelperInstance();
       const treeNode = await treeHelper.hierarchicalClusteringByDistance(this._dm, 'ward');
 
       this.df.setTag(treeTAGS.NEWICK, treeHelper.toNewick(treeNode));
@@ -775,10 +979,17 @@ export class PeptidesModel {
     }
   }
 
-  /** Class initializer */
-  init(): void {
-    if (this.isInitialized)
+  /**
+   * Analysis initializer
+   * @param settings - Analysis settings
+   */
+  init(settings: type.PeptidesSettings): void {
+    if (this.isInitialized) {
       return;
+    }
+
+
+    this.settings = settings;
     this.isInitialized = true;
 
     if (!this.isRibbonSet && this.df.getTag(C.TAGS.MULTIPLE_VIEWS) !== '1') {
@@ -790,88 +1001,131 @@ export class PeptidesModel {
     }
 
     this.subs.push(grok.events.onAccordionConstructed.subscribe((acc) => {
-      if (!(grok.shell.o instanceof DG.SemanticValue || (grok.shell.o instanceof DG.Column && this.df.columns.toList().includes(grok.shell.o))))
+      if (!(grok.shell.o instanceof DG.SemanticValue || (grok.shell.o instanceof DG.Column &&
+        this.df.columns.toList().includes(grok.shell.o)))) {
         return;
+      }
 
-      const actionsPane = acc.getPane('Actions');
 
+      const actionsPane = acc.getPane('Actions');
       const actionsHost = $(actionsPane.root).find('.d4-flex-col');
       const calculateIdentity = ui.label('Calculate identity');
       calculateIdentity.classList.add('d4-link-action');
-      ui.tooltip.bind(calculateIdentity, 'Adds a column with fractions of matching monomers against sequence in the current row');
+      ui.tooltip.bind(calculateIdentity,
+        'Adds a column with fractions of matching monomers against sequence in the current row');
       calculateIdentity.onclick = (): void => {
-        const seqCol = this.df.getCol(this.settings.sequenceColumnName!);
-        calculateScores(this.df, seqCol, seqCol.get(this.df.currentRowIdx), SCORE.IDENTITY);
+        const seqCol = this.df.getCol(this.settings!.sequenceColumnName);
+        calculateScores(this.df, seqCol, seqCol.get(this.df.currentRowIdx), SCORE.IDENTITY)
+          .then((col: DG.Column<number>) => col.setTag(C.TAGS.IDENTITY_TEMPLATE, seqCol.get(this.df.currentRowIdx)))
+          .catch((e) => _package.logger.debug(e));
       };
       actionsHost.append(ui.span([calculateIdentity], 'd4-markdown-row'));
 
       const calculateSimilarity = ui.label('Calculate similarity');
       calculateSimilarity.classList.add('d4-link-action');
-      ui.tooltip.bind(calculateSimilarity, 'Adds a column with sequence similarity scores against sequence in the current row');
+      ui.tooltip.bind(calculateSimilarity,
+        'Adds a column with sequence similarity scores against sequence in the current row');
       calculateSimilarity.onclick = (): void => {
-        const seqCol = this.df.getCol(this.settings.sequenceColumnName!);
-        calculateScores(this.df, seqCol, seqCol.get(this.df.currentRowIdx), SCORE.SIMILARITY);
+        const seqCol = this.df.getCol(this.settings!.sequenceColumnName);
+        calculateScores(this.df, seqCol, seqCol.get(this.df.currentRowIdx), SCORE.SIMILARITY)
+          .then((col: DG.Column<number>) => col.setTag(C.TAGS.SIMILARITY_TEMPLATE, seqCol.get(this.df.currentRowIdx)))
+          .catch((e) => _package.logger.debug(e));
       };
       actionsHost.append(ui.span([calculateSimilarity], 'd4-markdown-row'));
     }));
 
     this.subs.push(grok.events.onViewRemoved.subscribe((view) => {
-      if (view.id === this.analysisView.id)
+      if (view.id === this.analysisView.id) {
         this.subs.forEach((v) => v.unsubscribe());
+      }
+
+
       grok.log.debug(`Peptides: view ${view.name} removed`);
     }));
     this.subs.push(grok.events.onTableRemoved.subscribe((table: DG.DataFrame) => {
-      if (table.id === this.df.id)
+      if (table.id === this.df.id) {
         this.subs.forEach((v) => v.unsubscribe());
+      }
+
+
       grok.log.debug(`Peptides: table ${table.name} removed`);
     }));
     this.subs.push(grok.events.onProjectClosed.subscribe((project: DG.Project) => {
-      if (project.id === grok.shell.project.id)
+      if (project.id === grok.shell.project.id) {
         this.subs.forEach((v) => v.unsubscribe());
+      }
+
+
       grok.log.debug(`Peptides: project ${project.name} closed`);
     }));
 
-    this.fireBitsetChanged(true);
-    if (typeof this.settings.targetColumnName === 'undefined')
-      this.updateMutationCliffs();
+    this.fireBitsetChanged(null, true);
 
     this.analysisView.grid.invalidate();
   }
 
+  /**
+   * Finds viewer by type
+   * @param viewerType - Viewer type to find
+   * @return - Viewer or null if not found
+   */
   findViewer(viewerType: VIEWER_TYPE): DG.Viewer | null {
     return wu(this.analysisView.viewers).find((v) => v.type === viewerType) || null;
   }
 
-  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;
+  /**
+   * Adds Logo Summary Table viewer to the analysis view
+   * @param [viewerProperties] - Viewer properties
+   */
+  async addLogoSummaryTable(viewerProperties?: ILogoSummaryTable): Promise<void> {
+    viewerProperties ??= {
+      sequenceColumnName: this.settings!.sequenceColumnName,
+      clustersColumnName: wu(this.df.columns.categorical).next().value,
+      activityColumnName: this.settings!.activityColumnName,
+      activityScaling: this.settings!.activityScaling,
+    };
+    const logoSummaryTable = await this.df.plot
+      .fromType(VIEWER_TYPE.LOGO_SUMMARY_TABLE, viewerProperties) 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();
+
     logoSummaryTable.viewerGrid.invalidate();
   }
 
-  async addMonomerPosition(): Promise<void> {
-    const monomerPosition = await this.df.plot.fromType(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition;
+  /**
+   * Adds Monomer-Position viewer to the analysis view
+   * @param [viewerProperties] - Viewer properties
+   */
+  async addMonomerPosition(viewerProperties?: ISARViewer): Promise<void> {
+    viewerProperties ??= {
+      maxMutations: 1,
+      activityScaling: this.settings!.activityScaling,
+      activityColumnName: this.settings!.activityColumnName,
+      sequenceColumnName: this.settings!.sequenceColumnName,
+      minActivityDelta: 0,
+    };
+    const monomerPosition = await this.df.plot
+      .fromType(VIEWER_TYPE.MONOMER_POSITION, viewerProperties) as MonomerPosition;
     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];
     dm.dock(monomerPosition, dockType, refNode, VIEWER_TYPE.MONOMER_POSITION, ratio);
-    if (typeof this.settings.targetColumnName !== 'undefined') {
-      const target = monomerPosition.getProperty(MONOMER_POSITION_PROPERTIES.TARGET)!;
-      const choices = this.df.getCol(this.settings.targetColumnName!).categories;
-      target.choices = choices;
-      target.set(monomerPosition, choices[0]);
-    }
   }
 
-  async addMostPotentResidues(): Promise<void> {
+  /**
+   * Adds Most Potent Residues viewer to the analysis view
+   * @param [viewerProperties] - Viewer properties
+   */
+  async addMostPotentResidues(viewerProperties?: ISARViewer): Promise<void> {
+    viewerProperties ??= {
+      activityScaling: this.settings!.activityScaling,
+      activityColumnName: this.settings!.activityColumnName,
+      sequenceColumnName: this.settings!.sequenceColumnName,
+      minActivityDelta: 0,
+      maxMutations: 1,
+    };
     const mostPotentResidues =
-      await this.df.plot.fromType(VIEWER_TYPE.MOST_POTENT_RESIDUES) as MostPotentResidues;
+      await this.df.plot.fromType(VIEWER_TYPE.MOST_POTENT_RESIDUES, viewerProperties) 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] :
@@ -879,89 +1133,132 @@ export class PeptidesModel {
     dm.dock(mostPotentResidues, dockType, refNode, VIEWER_TYPE.MOST_POTENT_RESIDUES, ratio);
   }
 
-  addNewCluster(clusterName: string): void {
-    const newClusterCol = DG.Column.fromBitSet(clusterName, this.getCompoundBitset());
-    newClusterCol.setTag(C.TAGS.CUSTOM_CLUSTER, '1');
-    newClusterCol.setTag(C.TAGS.ANALYSIS_COL, `${true}`);
-    this.df.columns.add(newClusterCol);
-    this.analysisView.grid.col(newClusterCol.name)!.visible = false;
-  }
-
+  /**
+   * Creates new view from analysis dataframe selection, and adds LogoSummaryTable to it
+   * @return - New view id
+   */
   createNewView(): string {
-    const rowMask = this.getCompoundBitset();
-    const newDfId = uuid.v4();
-
+    const rowMask = this.getVisibleSelection();
     const newDf = this.df.clone(rowMask);
-    for (const [tag, value] of newDf.tags)
+    for (const [tag, value] of newDf.tags) {
       newDf.setTag(tag, tag === C.TAGS.SETTINGS ? value : '');
+    }
+
 
     newDf.name = 'Peptides Multiple Views';
     newDf.setTag(C.TAGS.MULTIPLE_VIEWS, '1');
-    newDf.setTag(C.TAGS.UUID, newDfId);
 
     const view = grok.shell.addTableView(newDf);
-    view.addViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE);
-
-    return newDfId;
-  }
-
-  modifyInvariantMapSelection(monomerPosition: type.SelectionItem, options: type.SelectionOptions = {shiftPressed: false, ctrlPressed: false}, notify: boolean = true): void {
-    if (notify)
-      this.invariantMapSelection = this.modifySelection(this.invariantMapSelection, monomerPosition, options);
-    else
-      this._invariantMapSelection = this.modifySelection(this._invariantMapSelection, monomerPosition, options);
-  }
-
-  modifyMutationCliffsSelection(monomerPosition: type.SelectionItem, options: type.SelectionOptions = {shiftPressed: false, ctrlPressed: false}, notify: boolean = true): void {
-    if (notify)
-      this.mutationCliffsSelection = this.modifySelection(this.mutationCliffsSelection, monomerPosition, options);
-    else
-      this._mutationCliffsSelection = this.modifySelection(this._mutationCliffsSelection, monomerPosition, options);
-  }
-
-  modifyClusterSelection(cluster: type.SelectionItem, options: type.SelectionOptions = {shiftPressed: false, ctrlPressed: false}, notify: boolean = true): void {
-    if (notify)
-      this.clusterSelection = this.modifySelection(this.clusterSelection, cluster, options);
-    else
-      this._clusterSelection = this.modifySelection(this._clusterSelection, cluster, options);
-  }
-
-  modifySelection(selection: type.Selection, clusterOrMonomerPosition: type.SelectionItem, options: type.SelectionOptions): type.Selection {
-    const monomerList = selection[clusterOrMonomerPosition.positionOrClusterType];
-    const monomerIndex = monomerList.indexOf(clusterOrMonomerPosition.monomerOrCluster);
-    if (options.shiftPressed && options.ctrlPressed) {
-      if (monomerIndex !== -1)
-        monomerList.splice(monomerIndex, 1);
-    } else if (options.ctrlPressed) {
-      if (monomerIndex === -1)
-        monomerList.push(clusterOrMonomerPosition.monomerOrCluster);
-      else
-        monomerList.splice(monomerIndex, 1);
-    } else if (options.shiftPressed) {
-      if (monomerIndex === -1)
-        monomerList.push(clusterOrMonomerPosition.monomerOrCluster);
-    } else {
-      const selectionKeys = Object.keys(selection);
-      selection = {};
-      for (const posOrClustType of selectionKeys) {
-        selection[posOrClustType] = [];
-        if (posOrClustType === clusterOrMonomerPosition.positionOrClusterType)
-          selection[posOrClustType].push(clusterOrMonomerPosition.monomerOrCluster);
-      }
+    const lstViewer = this.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable | null;
+    if (lstViewer != null) {
+      view.addViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE, {
+        [`${LST_PROPERTIES.SEQUENCE}${COLUMN_NAME}`]: lstViewer.sequenceColumnName,
+        [`${LST_PROPERTIES.ACTIVITY}${COLUMN_NAME}`]: lstViewer.activityColumnName,
+        [LST_PROPERTIES.ACTIVITY_SCALING]: lstViewer.activityScaling,
+        [LST_PROPERTIES.WEB_LOGO_MODE]: lstViewer.webLogoMode,
+        [LST_PROPERTIES.MEMBERS_RATIO_THRESHOLD]: lstViewer.membersRatioThreshold,
+        [`${LST_PROPERTIES.CLUSTERS}${COLUMN_NAME}`]: lstViewer.clustersColumnName,
+      });
     }
-    return selection;
+
+    return newDf.getTag(DG.TAGS.ID)!;
   }
 
+  /**
+   * Adds Sequence Space viewer to the analysis view
+   */
   async addSequenceSpace(): Promise<void> {
-    const seqSpaceParams: {table: DG.DataFrame, molecules: DG.Column, methodName: DimReductionMethods,
-      similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames, plotEmbeddings: boolean,
-      sparseMatrixThreshold?: number, options?: (IUMAPOptions | ITSNEOptions) & Options} =
-      {table: this.df, molecules: this.df.getCol(this.settings.sequenceColumnName!),
-        methodName: DimReductionMethods.UMAP, similarityMetric: MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE,
-        plotEmbeddings: true, sparseMatrixThreshold: 0.3, options: {'bypassLargeDataWarning': true}};
-    const seqSpaceViewer: DG.ScatterPlotViewer | undefined = await grok.functions.call('Bio:sequenceSpaceTopMenu', seqSpaceParams);
-    if (!(seqSpaceViewer instanceof DG.ScatterPlotViewer))
+    if (this._sequenceSpaceViewer !== null) {
+      try {
+        this._sequenceSpaceViewer?.detach();
+        this._sequenceSpaceViewer?.close();
+      } catch (_) {}
+    }
+    if (this._sequenceSpaceCols.length !== 0)
+      this._sequenceSpaceCols.forEach((col) => this.df.columns.remove(col));
+
+    this._sequenceSpaceCols = [];
+    let seqCol = this.df.getCol(this.settings!.sequenceColumnName!);
+    const uh = UnitsHandler.getOrCreate(seqCol);
+    const isHelm = uh.isHelm();
+    if (isHelm) {
+      try {
+        grok.shell.warning('Column is in HELM notation. Sequences space will linearize sequences from position 0 ' +
+          'prior to analysis');
+        const linearCol = uh.convert(NOTATION.SEPARATOR, '/');
+        const newName = this.df.columns.getUnusedName(`Separator(${seqCol.name})`);
+        linearCol.name = newName;
+        this.df.columns.add(linearCol, true);
+        this.analysisView.grid.col(newName)!.visible = false;
+        seqCol = linearCol;
+      } catch (e) {
+        grok.shell.error('Error on converting HELM notation to linear notation');
+        grok.shell.error(e as string);
+        return;
+      }
+    }
+    const seqSpaceSettings = this.settings?.sequenceSpaceParams ?? new type.SequenceSpaceParams();
+    const seqSpaceParams: {
+      table: DG.DataFrame,
+      molecules: DG.Column,
+      methodName: DimReductionMethods,
+      similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames,
+      plotEmbeddings: boolean,
+      sparseMatrixThreshold?: number,
+      clusterEmbeddings?: boolean,
+      options?: (IUMAPOptions | ITSNEOptions) & Options
+    } =
+      {
+        table: this.df,
+        molecules: seqCol,
+        methodName: DimReductionMethods.UMAP,
+        similarityMetric: seqSpaceSettings.distanceF,
+        plotEmbeddings: true,
+        sparseMatrixThreshold: 0.3,
+        options: {'bypassLargeDataWarning': true, dbScanEpsilon: seqSpaceSettings.epsilon, dbScanMinPts: seqSpaceSettings.minPts,
+        preprocessingFuncArgs: {gapOpen: seqSpaceSettings.gapOpen, gapExtend: seqSpaceSettings.gapExtend, fingerprintType: seqSpaceSettings.fingerprintType}},
+        clusterEmbeddings: seqSpaceSettings.clusterEmbeddings,
+      };
+
+    // Use counter to unsubscribe when 2 columns are hidden
+    let counter = 0;
+    const addedColCount = seqSpaceSettings.clusterEmbeddings ? 3 : 2;
+    const columnAddedSub = this.df.onColumnsAdded.subscribe((colArgs: DG.ColumnsArgs) => {
+      for (const col of colArgs.columns) {
+        if (col.name.startsWith('Embed_') || ( seqSpaceSettings.clusterEmbeddings && col.name.toLowerCase().startsWith('cluster'))) {
+          const gridCol = this.analysisView.grid.col(col.name);
+          if (gridCol == null) {
+            continue;
+          }
+          gridCol.visible = false;
+          this._sequenceSpaceCols.push(col.name);
+          counter++;
+        }
+      }
+      if (counter === addedColCount) {
+        columnAddedSub.unsubscribe();
+      }
+    });
+
+    const seqSpaceViewer: DG.ScatterPlotViewer | undefined =
+      await grok.functions.call('Bio:sequenceSpaceTopMenu', seqSpaceParams);
+    if (!(seqSpaceViewer instanceof DG.ScatterPlotViewer)) {
       return;
-    seqSpaceViewer.props.colorColumnName = C.COLUMNS_NAMES.ACTIVITY_SCALED;
+    }
+
+    if (!seqSpaceSettings.clusterEmbeddings) { // color by activity if clusters are not automatically generated.
+      seqSpaceViewer.props.colorColumnName = this.getScaledActivityColumn()!.name;
+    }
+    seqSpaceViewer.props.showXSelector = false;
+    seqSpaceViewer.props.showYSelector = false;
+    this._sequenceSpaceViewer = seqSpaceViewer;
+    seqSpaceViewer.onContextMenu.subscribe((menu) => {
+      try {
+        menu.item('Modify Sequence space parameters', () => {
+          getSettingsDialog(this);
+        });
+      } catch (e) {
+      }
+    });
   }
 }