@datagrok/peptides 1.17.0 → 1.17.1

package/src/widgets/peptides.ts

@@ -2,8 +2,6 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import * as uuid from 'uuid';
-
 import '../styles.css';
 import * as C from '../utils/constants';
 import * as type from '../utils/types';
@@ -11,28 +9,31 @@ import {PeptidesModel} from '../model';
 import $ from 'cash-dom';
 import {scaleActivity} from '../utils/misc';
 import {ALIGNMENT, NOTATION, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ILogoSummaryTable} from '../viewers/logo-summary';
+
+export type DialogParameters = { host: HTMLElement, callback: () => Promise<boolean> };
 
-/** Peptide analysis widget.
- * @param {DG.DataFrame} df Working table
- * @param {DG.Column} col Aligned sequence column
- * @return {Promise<DG.Widget>} Widget containing peptide analysis */
-export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {host: HTMLElement, callback: () => Promise<boolean>} {
+/**
+ * Peptides analysis parameters UI
+ * @param df - Dataframe with peptides
+ * @param [col] - Peptides column
+ * @return - UI host and analysis start callback
+ */
+export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): DialogParameters {
   const logoHost = ui.div();
   let seqColInput: DG.InputBase | null = null;
   if (typeof col === 'undefined') {
-    const sequenceColumns = df.columns.toList().filter((dfCol) => dfCol.semType === DG.SEMTYPE.MACROMOLECULE);
-    const potentialCol = DG.Utils.firstOrNull(sequenceColumns);
+    // Building UI for starting analysis from dialog (top menu)
+    const potentialCol = DG.Utils.firstOrNull(
+      df.columns.toList().filter((dfCol) => dfCol.semType === DG.SEMTYPE.MACROMOLECULE));
     if (potentialCol === null)
       throw new Error('Peptides Error: table doesn\'t contain sequence columns');
     else if (potentialCol.stats.missingValueCount !== 0)
       grok.shell.info('Sequences column contains missing values. They will be ignored during analysis');
 
+
     seqColInput = ui.columnInput('Sequence', df, potentialCol, () => {
       const seqCol = seqColInput!.value;
-      if (!(seqCol.getTag(DG.TAGS.SEMTYPE) === DG.SEMTYPE.MACROMOLECULE)) {
-        grok.shell.warning('Peptides analysis only works with macromolecules');
-        seqColInput!.value = potentialCol;
-      }
       $(logoHost).empty().append(ui.wait(async () => {
         const viewer = await df.plot.fromType('WebLogo', {sequenceColumnName: seqCol.name});
         viewer.root.style.setProperty('height', '130px');
@@ -66,6 +67,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {h
     };
   }
 
+  // Activity column properties
   let scaledCol: DG.Column<number>;
   const defaultActivityColumn: DG.Column<number> | null = df.col('activity') || df.col('IC50') ||
     DG.Utils.firstOrNull(df.columns.numerical);
@@ -77,13 +79,8 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {h
       scaledCol = scaleActivity(activityColumnChoice.value!, currentMethod);
 
       const hist = DG.DataFrame.fromColumns([scaledCol]).plot.histogram({
-        filteringEnabled: false,
-        valueColumnName: C.COLUMNS_NAMES.ACTIVITY,
-        legendVisibility: 'Never',
-        showXAxis: true,
-        showColumnSelector: false,
-        showRangeSlider: false,
-        showBinSelector: false,
+        filteringEnabled: false, valueColumnName: C.COLUMNS_NAMES.ACTIVITY, legendVisibility: 'Never', showXAxis: true,
+        showColumnSelector: false, showRangeSlider: false, showBinSelector: false,
       });
       histogramHost.lastChild?.remove();
       histogramHost.appendChild(hist.root);
@@ -96,7 +93,6 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {h
     if (activityColumnChoice.value!.stats.missingValueCount !== 0)
       grok.shell.info('Activity column contains missing values. They will be ignored during analysis');
   };
-  //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});
   activityColumnChoice.setTooltip('Numerical activity column');
@@ -106,15 +102,11 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {h
   activityColumnChoice.fireChanged();
   activityScalingMethod.fireChanged();
 
-  const targetColumnChoice = ui.columnInput('Target', df, null, null, {filter: (col: DG.Column) => col.type === DG.TYPE.STRING});
-  targetColumnChoice.setTooltip('Optional. Target represents a unique binding construct for every peptide in the data. ' +
-    'Target can be used to split mutation cliff analysis for peptides specific to a certain set of targets');
-  targetColumnChoice.nullable = true;
-
-  const inputsList = [activityColumnChoice, activityScalingMethod, clustersColumnChoice, targetColumnChoice];
+  const inputsList = [activityColumnChoice, activityScalingMethod, clustersColumnChoice];
   if (seqColInput !== null)
     inputsList.splice(0, 0, seqColInput);
 
+
   const bitsetChanged = df.filter.onChanged.subscribe(() => activityScalingMethodState());
 
   const startAnalysisCallback = async (): Promise<boolean> => {
@@ -122,7 +114,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {h
     bitsetChanged.unsubscribe();
     if (sequencesCol) {
       const model = await startAnalysis(activityColumnChoice.value!, sequencesCol, clustersColumnChoice.value, df,
-        scaledCol, activityScalingMethod.value ?? C.SCALING_METHODS.NONE, targetColumnChoice.value, {addSequenceSpace: true});
+        scaledCol, activityScalingMethod.value ?? C.SCALING_METHODS.NONE, {addSequenceSpace: true});
       return model !== null;
     }
     return false;
@@ -155,75 +147,78 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): {h
   return {host: mainHost, callback: startAnalysisCallback};
 }
 
-type AnalysisOptions = {addSequenceSpace?: boolean};
-
+type AnalysisOptions = { addSequenceSpace?: boolean };
+
+/**
+ * Creates dataframe to use in analysis, model instance and adds viewers
+ * @param activityColumn - Activity column
+ * @param peptidesCol - Peptides column
+ * @param clustersColumn - Clusters column or null
+ * @param sourceDf - Source dataframe
+ * @param scaledCol - Scaled activity column
+ * @param scaling - Activity scaling method
+ * @param options - Additional options
+ * @return - Peptides model instance or null
+ */
 export async function startAnalysis(activityColumn: DG.Column<number>, peptidesCol: DG.Column<string>,
-  clustersColumn: DG.Column | null, currentDf: DG.DataFrame, scaledCol: DG.Column<number>, scaling: C.SCALING_METHODS,
-  targetColumn: DG.Column<string> | null = null, options: AnalysisOptions = {}): Promise<PeptidesModel | null> {
-  const progress = DG.TaskBarProgressIndicator.create('Loading SAR...');
+  clustersColumn: DG.Column | null, sourceDf: DG.DataFrame, scaledCol: DG.Column<number>, scaling: C.SCALING_METHODS,
+  options: AnalysisOptions = {}): Promise<PeptidesModel | null> {
   let model = null;
-  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;
-    newDfCols.add(scaledCol);
-    for (const col of currentDf.columns) {
-      if (col.getTag(C.TAGS.ANALYSIS_COL) !== `${true}`) {
-        if (col.name.toLowerCase() === scaledCol.name.toLowerCase())
-          col.name = currentDf.columns.getUnusedName(col.name);
-        newDfCols.add(col);
-      }
+  if (activityColumn.type !== DG.COLUMN_TYPE.FLOAT && activityColumn.type !== DG.COLUMN_TYPE.INT) {
+    grok.shell.error('The activity column must be of numeric type!');
+    return model;
+  }
+  const progress = DG.TaskBarProgressIndicator.create('Loading SAR...');
+
+  // Prepare new DF
+  const newDf = DG.DataFrame.create(sourceDf.rowCount);
+  newDf.name = 'Peptides analysis';
+  const newDfCols = newDf.columns;
+  newDfCols.add(scaledCol);
+  for (const col of sourceDf.columns) {
+    if (col.getTag(C.TAGS.ANALYSIS_COL) !== `${true}`) {
+      if (col.name.toLowerCase() === scaledCol.name.toLowerCase())
+        col.name = sourceDf.columns.getUnusedName(col.name);
+
+
+      newDfCols.add(col);
     }
+  }
+
+  const settings: type.PeptidesSettings = {
+    sequenceColumnName: peptidesCol.name, activityColumnName: activityColumn.name, activityScaling: scaling,
+    columns: {}, showDendrogram: false, sequenceSpaceParams: new type.SequenceSpaceParams(),
+  };
 
-    newDf.name = 'Peptides analysis';
-    const settings: type.PeptidesSettings = {
-      sequenceColumnName: peptidesCol.name,
+  if (clustersColumn) {
+    const clusterCol = newDf.getCol(clustersColumn.name);
+    if (clusterCol.type !== DG.COLUMN_TYPE.STRING)
+      newDfCols.replace(clusterCol, clusterCol.convertTo(DG.COLUMN_TYPE.STRING));
+  }
+  newDf.setTag(C.TAGS.SETTINGS, JSON.stringify(settings));
+
+  const bitset = DG.BitSet.create(sourceDf.rowCount,
+    (i) => !activityColumn.isNone(i) && !peptidesCol.isNone(i) && sourceDf.filter.get(i));
+
+  // 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(bitset));
+  model.init(settings);
+  if (clustersColumn) {
+    const lstProps: ILogoSummaryTable = {
+      clustersColumnName: clustersColumn.name, sequenceColumnName: peptidesCol.name, activityScaling: scaling,
       activityColumnName: activityColumn.name,
-      scaling: scaling,
-      columns: {},
-      maxMutations: 1,
-      minActivityDelta: 0,
-      showDendrogram: false,
     };
-    if (targetColumn !== null)
-      settings.targetColumnName = targetColumn.name;
-
-    if (clustersColumn) {
-      const clusterCol = newDf.getCol(clustersColumn.name);
-      if (clusterCol.type !== DG.COLUMN_TYPE.STRING)
-        newDfCols.replace(clusterCol, clusterCol.convertTo(DG.COLUMN_TYPE.STRING));
-      settings.clustersColumnName = clustersColumn.name;
-    }
-    newDf.setTag(C.TAGS.SETTINGS, JSON.stringify(settings));
-
-    let monomerType: string;
-    if (peptidesCol.getTag(DG.TAGS.UNITS) === NOTATION.HELM) {
-      const sampleSeq = peptidesCol.get(0)!;
-      monomerType = sampleSeq.startsWith('PEPTIDE') ? 'HELM_AA' : 'HELM_BASE';
-    } else {
-      const alphabet = peptidesCol.tags[C.TAGS.ALPHABET];
-      monomerType = alphabet === 'DNA' || alphabet === 'RNA' ? 'HELM_BASE' : 'HELM_AA';
-    }
-    const dfUuid = uuid.v4();
-    newDf.setTag(C.TAGS.UUID, dfUuid);
-    newDf.setTag('monomerType', monomerType);
-
-    const bitset = DG.BitSet.create(currentDf.rowCount,
-      (i) => !activityColumn.isNone(i) && !peptidesCol.isNone(i) && currentDf.filter.get(i));
-
-    // 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(bitset));
-    if (clustersColumn)
-      await model.addLogoSummaryTable();
-    await model.addMonomerPosition();
-    await model.addMostPotentResidues();
-
-    // FIXME: enable by default for tests
-    if (options.addSequenceSpace ?? false)
-      model.addSequenceSpace();
-  } else
-    grok.shell.error('The activity column must be of numeric type!');
+    await model.addLogoSummaryTable(lstProps);
+  }
+  await model.addMonomerPosition();
+  await model.addMostPotentResidues();
+
+  // FIXME: enable by default for tests
+  if (options.addSequenceSpace ?? false)
+    model.addSequenceSpace();
+
+
   progress.close();
   return model;
 }

package/src/widgets/selection.ts

@@ -1,35 +1,52 @@
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {PeptidesModel} from '../model';
-
 import wu from 'wu';
-import {COLUMNS_NAMES} from '../utils/constants';
 import {addExpandIcon} from '../utils/misc';
-import {CellRendererOptions, setWebLogoRenderer, WebLogoBounds} from '../utils/cell-renderer';
+import {setWebLogoRenderer, WebLogoBounds, WebLogoCellRendererOptions} from '../utils/cell-renderer';
 import {CachedWebLogoTooltip, SelectionItem} from '../utils/types';
 import {TooltipOptions} from '../utils/tooltips';
 import {calculateMonomerPositionStatistics} from '../utils/algorithms';
+import {AggregationColumns} from '../utils/statistics';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
+
+export type SelectionWidgetOptions = {
+  tableSelection: DG.BitSet, gridColumns: DG.GridColumnList, positionColumns: DG.Column<string>[],
+  activityColumn: DG.Column<number>, columns: AggregationColumns, colorPalette: SeqPalette, isAnalysis: boolean,
+};
 
-export function getSelectionWidget(table: DG.DataFrame, model: PeptidesModel): HTMLElement {
-  const compBitset = model.getVisibleSelection();
-  if (compBitset.trueCount === 0)
+/**
+ * Creates selection grid with WebLogo rendered in its header.
+ * @param table - table with selected sequences.
+ * @param options - options for selection widget.
+ * @return - selection grid.
+ */
+export function getSelectionWidget(table: DG.DataFrame, options: SelectionWidgetOptions): HTMLElement {
+  if (options.tableSelection.trueCount === 0)
     return ui.divText('No compounds selected');
+
+
   const newTable = DG.DataFrame.create(table.rowCount);
   newTable.name = 'Selected compounds';
-  newTable.filter.copyFrom(compBitset);
-  const sourceGrid = model.analysisView.grid;
+  newTable.filter.copyFrom(options.tableSelection);
   const numericalCols = wu(table.columns.numerical);
-  for (let gridColIdx = 1; gridColIdx < sourceGrid.columns.length; gridColIdx++) {
-    const gridCol = sourceGrid.columns.byIndex(gridColIdx)!;
+  for (let gridColIdx = 1; gridColIdx < options.gridColumns.length; gridColIdx++) {
+    const gridCol = options.gridColumns.byIndex(gridColIdx)!;
     if (!gridCol.visible)
       continue;
+
+
     const sourceCol = gridCol.column!;
+    if (sourceCol.type === DG.COLUMN_TYPE.BOOL)
+      continue;
+
+
     const sourceColRawData = sourceCol.getRawData();
     const sourceColCategories = sourceCol.categories;
-    const getValue = numericalCols.some((col) => col.name === sourceCol.name) ? (i: number): number => sourceColRawData[i] :
+    const getValue = numericalCols
+      .some((col) => col.name === sourceCol.name) ? (i: number): number => sourceColRawData[i] :
       (i: number): string => sourceColCategories[sourceColRawData[i]];
-    const col = sourceCol.name === COLUMNS_NAMES.ACTIVITY ?
+    const col = sourceCol.name === options.activityColumn.name ?
       newTable.columns.addNewFloat(gridCol.name).init((i) => getValue(i)) :
       newTable.columns.addNewVirtual(gridCol.name, (i) => getValue(i), sourceCol.type as DG.TYPE);
     for (const [tag, value] of sourceCol.tags)
@@ -55,22 +72,39 @@ export function getSelectionWidget(table: DG.DataFrame, model: PeptidesModel): H
   const gridHost = ui.box(grid.root);
   gridHost.style.marginLeft = '0px';
   setTimeout(() => {
-    for (let gridColIdx = 1; gridColIdx < sourceGrid.columns.length; gridColIdx++) {
-      const gridCol = sourceGrid.columns.byIndex(gridColIdx)!;
-      if (!gridCol.visible)
+    for (let gridColIdx = 1; gridColIdx < options.gridColumns.length; gridColIdx++) {
+      const originalGridCol = options.gridColumns.byIndex(gridColIdx)!;
+      if (!originalGridCol.visible)
+        continue;
+
+
+      if (!grid.col(originalGridCol.name))
         continue;
-      grid.col(gridCol.name)!.width = gridCol.width;
+
+
+      grid.col(originalGridCol.name)!.width = originalGridCol.width;
     }
   }, 500);
 
-  const mpStats = calculateMonomerPositionStatistics(grid.dataFrame, model.positionColumns.toArray());
+  const mpStats = calculateMonomerPositionStatistics(options.activityColumn, newTable.filter,
+    options.positionColumns, {isFiltered: newTable.filter.anyTrue || newTable.filter.anyFalse});
 
-  const cachedWebLogoTooltip: CachedWebLogoTooltip = {bar: '', tooltip: null};
-  const webLogoBounds: WebLogoBounds = {};
-  const cellRendererOptions: CellRendererOptions = {isSelectionTable: true, cachedWebLogoTooltip, webLogoBounds};
+  const cachedWebLogoTooltip: () => CachedWebLogoTooltip = () => {
+    return {bar: '', tooltip: null};
+  };
+  const webLogoBounds: () => WebLogoBounds = () => {
+    return {};
+  };
+  const cellRendererOptions: WebLogoCellRendererOptions = {
+    isSelectionTable: true, cachedWebLogoTooltip, webLogoBounds,
+    colorPalette: () => options.colorPalette,
+  };
   const tooltipOptions: TooltipOptions = {x: 0, y: 0, monomerPosition: {} as SelectionItem, mpStats};
 
-  setWebLogoRenderer(grid, model, cellRendererOptions, tooltipOptions);
+  if (options.isAnalysis) {
+    setWebLogoRenderer(grid, mpStats, options.positionColumns, options.activityColumn, cellRendererOptions,
+      tooltipOptions);
+  }
 
   return gridHost;
 }

package/src/widgets/settings.ts

@@ -1,4 +1,5 @@
 import * as ui from 'datagrok-api/ui';
+import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
 import * as type from '../utils/types';
@@ -8,16 +9,17 @@ import {PeptidesModel, VIEWER_TYPE} from '../model';
 import $ from 'cash-dom';
 import wu from 'wu';
 import {getTreeHelperInstance} from '../package';
+import { MmDistanceFunctionsNames as distFNames } from '@datagrok-libraries/ml/src/macromolecule-distance-functions';
 
-type PaneInputs = {[paneName: string]: DG.InputBase[]};
-type SettingsElements = {dialog: DG.Dialog, accordion: DG.Accordion, inputs: PaneInputs};
+type PaneInputs = { [paneName: string]: DG.InputBase[] };
+type SettingsElements = { dialog: DG.Dialog, accordion: DG.Accordion, inputs: PaneInputs };
 
 export enum SETTINGS_PANES {
   GENERAL = 'General',
   VIEWERS = 'Viewers',
-  MUTATION_CLIFFS = 'Mutation Cliffs',
   COLUMNS = 'Columns',
-};
+  SEQUENCE_SPACE = 'Sequence space',
+}
 
 export enum GENERAL_INPUTS {
   ACTIVITY = 'Activity',
@@ -28,45 +30,57 @@ export enum VIEWERS_INPUTS {
   DENDROGRAM = VIEWER_TYPE.DENDROGRAM,
 }
 
-export enum MUTATION_CLIFFS_INPUTS {
-  MAX_MUTATIONS = 'Max mutations',
-  MIN_ACTIVITY_DELTA = 'Min activity delta',
-}
-
 export enum COLUMNS_INPUTS {
   IS_INCLUDED = '',
   AGGREGATION = 'Aggregation',
 }
+export enum SEQUENCE_SPACE_INPUTS {
+  DISTANCE_FUNCTION = 'Distance function',
+  GAP_OPEN = 'Gap open penalty',
+  GAP_EXTEND = 'Gap extend penalty',
+  CLUSTER_EMBEDDINGS = 'Cluster embeddings',
+  EPSILON = 'Epsilon',
+  MIN_PTS = 'Minimum points',
+  FINGERPRINT_TYPE = 'Fingerprint type',
+}
+
 
 export const PANES_INPUTS = {
   [SETTINGS_PANES.GENERAL]: GENERAL_INPUTS,
   [SETTINGS_PANES.VIEWERS]: VIEWERS_INPUTS,
-  [SETTINGS_PANES.MUTATION_CLIFFS]: MUTATION_CLIFFS_INPUTS,
   [SETTINGS_PANES.COLUMNS]: COLUMNS_INPUTS,
+  [SETTINGS_PANES.SEQUENCE_SPACE]: SEQUENCE_SPACE_INPUTS,
 };
 
-//TODO: show sliderInput values
+/**
+ * Creates settings dialog for peptides analysis.
+ * @param model - Peptides analysis model.
+ * @return - Settings dialog elements.
+ */
 export function getSettingsDialog(model: PeptidesModel): SettingsElements {
+  if (model.settings == null)
+    grok.log.error('PeptidesError: Settings are not initialized');
+
   const accordion = ui.accordion();
   const settings = model.settings;
-  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 currentScaling = settings?.activityScaling ?? C.SCALING_METHODS.NONE;
+  const currentColumns = settings?.columns ?? {};
 
-  const result: type.PeptidesSettings = {};
+  const result: type.PartialPeptidesSettings = {};
   const inputs: PaneInputs = {};
+  const seqSpaceParams = settings?.sequenceSpaceParams ?? new type.SequenceSpaceParams();
 
   // General pane options
   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 && col.stats.missingValueCount === 0});
+    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 && col.stats.missingValueCount === 0,
+    });
   activityCol.setTooltip('Numeric activity column');
   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>;
+      () => result.activityScaling = activityScaling.value as C.SCALING_METHODS) as DG.InputBase<C.SCALING_METHODS>;
   activityScaling.setTooltip('Activity column transformation method');
 
   accordion.addPane(SETTINGS_PANES.GENERAL, () => ui.inputs([activityCol, activityScaling]), true);
@@ -94,35 +108,15 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   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, 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.setTooltip('Maximum number of mutations between reference and mutated sequences');
-  maxMutations.addPostfix((settings.maxMutations ?? 1).toString());
-  const minActivityDelta = ui.sliderInput(MUTATION_CLIFFS_INPUTS.MIN_ACTIVITY_DELTA, currentMinActivityDelta, 0,
-    100, () => {
-      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.setTooltip('Minimum activity difference between reference and mutated sequences');
-  minActivityDelta.addPostfix((settings.minActivityDelta ?? 0).toString());
-  accordion.addPane(SETTINGS_PANES.MUTATION_CLIFFS, () => ui.inputs([maxMutations, minActivityDelta]), true);
-  inputs[SETTINGS_PANES.MUTATION_CLIFFS] = [maxMutations, minActivityDelta];
-
   // Columns to include pane options
   const inputsRows: HTMLElement[] = [];
   const includedColumnsInputs: DG.InputBase[] = [];
   for (const col of model.df.columns.numerical) {
     const colName = col.name;
-    if (colName === settings.activityColumnName || colName === C.COLUMNS_NAMES.ACTIVITY)
+    if (colName === settings!.activityColumnName || colName === C.COLUMNS_NAMES.ACTIVITY)
       continue;
 
+
     const isIncludedInput = ui.boolInput(COLUMNS_INPUTS.IS_INCLUDED, typeof (currentColumns)[colName] !== 'undefined',
       () => {
         result.columns ??= {};
@@ -134,7 +128,8 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
             delete result.columns;
         }
       }) as DG.InputBase<boolean>;
-    isIncludedInput.setTooltip('Include aggregated column value in tooltips, Logo Summary Table and Distribution panel');
+    isIncludedInput.setTooltip('Include aggregated column value in tooltips, Logo Summary Table and ' +
+      'Distribution panel');
 
     const aggregationInput = ui.choiceInput(COLUMNS_INPUTS.AGGREGATION, (currentColumns)[colName] ?? DG.AGG.AVG,
       Object.values(DG.STATS), () => {
@@ -159,6 +154,61 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
     inputs[SETTINGS_PANES.COLUMNS] = includedColumnsInputs;
   }
 
+  // Sequence space pane options
+  const modifiedSeqSpaceParams: Partial<type.SequenceSpaceParams> = {};
+  function onSeqSpaceParamsChange(fieldName: keyof type.SequenceSpaceParams, value: any) {
+    correctSeqSpaceInputs();
+    if (value === null || value === undefined || value === '')
+      return;
+    modifiedSeqSpaceParams[fieldName] = value;
+    let isAllSame = true;
+    for (const [key, val] of Object.entries(modifiedSeqSpaceParams)) {
+      if (val !== seqSpaceParams[key as keyof type.SequenceSpaceParams]) {
+        isAllSame = false;
+        break;
+      }
+    }
+    if (isAllSame)
+      delete result.sequenceSpaceParams;
+    else
+      result.sequenceSpaceParams = {...seqSpaceParams, ...modifiedSeqSpaceParams};
+  }
+
+  function toggleInputs(nwInputs: DG.InputBase[], condition: boolean) {
+    nwInputs.forEach((input) => {
+      if (condition)
+        input.root.style.display = 'flex';
+      else
+        input.root.style.display = 'none';
+    });
+  }
+
+  const distanceFunctionInput = ui.choiceInput(SEQUENCE_SPACE_INPUTS.DISTANCE_FUNCTION, seqSpaceParams.distanceF,
+  [distFNames.NEEDLEMANN_WUNSCH, distFNames.HAMMING, distFNames.LEVENSHTEIN, distFNames.MONOMER_CHEMICAL_DISTANCE],
+   () => onSeqSpaceParamsChange('distanceF', distanceFunctionInput.value));
+  distanceFunctionInput.setTooltip('Distance function');
+  const gapOpenInput = ui.floatInput(SEQUENCE_SPACE_INPUTS.GAP_OPEN, seqSpaceParams.gapOpen, () => onSeqSpaceParamsChange('gapOpen', gapOpenInput.value));
+  const gapExtendInput = ui.floatInput(SEQUENCE_SPACE_INPUTS.GAP_EXTEND, seqSpaceParams.gapExtend, () => onSeqSpaceParamsChange('gapExtend', gapExtendInput.value));
+  const clusterEmbeddingsInput = ui.boolInput(SEQUENCE_SPACE_INPUTS.CLUSTER_EMBEDDINGS, seqSpaceParams.clusterEmbeddings ?? false,
+    () => onSeqSpaceParamsChange('clusterEmbeddings', clusterEmbeddingsInput.value));
+  clusterEmbeddingsInput.setTooltip('Cluster embeddings using DBSCAN algorithm');
+  const epsilonInput = ui.floatInput(SEQUENCE_SPACE_INPUTS.EPSILON, seqSpaceParams.epsilon, () => onSeqSpaceParamsChange('epsilon', epsilonInput.value));
+  epsilonInput.setTooltip('Epsilon parameter for DBSCAN. Minimum distance between two points to be considered as a cluster');
+  const minPtsInput = ui.intInput(SEQUENCE_SPACE_INPUTS.MIN_PTS, seqSpaceParams.minPts, () => onSeqSpaceParamsChange('minPts', minPtsInput.value));
+  minPtsInput.setTooltip('Minimum number of points in a cluster');
+  const fingerprintTypesInput = ui.choiceInput('Fingerprint type', seqSpaceParams.fingerprintType, ['Morgan', 'RDKit', 'Pattern'],
+    () => onSeqSpaceParamsChange('fingerprintType', fingerprintTypesInput.value));
+  function correctSeqSpaceInputs() {
+    toggleInputs([gapOpenInput, gapExtendInput], distanceFunctionInput.value === distFNames.NEEDLEMANN_WUNSCH);
+    toggleInputs([epsilonInput, minPtsInput], clusterEmbeddingsInput.value === true);
+    toggleInputs([fingerprintTypesInput],
+      distanceFunctionInput.value === distFNames.MONOMER_CHEMICAL_DISTANCE || distanceFunctionInput.value === distFNames.NEEDLEMANN_WUNSCH);
+  }
+  correctSeqSpaceInputs();
+
+  const seqSpaceInputs = [distanceFunctionInput, fingerprintTypesInput, gapOpenInput, gapExtendInput, clusterEmbeddingsInput, epsilonInput, minPtsInput];
+  accordion.addPane(SETTINGS_PANES.SEQUENCE_SPACE, () => ui.inputs(seqSpaceInputs), true);
+  inputs[SETTINGS_PANES.SEQUENCE_SPACE] = seqSpaceInputs;
   const dialog = ui.dialog('Peptides settings').add(accordion);
   dialog.root.style.width = '400px';
   dialog.onOK(() => model.settings = result);

package/src/workers/dimensionality-reducer.ts

@@ -3,12 +3,11 @@ import {KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
 
 /**
  * Worker thread receiving data function.
- *
- * @param {any[]} columnData Samples to process.
- * @param {string} method Embedding method.
- * @param {string} measure Distance metric.
- * @param {any} options Options to pass to algorithm.
- * @return {any} Embedding (and distance matrix where applicable).
+ * @param columnData Samples to process.
+ * @param method Embedding method.
+ * @param measure Distance metric.
+ * @param options Options to pass to algorithm.
+ * @return Embedding (and distance matrix where applicable).
  */
 function onMessage(columnData: any[], method: KnownMethods, measure: KnownMetrics, options: any): any {
   const reducer = new DimensionalityReducer(columnData, method, measure, options);

package/src/workers/mutation-cliffs-worker.ts

@@ -1,14 +1,9 @@
-
 onmessage = async (event): Promise<void> => {
-  const {startIdx, endIdx, activityArray, monomerInfoArray, settings, currentTargetIdx, targetOptions} = event.data;
-  // const monomers1: string[] = [];
-  // const monomers2: string[] = [];
+  const {startIdx, endIdx, activityArray, monomerInfoArray, settings, currentTargetIdx} = event.data;
   const pos: string[] = [];
   const seq1Idxs: number[] = [];
   const seq2Idxs: number[] = [];
   const chunkSize = endIdx - startIdx;
-  //const mi = startRow;
-  //const mj = startCol;
   let cnt = 0;
   const startRow = activityArray.length - 2 - Math.floor(
     Math.sqrt(-8 * startIdx + 4 * activityArray.length * (activityArray.length - 1) - 7) / 2 - 0.5);
@@ -17,8 +12,8 @@ onmessage = async (event): Promise<void> => {
   let seq2Idx = startCol;
   const tempData = new Array(monomerInfoArray.length);
   while (cnt < chunkSize) {
-    if (!(currentTargetIdx !== -1 && (targetOptions.targetCol?.rawData[seq1Idx] !== currentTargetIdx ||
-        targetOptions.targetCol?.rawData[seq2Idx] !== currentTargetIdx))) {
+    if (!(currentTargetIdx !== -1 && (settings.targetCol?.rawData[seq1Idx] !== currentTargetIdx ||
+      settings.targetCol?.rawData[seq2Idx] !== currentTargetIdx))) {
       let substCounter = 0;
       const activityValSeq1 = activityArray[seq1Idx];
       const activityValSeq2 = activityArray[seq2Idx];
@@ -39,8 +34,6 @@ onmessage = async (event): Promise<void> => {
 
           tempData[tempDataIdx++] = {
             pos: monomerInfo.name,
-            // seq1monomer: monomerInfo.cat![seq1categoryIdx],
-            // seq2monomer: monomerInfo.cat![seq2categoryIdx],
             seq1Idx: seq1Idx,
             seq2Idx: seq2Idx,
           };
@@ -49,10 +42,6 @@ onmessage = async (event): Promise<void> => {
           for (let i = 0; i < tempDataIdx; i++) {
             const tempDataElement = tempData[i];
             const position = tempDataElement.pos;
-            // const seq1monomer = tempDataElement.seq1monomer;
-            // const seq2monomer = tempDataElement.seq2monomer;
-            // monomers1.push(seq1monomer);
-            // monomers2.push(seq2monomer);
             pos.push(position);
             seq1Idxs.push(seq1Idx);
             seq2Idxs.push(seq2Idx);
@@ -68,8 +57,6 @@ onmessage = async (event): Promise<void> => {
     }
   }
   postMessage({
-    // monomers1: monomers1,
-    // monomers2: monomers2,
     pos: pos,
     seq1Idxs: new Uint32Array(seq1Idxs),
     seq2Idxs: new Uint32Array(seq2Idxs),