@datagrok/peptides 1.17.0 → 1.17.1

package/src/widgets/distribution.ts

@@ -1,78 +1,98 @@
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-
-import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
 
 import $ from 'cash-dom';
 
 import * as C from '../utils/constants';
-import {getAggregatedColumnValues, getStats, Stats} from '../utils/statistics';
-import {PeptidesModel} from '../model';
-import {getDistributionPanel, getDistributionTable} from '../utils/misc';
-
-export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
-  if (!table.selection.anyTrue)
-    return new DG.Widget(ui.divText('No distribution'));
-
-  const activityCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY);
-  const rowCount = activityCol.length;
-
-  // const setDefaultProperties = (input: DG.InputBase): void => {
-  //   input.enabled = !model.isMutationCliffsSelectionEmpty;
-  //   $(input.root).find('.ui-input-editor').css('margin', '0px');
-  //   $(input.root).find('.ui-input-description').css('padding', '0px').css('padding-left', '5px');
-  //   $(input.captionLabel).addClass('ui-label-right');
-  // };
-  //
-  // let defaultValuePos = model.splitByPos;
-  // let defaultValueMonomer = model.splitByMonomer;
-  // if (!model.isClusterSelectionEmpty && model.isMutationCliffsSelectionEmpty) {
-  //   defaultValuePos = false;
-  //   defaultValueMonomer = false;
-  // }
-
-  const distributionHost = ui.div([], 'd4-flex-wrap');
-
-  const updateDistributionHost = (): void => {
-    const res: HTMLDivElement[] = [];
-    if (!table.selection.anyTrue)
-      res.push(ui.divText('No distribution'));
-    else {
-      const hist = getActivityDistribution(getDistributionTable(activityCol, model.df.selection, model.getCombinedSelection()));
-      const bitArray = BitArray.fromString(table.selection.toBinaryString());
-      const mask = DG.BitSet.create(rowCount,
-        bitArray.allFalse || bitArray.allTrue ? (_): boolean => true : (i): boolean => bitArray.getBit(i));
-      const aggregatedColMap = getAggregatedColumnValues(model.df, model.settings.columns!, {filterDf: true, mask});
-      const stats = bitArray.allFalse || bitArray.allTrue ?
-        {count: rowCount, pValue: null, meanDifference: 0, ratio: 1, mask: bitArray, mean: activityCol.stats.avg} :
-        getStats(activityCol.getRawData(), bitArray);
-      const tableMap = getStatsTableMap(stats);
-      const resultMap: { [key: string]: any } = {...tableMap, ...aggregatedColMap};
-      const distributionRoot = getDistributionPanel(hist, resultMap);
-      $(distributionRoot).addClass('d4-flex-col');
-
-      res.push(distributionRoot);
-    }
+import {AggregationColumns, getAggregatedColumnValues, getStats, StatsItem} from '../utils/statistics';
+import {DistributionLabelMap, getDistributionPanel, getDistributionTable, SPLIT_CATEGORY} from '../utils/misc';
+import {SARViewer} from '../viewers/sar-viewer';
+import {CLUSTER_TYPE, LogoSummaryTable} from '../viewers/logo-summary';
+import BitArray from '@datagrok-libraries/utils/src/bit-array';
+import {Selection} from '../utils/types';
+
+export type DistributionItemOptions = {
+  peptideSelection: DG.BitSet, columns: AggregationColumns, clusterColName?: string,
+  activityCol: DG.Column<number>, monomerPositionSelection: Selection, clusterSelection: Selection,
+};
+
+export enum DISTRIBUTION_CATEGORIES_KEYS {
+  SEPARATE_MONOMERS = 'separateMonomers',
+  SEPARATE_POSITIONS = 'separatePositions',
+  SEPARATE_CLUSTERS = 'separateClusters',
+}
+
+const general = 'general';
+const key2category = (key: DISTRIBUTION_CATEGORIES_KEYS | typeof general): string => {
+  if (key === general)
+    return 'General';
+
+
+  return key.substring(8);
+};
+export type PeptideViewer = SARViewer | LogoSummaryTable;
+
+
+/**
+ * Builds Distribution panel
+ * @param table - Dataframe with peptides
+ * @param options - Distribution options
+ * @return - Distribution panel
+ */
+export function getDistributionWidget(table: DG.DataFrame, options: DistributionItemOptions): HTMLDivElement {
+  const mask = table.selection;
+  if (!mask.anyTrue)
+    return ui.divText('No distribution');
+
 
-    $(distributionHost).empty().append(res);
+  const getDistributionCategoreisHost = (): HTMLDivElement => {
+    const distributionCategories: HTMLDivElement[] = [getDistributionCategory(general, table, options)];
+    for (const tag of Object.values(DISTRIBUTION_CATEGORIES_KEYS)) {
+      if (table.getTag(tag) !== `${true}` ||
+        (tag === DISTRIBUTION_CATEGORIES_KEYS.SEPARATE_CLUSTERS && !options.clusterColName))
+        continue;
+
+
+      distributionCategories.push(getDistributionCategory(tag, table, options));
+    }
+    return (distributionCategories.length === 1) ? distributionCategories[0] : ui.div(distributionCategories);
   };
+  const distributionCategoriesHost = ui.div(getDistributionCategoreisHost());
+  const inputsNames = Object.values(DISTRIBUTION_CATEGORIES_KEYS);
+  const inputsArray: DG.InputBase[] = new Array(inputsNames.length);
+  for (let inputIdx = 0; inputIdx < inputsNames.length; inputIdx++) {
+    const inputName = inputsNames[inputIdx].substring(8);
+    inputsArray[inputIdx] = ui.boolInput(inputName,
+      table.getTag(inputsNames[inputIdx]) === `${true}`, () => {
+        table.setTag(inputsNames[inputIdx], `${inputsArray[inputIdx].value}`);
+        $(distributionCategoriesHost).empty();
+        distributionCategoriesHost.append(getDistributionCategoreisHost());
+      }) as DG.InputBase<boolean>;
+    $(inputsArray[inputIdx].captionLabel).addClass('ui-label-right').css('text-align', 'left');
+    $(inputsArray[inputIdx].root).find('.ui-input-editor').css('margin', '0px');
+    $(inputsArray[inputIdx].root).find('.ui-input-description').css('margin', '0px');
+    inputsArray[inputIdx].setTooltip(`Show distribution for each ${inputName}`);
+    if (inputName === DISTRIBUTION_CATEGORIES_KEYS.SEPARATE_CLUSTERS)
+      inputsArray[inputIdx].enabled = !!(options.clusterColName && options.clusterSelection[CLUSTER_TYPE.ORIGINAL]);
+    else if (inputName === DISTRIBUTION_CATEGORIES_KEYS.SEPARATE_MONOMERS ||
+      inputName === DISTRIBUTION_CATEGORIES_KEYS.SEPARATE_POSITIONS)
+      inputsArray[inputIdx].enabled = Object.entries(options.monomerPositionSelection).length !== 0;
+  }
 
-  // const splitByPosition = ui.boolInput('Split by position', defaultValuePos, updateDistributionHost);
-  // splitByPosition.setTooltip('Constructs distribution for each position separately');
-  // setDefaultProperties(splitByPosition);
-  // $(splitByPosition.root).css('margin-right', '10px');
-  // const splitByMonomer = ui.boolInput('Split by monomer', defaultValueMonomer, updateDistributionHost);
-  // splitByMonomer.setTooltip('Constructs distribution for each monomer separately');
-  // setDefaultProperties(splitByMonomer);
-
-  // const controlsHost = ui.divH([splitByPosition.root, splitByMonomer.root]);
-  // splitByMonomer.fireChanged();
-  updateDistributionHost();
-  return new DG.Widget(ui.divV([/*controlsHost,*/ distributionHost]));
+  const inputsHost = ui.form(inputsArray);
+  $(inputsHost).css('display', 'inline-flex');
+  return ui.divV([inputsHost, distributionCategoriesHost]);
 }
 
-export function getActivityDistribution(table: DG.DataFrame, isTooltip: boolean = false): DG.Viewer<DG.IHistogramLookSettings> {
+/**
+ * Builds activity distribution histogram
+ * @param table - Dataframe with peptides
+ * @param isTooltip - Is histogram for tooltip
+ * @return - Histogram viewer
+ */
+export function getActivityDistribution(table: DG.DataFrame, isTooltip: boolean = false,
+): DG.Viewer<DG.IHistogramLookSettings> {
   const hist = table.plot.histogram({
     filteringEnabled: false,
     valueColumnName: C.COLUMNS_NAMES.ACTIVITY,
@@ -88,7 +108,14 @@ export function getActivityDistribution(table: DG.DataFrame, isTooltip: boolean
   return hist;
 }
 
-export function getStatsTableMap(stats: Stats, options: {fractionDigits?: number} = {}): StringDictionary {
+/**
+ * Builds stats table map
+ * @param stats - Stats item
+ * @param options - Stats table map options
+ * @param options.fractionDigits - Number of fraction digits for stats values
+ * @return - Stats table map
+ */
+export function getStatsTableMap(stats: StatsItem, options: { fractionDigits?: number } = {}): StringDictionary {
   options.fractionDigits ??= 3;
   const tableMap: StringDictionary = {
     'Count': `${stats.count} (${stats.ratio.toFixed(options.fractionDigits)}%)`,
@@ -97,5 +124,219 @@ export function getStatsTableMap(stats: Stats, options: {fractionDigits?: number
   };
   if (stats.pValue !== null)
     tableMap['p-value'] = stats.pValue < 0.01 ? '<0.01' : stats.pValue.toFixed(options.fractionDigits);
+
+
   return tableMap;
 }
+
+/**
+ * Builds distribution for signle item
+ * @param table - Dataframe with peptides
+ * @param stats - Stats item
+ * @param options - Distribution options
+ * @param [labelMap] - Map for histogram legend labels
+ * @return - Distribution panel
+ */
+function getSingleDistribution(table: DG.DataFrame, stats: StatsItem, options: DistributionItemOptions,
+  labelMap: DistributionLabelMap = {}): HTMLDivElement {
+  const hist = getActivityDistribution(getDistributionTable(options.activityCol, table.selection,
+    options.peptideSelection));
+  const aggregatedColMap = getAggregatedColumnValues(table, Object.entries(options.columns),
+    {filterDf: true, mask: DG.BitSet.fromBytes(stats.mask.buffer.buffer, stats.mask.length)});
+  const tableMap = getStatsTableMap(stats);
+  const resultMap: { [key: string]: any } = {...tableMap, ...aggregatedColMap};
+  const distributionRoot = getDistributionPanel(hist, resultMap, labelMap);
+  $(distributionRoot).addClass('d4-flex-col');
+
+  return distributionRoot;
+}
+
+/**
+ * Builds distribution item for specified category
+ * @param category - Distribution category
+ * @param table - Dataframe with peptides
+ * @param options - Distribution options
+ * @return - Distribution item
+ */
+function getDistributionCategory(category: DISTRIBUTION_CATEGORIES_KEYS | typeof general, table: DG.DataFrame,
+  options: DistributionItemOptions): HTMLDivElement {
+  let body: HTMLDivElement = ui.divText('No distribution');
+  switch (category) {
+  case general:
+    const bitArray = BitArray.fromSeq(table.selection.length, (i: number) => table.selection.get(i));
+    const stats = !table.selection.anyTrue || !table.selection.anyFalse ?
+      {
+        count: options.activityCol.length, pValue: null, meanDifference: 0, ratio: 1, mask: bitArray,
+        mean: options.activityCol.stats.avg,
+      } :
+      getStats(options.activityCol.getRawData(), bitArray);
+
+    body = getSingleDistribution(table, stats, options);
+    break;
+  case DISTRIBUTION_CATEGORIES_KEYS.SEPARATE_CLUSTERS:
+    body = getDistributionForClusters(table, options as Required<DistributionItemOptions>, options.clusterSelection);
+    break;
+  case DISTRIBUTION_CATEGORIES_KEYS.SEPARATE_MONOMERS:
+    const reversedSelectionObject = getReversedObject(options.monomerPositionSelection);
+    body = getDistributionForMonomers(table, options, reversedSelectionObject);
+    break;
+  case DISTRIBUTION_CATEGORIES_KEYS.SEPARATE_POSITIONS:
+    body = getDistributionForPositions(table, options, options.monomerPositionSelection);
+    break;
+  }
+
+  return ui.divV([ui.h1(key2category(category)), body]);
+}
+
+/**
+ * Builds distribution group for clusters
+ * @param table - Dataframe with peptides
+ * @param options - Distribution options
+ * @param selectionObject - Selection object
+ * @return - Distribution group host
+ */
+function getDistributionForClusters(table: DG.DataFrame, options: Required<DistributionItemOptions>,
+  selectionObject: Selection): HTMLDivElement {
+  const rowCount = table.rowCount;
+  const distributions: HTMLDivElement[] = [];
+  const activityColData = options.activityCol.getRawData();
+  const clusterCol = table.getCol(options.clusterColName);
+  const clusterColCategories = clusterCol.categories;
+  const clusterColData = clusterCol.getRawData() as Int32Array;
+
+  // Build distributions for original clusters
+  const selectedClustersCategoryIndexes = selectionObject[CLUSTER_TYPE.ORIGINAL]
+    .map((cluster: string) => clusterColCategories.indexOf(cluster));
+  const clusterMasks: BitArray[] = new Array(selectedClustersCategoryIndexes.length).fill(new BitArray(rowCount));
+  for (let i = 0; i < rowCount; i++) {
+    const cluster = clusterColData[i];
+    const selectedIndex = selectedClustersCategoryIndexes.indexOf(cluster);
+    if (selectedIndex !== -1)
+      clusterMasks[selectedIndex].setTrue(i);
+  }
+  for (let selectedClusterIdx = 0; selectedClusterIdx < selectedClustersCategoryIndexes.length; selectedClusterIdx++) {
+    const selectedClusterCategoryIndex = selectedClustersCategoryIndexes[selectedClusterIdx];
+    const stats = getStats(activityColData, clusterMasks[selectedClusterIdx]);
+    distributions.push(getSingleDistribution(table, stats, options,
+      {[SPLIT_CATEGORY.SELECTION]: clusterColCategories[selectedClusterCategoryIndex]}));
+  }
+
+  // Build distributions for custom clusters
+  const customClusterSelection = selectionObject[CLUSTER_TYPE.CUSTOM];
+  for (const clusterColumnName of customClusterSelection) {
+    const customClustCol = table.getCol(clusterColumnName);
+    const bitArray = BitArray.fromUint32Array(rowCount, customClustCol.getRawData() as Uint32Array);
+    const stats = getStats(activityColData, bitArray);
+    distributions.push(getSingleDistribution(table, stats, options,
+      {[SPLIT_CATEGORY.SELECTION]: clusterColumnName}));
+  }
+
+  return ui.div(distributions, 'd4-flex-wrap');
+}
+
+/**
+ * Builds distribution group for positions category
+ * @param table - Dataframe with peptides
+ * @param options - Distribution options
+ * @param selectionObject - Selection object
+ * @return - Distribution group host
+ */
+function getDistributionForPositions(table: DG.DataFrame, options: DistributionItemOptions,
+  selectionObject: Selection): HTMLDivElement {
+  const positions = Object.keys(selectionObject);
+  const rowCount = table.rowCount;
+  const distributions: HTMLDivElement[] = [];
+  const activityColData = options.activityCol.getRawData();
+  const positionColumns: (DG.Column<string> | undefined)[] = [];
+  const positionColumnsCategories: (string[] | undefined)[] = [];
+  const positionColumnsData: (Int32Array | undefined)[] = [];
+
+  for (let posIdx = 0; posIdx < positions.length; posIdx++) {
+    const position = positions[posIdx];
+    const monomerList = selectionObject[position];
+    if (monomerList.length === 0)
+      continue;
+
+
+    positionColumns[posIdx] ??= table.getCol(position);
+    positionColumnsCategories[posIdx] ??= positionColumns[posIdx]!.categories;
+    positionColumnsData[posIdx] ??= positionColumns[posIdx]!.getRawData() as Int32Array;
+
+    const mask = new BitArray(table.rowCount);
+    for (let monomerIdx = 0; monomerIdx < monomerList.length; monomerIdx++) {
+      const monomer = monomerList[monomerIdx];
+      const monomerCategoryIndex = positionColumnsCategories[posIdx]!.indexOf(monomer);
+
+      for (let i = 0; i < rowCount; i++) {
+        if (positionColumnsData[posIdx]![i] === monomerCategoryIndex)
+          mask.setTrue(i);
+      }
+    }
+    const stats = getStats(activityColData, mask);
+    distributions.push(getSingleDistribution(table, stats, options, {[SPLIT_CATEGORY.SELECTION]: position}));
+  }
+
+  return ui.div(distributions, 'd4-flex-wrap');
+}
+
+/**
+ * Builds distribution group for monomers category
+ * @param table - Dataframe with peptides
+ * @param options - Distribution options
+ * @param reversedSelectionObject - Selection object with monomers as keys and list of positions as values
+ * @return - Distribution group host
+ */
+function getDistributionForMonomers(table: DG.DataFrame, options: DistributionItemOptions,
+  reversedSelectionObject: Selection): HTMLDivElement {
+  const monomers = Object.keys(reversedSelectionObject);
+  const rowCount = table.rowCount;
+  const distributions: HTMLDivElement[] = [];
+  const positionColumns: (DG.Column<string> | undefined)[] = [];
+  const positionColumnsCategories: (string[] | undefined)[] = [];
+  const positionColumnsData: (Int32Array | undefined)[] = [];
+  const activityColData = options.activityCol.getRawData();
+
+  for (const monomer of monomers) {
+    const posList = reversedSelectionObject[monomer];
+    const mask = new BitArray(rowCount);
+
+    for (let posIdx = 0; posIdx < posList.length; posIdx++) {
+      const position = posList[posIdx];
+      positionColumns[posIdx] ??= table.getCol(position);
+      positionColumnsCategories[posIdx] ??= positionColumns[posIdx]!.categories;
+      positionColumnsData[posIdx] ??= positionColumns[posIdx]!.getRawData() as Int32Array;
+
+      const monomerCategoryIndex = positionColumnsCategories[posIdx]!.indexOf(monomer);
+      for (let i = 0; i < rowCount; i++) {
+        if (positionColumnsData[posIdx]![i] === monomerCategoryIndex)
+          mask.setTrue(i);
+      }
+    }
+    const stats = getStats(activityColData, mask);
+
+    distributions.push(getSingleDistribution(table, stats, options, {[SPLIT_CATEGORY.SELECTION]: monomer}));
+  }
+
+  return ui.div(distributions, 'd4-flex-wrap');
+}
+
+/**
+ * Converts monomer-position selection object to have monomers as keys and list of positions as values
+ * @param selectionObject - Selection object
+ * @return - Reversed selection object
+ */
+function getReversedObject(selectionObject: Selection): Selection {
+  const reversedSelectionObject: Selection = {};
+  const positions = Object.keys(selectionObject);
+  for (const position of positions) {
+    for (const monomer of selectionObject[position]) {
+      if (!reversedSelectionObject.hasOwnProperty(monomer)) {
+        reversedSelectionObject[monomer] = [position];
+        continue;
+      }
+      if (!reversedSelectionObject[monomer].includes(position))
+        reversedSelectionObject[monomer].push(position);
+    }
+  }
+  return reversedSelectionObject;
+}

package/src/widgets/manual-alignment.ts

@@ -5,32 +5,39 @@ import * as DG from 'datagrok-api/dg';
 import $ from 'cash-dom';
 import '../styles.css';
 import {PeptidesModel} from '../model';
-import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
 
-/** Manual sequence alignment widget.
- * @param {DG.Column} alignedSequenceCol Aligned sequence column
- * @param {DG.DataFrame} currentDf Working table
- * @return {DG.Widget} Widget for manual sequence alignment */
+/**
+ * Allows to edit sequence and apply changes to the table and analysis.
+ * @param alignedSequenceCol Aligned sequence column
+ * @param currentDf Working table
+ * @return Widget for manual sequence alignment
+ */
 export function manualAlignmentWidget(alignedSequenceCol: DG.Column<string>, currentDf: DG.DataFrame): DG.Widget {
   const sequenceInput = ui.textInput('', alignedSequenceCol.get(currentDf.currentRowIdx)!);
   $(sequenceInput.root).addClass('pep-textinput');
 
   const applyChangesBtn = ui.button('Apply', async () => {
+    const uh = UnitsHandler.getOrCreate(alignedSequenceCol);
     const newSequence = sequenceInput.value;
+    const splitter = uh.getSplitter();
+    const splitSequence = splitter(newSequence);
     const affectedRowIndex = currentDf.currentRowIdx;
-    const splitSequence = splitAlignedSequences(DG.Column.fromStrings('splitSequence', [newSequence]));
-
     alignedSequenceCol.set(affectedRowIndex, newSequence);
-    for (const part of splitSequence.columns) {
-      if (currentDf.col(part.name) !== null)
-        currentDf.set(part.name, affectedRowIndex, part.get(0));
+    for (let i = 0; i < splitSequence.length; i++) {
+      const part = splitSequence[i];
+      if (currentDf.col(i.toString()) !== null)
+        currentDf.set(i.toString(), affectedRowIndex, part);
     }
     const temp = grok.shell.o;
     grok.shell.o = null;
-    grok.shell.o = temp;
 
     const peptidesController = PeptidesModel.getInstance(currentDf);
     peptidesController.updateGrid();
+
+    setTimeout(() => {
+      grok.shell.o = temp;
+    }, 100);
   }, 'Apply changes');
 
   const resetBtn = ui.button(ui.iconFA('redo'),

package/src/widgets/mutation-cliffs.ts

@@ -2,46 +2,61 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import * as C from '../utils/constants';
 import * as type from '../utils/types';
-import {PeptidesModel} from '../model';
 import {addExpandIcon, getSeparator, setGridProps} from '../utils/misc';
 import {renderCellSelection} from '../utils/cell-renderer';
 
-export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
+export type MutationCliffsOptions = {
+  mutationCliffs: type.MutationCliffs, mutationCliffsSelection: type.Selection, sequenceColumnName: string,
+  positionColumns: DG.Column<string>[], gridColumns: DG.GridColumnList, activityCol: DG.Column<number>,
+};
+
+/**
+ * Creates mutation cliffs widget that shows grid of sequences that form mutation cliffs pairs as well as
+ * grid of mutation cliffs pairs themselves.
+ * @param table - table with sequences.
+ * @param options - options for mutation cliffs widget.
+ * @return - mutation cliffs widget.
+ */
+export function mutationCliffsWidget(table: DG.DataFrame, options: MutationCliffsOptions): DG.Widget {
   const filteredIndexes = table.filter.getSelectedIndexes();
-  const substInfo = model.mutationCliffs;
-  const currentCell = model.mutationCliffsSelection;
-  const positions = Object.keys(currentCell);
+  const positions = Object.keys(options.mutationCliffsSelection);
 
-  if (!positions.length || substInfo === null)
+  if (!positions.length || options.mutationCliffs === null)
     return new DG.Widget(ui.label('No mutations table generated'));
 
+
   const substitutionsArray: string[] = [];
   const deltaArray: number[] = [];
   const substitutedToArray: string[] = [];
   const fromIdxArray: number[] = [];
   const toIdxArray: number[] = [];
-  const alignedSeqCol = table.getCol(model.settings.sequenceColumnName!);
+  const alignedSeqCol = table.getCol(options.sequenceColumnName!);
   const alignedSeqColCategories = alignedSeqCol.categories;
   const alignedSeqColData = alignedSeqCol.getRawData();
-  const activityScaledCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY);
-  const activityScaledColData = activityScaledCol.getRawData();
+  // const activityScaledCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY);
+  const activityScaledColData = options.activityCol.getRawData();
   const seenIndexes = new Map<number, number[]>();
   const uniqueSequencesBitSet = DG.BitSet.create(table.rowCount);
 
+  const positionColumns: { [colName: string]: DG.Column<string> } =
+    Object.fromEntries(options.positionColumns.map((col) => [col.name, col]));
   for (const pos of positions) {
-    const posCol = table.getCol(pos);
+    const posCol = positionColumns[pos];
     const posColCategories = posCol.categories;
     const posColData = posCol.getRawData();
 
-    for (const monomer of currentCell[pos]) {
-      const substitutionsMap = substInfo.get(monomer)?.get(pos) as Map<number, type.UTypedArray> | undefined;
+    for (const monomer of options.mutationCliffsSelection[pos]) {
+      const substitutionsMap = options.mutationCliffs.get(monomer)
+        ?.get(pos) as Map<number, type.UTypedArray> | undefined;
       if (typeof substitutionsMap === 'undefined')
         continue;
 
+
       for (const [referenceIdx, indexArray] of substitutionsMap.entries()) {
         if (!filteredIndexes.includes(referenceIdx))
           continue;
 
+
         const forbiddentIndexes = seenIndexes.get(referenceIdx) ?? [];
         const baseSequence = alignedSeqColCategories[alignedSeqColData[referenceIdx]];
         const baseActivity = activityScaledColData[referenceIdx];
@@ -50,8 +65,11 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
           if (forbiddentIndexes.includes(subIdx) || !filteredIndexes.includes(subIdx))
             continue;
 
+
           if (!seenIndexes.has(subIdx))
             seenIndexes.set(subIdx, []);
+
+
           const subSeq = alignedSeqColCategories[alignedSeqColData[subIdx]];
 
           seenIndexes.get(subIdx)!.push(referenceIdx);
@@ -70,6 +88,7 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
   if (substitutionsArray.length === 0)
     return new DG.Widget(ui.label('No mutations table generated'));
 
+
   const substCol = DG.Column.fromStrings('Mutation', substitutionsArray);
   const activityDeltaCol = DG.Column.fromList('double', 'Delta', deltaArray);
   const hiddenSubstToAarCol = DG.Column.fromStrings('~to', substitutedToArray);
@@ -102,11 +121,16 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
       const rowIdx = gridCell.tableRowIndex;
       if (!keyPress)
         return;
+
+
       if (rowIdx === null)
         return;
+
+
       if (lastSelectedIndex !== null)
         pairsSelectedIndexes.splice(pairsSelectedIndexes.indexOf(lastSelectedIndex), 1);
 
+
       if (!pairsSelectedIndexes.includes(rowIdx)) {
         pairsSelectedIndexes.push(rowIdx);
         pairsGrid.invalidate();
@@ -123,6 +147,7 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
     if (!gridCell || gridCell.tableRowIndex === null)
       return;
 
+
     const rowIdx = gridCell.tableRowIndex;
     if (!event.shiftKey) {
       pairsSelectedIndexes.length = 0;
@@ -141,16 +166,16 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
     if (gcArgs.cell.tableColumn?.name !== substCol.name || !pairsSelectedIndexes.includes(gcArgs.cell.tableRowIndex!))
       return;
 
+
     renderCellSelection(gcArgs.g, gcArgs.bounds);
   });
 
-  const gridCols = model.analysisView.grid.columns;
-  const originalGridColCount = gridCols.length;
-  const positionColumns = model.positionColumns.toArray().map((col) => col.name);
+  const originalGridColCount = options.gridColumns.length;
   const columnNames: string[] = [];
   for (let colIdx = 1; colIdx < originalGridColCount; colIdx++) {
-    const gridCol = gridCols.byIndex(colIdx);
-    if (gridCol?.name === model.settings.sequenceColumnName || (gridCol?.visible === true && !positionColumns.includes(gridCol.name)))
+    const gridCol = options.gridColumns.byIndex(colIdx);
+    if (gridCol?.name === options.sequenceColumnName ||
+      (gridCol?.visible === true && !Object.hasOwn(positionColumns, gridCol.name)))
       columnNames.push(gridCol!.name);
   }
 
@@ -176,5 +201,6 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
   addExpandIcon(pairsGrid);
   addExpandIcon(uniqueSequencesGrid);
 
-  return new DG.Widget(ui.divV([aminoToInput.root, pairsGrid.root, uniqueSequencesGrid.root], {style: {width: '100%'}}));
+  return new DG.Widget(ui.divV([aminoToInput.root, pairsGrid.root, uniqueSequencesGrid.root],
+    {style: {width: '100%'}}));
 }