@datagrok/peptides 1.9.2 → 1.11.3

package/src/widgets/distribution.ts

@@ -7,7 +7,7 @@ import $ from 'cash-dom';
 import * as C from '../utils/constants';
 import {getStats, Stats} from '../utils/statistics';
 import {PeptidesModel} from '../model';
-import {getStatsSummary} from '../utils/misc';
+import {getStatsSummary, prepareTableForHistogram} from '../utils/misc';
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
 
 const allConst = 'All';
@@ -17,7 +17,7 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
   const activityCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
   const activityColData = activityCol.getRawData();
   const rowCount = activityCol.length;
-  const selectionObject = model.monomerPositionSelection;
+  const selectionObject = model.mutationCliffsSelection;
   const clustersColName = model.settings.clustersColumnName;
   let clustersProcessedObject: string[] = [];
   if (clustersColName)
@@ -49,12 +49,12 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
           const mask = DG.BitSet.create(rowCount, (i) => posColData[i] === aarCategoryIndex);
           const distributionTable = DG.DataFrame.fromColumns(
             [activityCol, DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask)]);
-          const hist = getActivityDistribution(distributionTable);
+          const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
 
           const stats = model.monomerPositionStats[position][aar];
-          const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
+          const tableMap = getStatsTableMap(stats);
 
-          const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
+          const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask});
 
           const resultMap = {...tableMap, ...aggregatedColMap};
           const distributionRoot = getStatsSummary(labels, hist, resultMap);
@@ -80,14 +80,14 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
         const mask = DG.BitSet.create(rowCount, (i) => aarIndexesList.includes(posColData[i]));
         const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
 
-        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
+        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask});
 
         const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
-        const hist = getActivityDistribution(distributionTable);
+        const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
 
         const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
         const stats = getStats(activityColData, bitArray);
-        const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
+        const tableMap = getStatsTableMap(stats);
 
         const resultMap = {...tableMap, ...aggregatedColMap};
         const distributionRoot = getStatsSummary(labels, hist, resultMap);
@@ -123,15 +123,15 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
 
         const mask = DG.BitSet.create(rowCount,
           (i) => posColDataList.some((posColData, j) => posColData[i] === aarCategoryIndexList[j]));
-        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
+        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask});
 
         const splitCol = DG.Column.fromBitSet(C.COLUMNS_NAMES.SPLIT_COL, mask);
         const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
-        const hist = getActivityDistribution(distributionTable);
+        const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
 
         const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
         const stats = getStats(activityColData, bitArray);
-        const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
+        const tableMap = getStatsTableMap(stats);
 
         const resultMap: {[key: string]: any} = {...tableMap, ...aggregatedColMap};
         const distributionRoot = getStatsSummary(labels, hist, resultMap);
@@ -160,14 +160,15 @@ export function getDistributionWidget(table: DG.DataFrame, model: PeptidesModel)
         const labels = getDistributionLegend(aarStr, otherStr);
 
         const distributionTable = DG.DataFrame.fromColumns([activityCol, splitCol]);
-        const hist = getActivityDistribution(distributionTable);
+
+        const hist = getActivityDistribution(prepareTableForHistogram(distributionTable));
 
         const bitArray = BitArray.fromUint32Array(rowCount, splitCol.getRawData() as Uint32Array);
         const mask = DG.BitSet.create(rowCount, (i) => bitArray.getBit(i));
-        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask, fractionDigits: 2});
+        const aggregatedColMap = model.getAggregatedColumnValues({filterDf: true, mask});
 
         const stats = getStats(activityColData, bitArray);
-        const tableMap = getStatsTableMap(stats, {fractionDigits: 2});
+        const tableMap = getStatsTableMap(stats);
 
         const resultMap: {[key: string]: any} = {...tableMap, ...aggregatedColMap};
         const distributionRoot = getStatsSummary(labels, hist, resultMap);
@@ -225,10 +226,9 @@ export function getActivityDistribution(table: DG.DataFrame, isTooltip: boolean
 }
 
 export function getStatsTableMap(stats: Stats, options: {fractionDigits?: number} = {}): StringDictionary {
+  options.fractionDigits ??= 3;
   const tableMap = {
-    'Statistics:': '',
-    'Count': stats.count.toString(),
-    'Ratio': stats.ratio.toFixed(options.fractionDigits),
+    'Count': `${stats.count} (${stats.ratio.toFixed(options.fractionDigits)}%)`,
     'p-value': stats.pValue < 0.01 ? '<0.01' : stats.pValue.toFixed(options.fractionDigits),
     'Mean difference': stats.meanDifference.toFixed(options.fractionDigits),
   };

package/src/widgets/mutation-cliffs.ts

@@ -4,11 +4,12 @@ import * as C from '../utils/constants';
 import * as type from '../utils/types';
 import {PeptidesModel} from '../model';
 import {getSeparator} from '../utils/misc';
+import {renderCellSelection} from '../utils/cell-renderer';
 
 export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
   const filteredIndexes = table.filter.getSelectedIndexes();
   const substInfo = model.mutationCliffs;
-  const currentCell = model.monomerPositionSelection;
+  const currentCell = model.mutationCliffsSelection;
   const positions = Object.keys(currentCell);
 
   if (!positions.length || substInfo === null)
@@ -17,12 +18,15 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
   const substitutionsArray: string[] = [];
   const deltaArray: number[] = [];
   const substitutedToArray: string[] = [];
+  const fromIdxArray: number[] = [];
+  const toIdxArray: number[] = [];
   const alignedSeqCol = table.getCol(model.settings.sequenceColumnName!);
   const alignedSeqColCategories = alignedSeqCol.categories;
   const alignedSeqColData = alignedSeqCol.getRawData();
   const activityScaledCol = table.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
   const activityScaledColData = activityScaledCol.getRawData();
   const seenIndexes = new Map<number, number[]>();
+  const uniqueSequencesBitSet = DG.BitSet.create(table.rowCount);
 
   for (const pos of positions) {
     const posCol = table.getCol(pos);
@@ -39,9 +43,7 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
           continue;
 
         const forbiddentIndexes = seenIndexes.get(referenceIdx) ?? [];
-        // const baseSequence = alignedSeqCol.get(referenceIdx);
         const baseSequence = alignedSeqColCategories[alignedSeqColData[referenceIdx]];
-        // const baseActivity = activityScaledCol.get(referenceIdx);
         const baseActivity = activityScaledColData[referenceIdx];
 
         for (const subIdx of indexArray) {
@@ -56,6 +58,10 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
           substitutionsArray.push(`${baseSequence}#${subSeq}`);
           deltaArray.push(baseActivity - activityScaledColData[subIdx]);
           substitutedToArray.push(posColCategories[posColData[subIdx]]);
+          fromIdxArray.push(referenceIdx);
+          toIdxArray.push(subIdx);
+          uniqueSequencesBitSet.set(referenceIdx, true);
+          uniqueSequencesBitSet.set(subIdx, true);
         }
       }
     }
@@ -65,27 +71,93 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
     return new DG.Widget(ui.label('No mutations table generated'));
 
   const substCol = DG.Column.fromStrings('Mutation', substitutionsArray);
-  substCol.semType = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
-  substCol.tags[C.TAGS.SEPARATOR] = getSeparator(alignedSeqCol);
-  substCol.tags[DG.TAGS.UNITS] = alignedSeqCol.tags[DG.TAGS.UNITS];
-  substCol.tags[DG.TAGS.CELL_RENDERER] = 'MacromoleculeDifference';
-  const toColName = '~to';
-  const hiddenSubstToAarCol = DG.Column.fromStrings(toColName, substitutedToArray);
-  const substTable =
-    DG.DataFrame.fromColumns([substCol, DG.Column.fromList('double', 'Delta', deltaArray), hiddenSubstToAarCol]);
+  const activityDeltaCol = DG.Column.fromList('double', 'Delta', deltaArray);
+  const hiddenSubstToAarCol = DG.Column.fromStrings('~to', substitutedToArray);
+  const toIdxCol = DG.Column.fromList(DG.COLUMN_TYPE.INT, '~toIdx', toIdxArray);
+  const fromIdxCol = DG.Column.fromList(DG.COLUMN_TYPE.INT, '~fromIdx', fromIdxArray);
+  const pairsTable = DG.DataFrame.fromColumns([substCol, activityDeltaCol, hiddenSubstToAarCol, toIdxCol, fromIdxCol]);
 
   const aminoToInput = ui.stringInput('Mutated to:', '', () => {
     const substitutedToAar = aminoToInput.stringValue;
     if (substitutedToAar !== '')
-      substTable.filter.init((idx) => hiddenSubstToAarCol.get(idx) === substitutedToAar);
+      pairsTable.filter.init((idx) => hiddenSubstToAarCol.get(idx) === substitutedToAar);
     else
-      substTable.filter.setAll(true);
+      pairsTable.filter.setAll(true);
+  });
+  aminoToInput.setTooltip('Monomer to which the mutation was made');
+
+  const pairsGrid = pairsTable.plot.grid();
+  pairsGrid.props.allowEdit = false;
+  pairsGrid.props.allowRowSelection = false;
+  pairsGrid.props.allowBlockSelection = false;
+  pairsGrid.props.allowColSelection = false;
+  pairsGrid.root.style.width = '100%';
+  pairsGrid.root.style.height = '150px';
+  substCol.semType = C.SEM_TYPES.MACROMOLECULE_DIFFERENCE;
+  substCol.tags[C.TAGS.SEPARATOR] = getSeparator(alignedSeqCol);
+  substCol.tags[DG.TAGS.UNITS] = alignedSeqCol.tags[DG.TAGS.UNITS];
+  substCol.tags[DG.TAGS.CELL_RENDERER] = 'MacromoleculeDifference';
+
+  const pairsSelectedIndexes: number[] = [];
+  pairsGrid.root.addEventListener('click', (event) => {
+    const gridCell = pairsGrid.hitTest(event.offsetX, event.offsetY);
+    if (gridCell === null || gridCell.tableRowIndex === null)
+      return;
+
+    const rowIdx = gridCell.tableRowIndex;
+    if (!event.shiftKey) {
+      pairsSelectedIndexes.length = 0;
+      pairsSelectedIndexes.push(rowIdx);
+    } else {
+      const rowIdxIdx = pairsSelectedIndexes.indexOf(rowIdx);
+      if (rowIdxIdx === -1)
+        pairsSelectedIndexes.push(rowIdx);
+      else
+        pairsSelectedIndexes.splice(rowIdxIdx, 1);
+    }
+    uniqueSequencesTable.filter.fireChanged();
+    gridCell.cell.dataFrame.currentRowIdx = -1;
+    pairsGrid.invalidate();
+  });
+  pairsGrid.onCellRender.subscribe((gcArgs) => {
+    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.splitSeqDf.columns;
+  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.contains(gridCol.name)))
+      columnNames.push(gridCol!.name);
+  }
+
+  const uniqueSequencesTable = table.clone(uniqueSequencesBitSet, columnNames);
+  const seqIdxCol = uniqueSequencesTable.columns.addNewInt('~seqIdx');
+  const seqIdxColData = seqIdxCol.getRawData();
+  const selectedIndexes = uniqueSequencesBitSet.getSelectedIndexes();
+  seqIdxCol.init((idx) => selectedIndexes[idx]);
+  const uniqueSequencesGrid = uniqueSequencesTable.plot.grid();
+  uniqueSequencesGrid.props.allowEdit = false;
+  uniqueSequencesGrid.props.allowRowSelection = false;
+  uniqueSequencesGrid.props.allowBlockSelection = false;
+  uniqueSequencesGrid.props.allowColSelection = false;
+  uniqueSequencesGrid.props.rowHeight = 20;
+  uniqueSequencesGrid.root.style.width = '100%';
+  uniqueSequencesGrid.root.style.height = '250px';
+  uniqueSequencesTable.filter.onChanged.subscribe(() => {
+    const uniqueSelectedIndexes: number[] = [];
+    for (const idx of pairsSelectedIndexes) {
+      uniqueSelectedIndexes.push(fromIdxCol.get(idx)!);
+      uniqueSelectedIndexes.push(toIdxCol.get(idx)!);
+    }
+    uniqueSequencesTable.filter.init(
+      (idx) => pairsSelectedIndexes.length === 0 || uniqueSelectedIndexes.includes(seqIdxColData[idx]), false);
   });
 
-  const grid = substTable.plot.grid();
-  grid.props.allowEdit = false;
-  const gridRoot = grid.root;
-  gridRoot.style.width = 'auto';
-  gridRoot.style.height = '150px';
-  return new DG.Widget(ui.divV([aminoToInput.root, gridRoot]));
+  return new DG.Widget(ui.divV([aminoToInput.root, pairsGrid.root, uniqueSequencesGrid.root], {style: {width: '100%'}}));
 }

package/src/widgets/peptides.ts

@@ -13,7 +13,6 @@ import {scaleActivity} from '../utils/misc';
 import {ALIGNMENT, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 /** Peptide analysis widget.
- *
  * @param {DG.DataFrame} df Working table
  * @param {DG.Column} col Aligned sequence column
  * @return {Promise<DG.Widget>} Widget containing peptide analysis */
@@ -39,7 +38,8 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
         viewer.root.style.setProperty('height', '130px');
         return viewer.root;
       }));
-    });
+      //TODO: add when new version of datagrok-api is available
+    }, {filter: (col: DG.Column) => col.semType === DG.SEMTYPE.MACROMOLECULE});
   } else if (!(col.getTag(bioTAGS.aligned) === ALIGNMENT.SEQ_MSA) &&
     col.getTag(DG.TAGS.UNITS) !== NOTATION.HELM) {
     return {
@@ -95,18 +95,16 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
       DG.Stats.fromColumn(activityColumnChoice.value!).min > 0;
     activityScalingMethod.fireChanged();
   };
-  const activityColumnChoice = ui.columnInput('Activity', df, defaultActivityColumn, activityScalingMethodState);
+  //TODO: add when new version of datagrok-api is available
+  const activityColumnChoice = ui.columnInput('Activity', df, defaultActivityColumn, activityScalingMethodState,
+    {filter: (col: DG.Column) => col.type === DG.TYPE.INT || col.type === DG.TYPE.FLOAT});
   const clustersColumnChoice = ui.columnInput('Clusters', df, null);
   clustersColumnChoice.nullable = true;
   activityColumnChoice.fireChanged();
   activityScalingMethod.fireChanged();
 
-  const targetColumnChoice = ui.columnInput('Target', df, null, () => {
-    if (targetColumnChoice.value?.type !== DG.COLUMN_TYPE.STRING) {
-      grok.shell.warning('Target column should be of string type');
-      targetColumnChoice.value = null;
-    }
-  });
+  const targetColumnChoice = ui.columnInput('Target', df, null, null,
+    {filter: (col: DG.Column) => col.type === DG.TYPE.STRING});
   targetColumnChoice.nullable = true;
 
   const inputsList = [activityColumnChoice, activityScalingMethod, clustersColumnChoice, targetColumnChoice];
@@ -158,8 +156,7 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
   targetColumn: DG.Column<string> | null = null): Promise<PeptidesModel | null> {
   const progress = DG.TaskBarProgressIndicator.create('Loading SAR...');
   let model = null;
-  if (activityColumn.type === DG.COLUMN_TYPE.FLOAT || activityColumn.type === DG.COLUMN_TYPE.INT ||
-    activityColumn.type === DG.COLUMN_TYPE.BIG_INT || activityColumn.type === DG.COLUMN_TYPE.QNUM) {
+  if (activityColumn.type === DG.COLUMN_TYPE.FLOAT || activityColumn.type === DG.COLUMN_TYPE.INT) {
     //prepare new DF
     const newDf = DG.DataFrame.create(currentDf.rowCount);
     const newDfCols = newDf.columns;
@@ -200,8 +197,10 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
     const dfUuid = uuid.v4();
     newDf.setTag(C.TAGS.UUID, dfUuid);
     newDf.setTag('monomerType', monomerType);
-    model = PeptidesModel.getInstance(newDf);
-    // await model.addViewers();
+
+    // Cloning dataframe with applied filter. If filter is not applied, cloning is
+    // needed anyway to allow filtering on the original dataframe
+    model = PeptidesModel.getInstance(newDf.clone(currentDf.filter));
     if (clustersColumn) await model.addLogoSummaryTable();
     await model.addMonomerPosition();
     await model.addMostPotentResidues();

package/src/widgets/settings.ts

@@ -7,6 +7,7 @@ import {PeptidesModel, VIEWER_TYPE} from '../model';
 
 import $ from 'cash-dom';
 import wu from 'wu';
+import {getTreeHelperInstance} from '../package';
 
 type PaneInputs = {[paneName: string]: DG.InputBase[]};
 type SettingsElements = {dialog: DG.Dialog, accordion: DG.Accordion, inputs: PaneInputs};
@@ -19,6 +20,7 @@ export enum SETTINGS_PANES {
 };
 
 export enum GENERAL_INPUTS {
+  ACTIVITY = 'Activity',
   ACTIVITY_SCALING = 'Activity scaling',
   BIDIRECTIONAL_ANALYSIS = 'Bidirectional analysis',
 }
@@ -48,17 +50,27 @@ export const PANES_INPUTS = {
 export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   const accordion = ui.accordion();
   const settings = model.settings;
-  const result: type.PeptidesSettings = {columns: {}};
+  const currentScaling = settings.scaling ?? C.SCALING_METHODS.NONE;
+  const currentBidirectional = settings.isBidirectional ?? false;
+  const currentMaxMutations = settings.maxMutations ?? 1;
+  const currentMinActivityDelta = settings.minActivityDelta ?? 0;
+  const currentColumns = settings.columns ?? {};
+
+  const result: type.PeptidesSettings = {};
   const inputs: PaneInputs = {};
 
   // General pane options
-  const activityScaling = ui.choiceInput(GENERAL_INPUTS.ACTIVITY_SCALING, settings.scaling ?? C.SCALING_METHODS.NONE,
-    Object.values(C.SCALING_METHODS), () => result.scaling = activityScaling.value! as C.SCALING_METHODS);
-  const bidirectionalAnalysis = ui.boolInput(GENERAL_INPUTS.BIDIRECTIONAL_ANALYSIS, settings.isBidirectional ?? false,
-    () => result.isBidirectional = bidirectionalAnalysis.value!);
-
-  accordion.addPane(SETTINGS_PANES.GENERAL, () => ui.inputs([activityScaling, bidirectionalAnalysis]), true);
-  inputs[SETTINGS_PANES.GENERAL] = [activityScaling, bidirectionalAnalysis];
+  const activityCol = ui.columnInput(GENERAL_INPUTS.ACTIVITY, model.df,
+    model.df.getCol(model.settings.activityColumnName!), () => result.activityColumnName = activityCol.value!.name,
+    {filter: (col: DG.Column) => (col.type === DG.TYPE.FLOAT || col.type === DG.TYPE.INT) && col.name !== C.COLUMNS_NAMES.ACTIVITY_SCALED});
+  const activityScaling =
+    ui.choiceInput(GENERAL_INPUTS.ACTIVITY_SCALING, currentScaling, Object.values(C.SCALING_METHODS),
+      () => result.scaling = activityScaling.value as C.SCALING_METHODS) as DG.InputBase<C.SCALING_METHODS>;
+  const bidirectionalAnalysis = ui.boolInput(GENERAL_INPUTS.BIDIRECTIONAL_ANALYSIS, currentBidirectional,
+    () => result.isBidirectional = bidirectionalAnalysis.value) as DG.InputBase<boolean>;
+
+  accordion.addPane(SETTINGS_PANES.GENERAL, () => ui.inputs([activityCol, activityScaling, bidirectionalAnalysis]), true);
+  inputs[SETTINGS_PANES.GENERAL] = [activityCol, activityScaling, bidirectionalAnalysis];
 
   // Viewers pane options
   /* FIXME: combinations of adding and deleting viewers are not working properly
@@ -75,26 +87,27 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   */
   const isDendrogramEnabled = wu(model.analysisView.viewers).some((v) => v.type === VIEWER_TYPE.DENDROGRAM);
   const dendrogram = ui.boolInput(VIEWER_TYPE.DENDROGRAM, isDendrogramEnabled ?? false,
-    () => result.showDendrogram = dendrogram.value!);
+    () => result.showDendrogram = dendrogram.value) as DG.InputBase<boolean>;
+  dendrogram.enabled = getTreeHelperInstance() !== null;
 
   accordion.addPane(SETTINGS_PANES.VIEWERS, () => ui.inputs([dendrogram]), true);
   inputs[SETTINGS_PANES.VIEWERS] = [dendrogram];
 
   // Mutation Cliffs pane options
-  const maxMutations = ui.sliderInput(MUTATION_CLIFFS_INPUTS.MAX_MUTATIONS, settings.maxMutations ?? 1, 0, 50, () => {
-    const val = Math.round(maxMutations.value!);
+  const maxMutations = ui.sliderInput(MUTATION_CLIFFS_INPUTS.MAX_MUTATIONS, currentMaxMutations, 1, 50, () => {
+    const val = Math.round(maxMutations.value);
     $(maxMutations.root).find('label.ui-input-description').remove();
     result.maxMutations = val;
     maxMutations.addPostfix(val.toString());
-  });
+  }) as DG.InputBase<number>;
   maxMutations.addPostfix((settings.maxMutations ?? 1).toString());
-  const minActivityDelta = ui.sliderInput(MUTATION_CLIFFS_INPUTS.MIN_ACTIVITY_DELTA, settings.minActivityDelta ?? 0, 0,
+  const minActivityDelta = ui.sliderInput(MUTATION_CLIFFS_INPUTS.MIN_ACTIVITY_DELTA, currentMinActivityDelta, 0,
     100, () => {
-      const val = minActivityDelta.value!.toFixed(3);
+      const val = minActivityDelta.value.toFixed(3);
       result.minActivityDelta = parseFloat(val);
       $(minActivityDelta.root).find('label.ui-input-description').remove();
       minActivityDelta.addPostfix(val);
-    });
+    }) as DG.InputBase<number>;
   minActivityDelta.addPostfix((settings.minActivityDelta ?? 0).toString());
   accordion.addPane(SETTINGS_PANES.MUTATION_CLIFFS, () => ui.inputs([maxMutations, minActivityDelta]), true);
   inputs[SETTINGS_PANES.MUTATION_CLIFFS] = [maxMutations, minActivityDelta];
@@ -107,19 +120,28 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
     if (colName === settings.activityColumnName || colName === C.COLUMNS_NAMES.ACTIVITY_SCALED)
       continue;
 
-    const isIncludedInput = ui.boolInput(COLUMNS_INPUTS.IS_INCLUDED,
-      typeof (settings.columns ?? {})[colName] !== 'undefined', () => {
+    const isIncludedInput = ui.boolInput(COLUMNS_INPUTS.IS_INCLUDED, typeof (currentColumns)[colName] !== 'undefined',
+      () => {
+        result.columns ??= {};
         if (isIncludedInput.value)
-          result.columns![colName] = aggregationInput.value;
-        else
-          delete result.columns![colName];
+          result.columns[colName] = aggregationInput.value;
+        else {
+          delete result.columns[colName];
+          if (Object.keys(result.columns).length === Object.keys(currentColumns).length)
+            delete result.columns;
+        }
       }) as DG.InputBase<boolean>;
-    const aggregationInput = ui.choiceInput(COLUMNS_INPUTS.AGGREGATION,
-      (settings.columns ?? {})[colName] ?? DG.AGG.AVG, Object.values(DG.STATS), () => {
+
+    const aggregationInput = ui.choiceInput(COLUMNS_INPUTS.AGGREGATION, (currentColumns)[colName] ?? DG.AGG.AVG,
+      Object.values(DG.STATS), () => {
+        result.columns ??= {};
         if (isIncludedInput.value)
-          result.columns![colName] = aggregationInput.value;
-        else
-          delete result.columns![col.name];
+          result.columns[colName] = aggregationInput.value;
+        else {
+          delete result.columns[col.name];
+          if (Object.keys(result.columns).length === Object.keys(currentColumns).length)
+            delete result.columns;
+        }
       }) as DG.InputBase<DG.AggregationType>;
     $(aggregationInput.root).find('label').css('width', 'auto');
     const inputsRow = ui.inputsRow(col.name, [isIncludedInput, aggregationInput]);

package/src/widgets/similarity.ts

@@ -0,0 +1,39 @@
+
+import {sequenceChemSimilarity} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {ISeqSplitted} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+import * as DG from 'datagrok-api/dg';
+
+export function calculateIdentity(template: ISeqSplitted, splitSeqDf: DG.DataFrame): DG.Column<number> {
+  const numPositions = splitSeqDf.columns.length;
+  const positionCols: Uint32Array[] = new Array(numPositions);
+  const positionEmptyCategories: number[] = new Array(numPositions);
+  const categoryIndexesTemplate: number[] = new Array(numPositions);
+
+  for (let posIdx = 0; posIdx < numPositions; ++posIdx) {
+    const posCol = splitSeqDf.columns.byIndex(posIdx);
+    positionCols[posIdx] = posCol.getRawData() as Uint32Array;
+    positionEmptyCategories[posIdx] = posCol.categories.indexOf('');
+    categoryIndexesTemplate[posIdx] = posCol.categories.indexOf(template[posIdx] ?? '');
+  }
+
+  const identityScoresCol = DG.Column.float('Identity', splitSeqDf.rowCount);
+  const identityScoresData = identityScoresCol.getRawData();
+  for (let rowIndex = 0; rowIndex < splitSeqDf.rowCount; ++rowIndex) {
+    identityScoresData[rowIndex] = 0;
+    for (let posIdx = 0; posIdx < template.length; ++posIdx) {
+      const categoryIndex = positionCols[posIdx][rowIndex];
+      if (categoryIndex === categoryIndexesTemplate[posIdx])
+        ++identityScoresData[rowIndex];
+    }
+    identityScoresData[rowIndex] /= template.length;
+  }
+
+  return identityScoresCol;
+}
+
+
+export async function calculateSimilarity(template: ISeqSplitted, splitSeqDf: DG.DataFrame): Promise<DG.Column<number>> {
+  const columns = splitSeqDf.columns.toList() as DG.Column<string>[];
+  const scoresCol = await sequenceChemSimilarity(columns, template);
+  return scoresCol;
+}