@datagrok/peptides 1.25.1 → 1.26.1

package/src/viewers/mutation-cliffs-viewer.ts

@@ -0,0 +1,378 @@
+/* eslint-disable max-len */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {PeptideUtils} from '../peptideUtils';
+import wu from 'wu';
+import {MutationCliffs} from '../utils/types';
+import {ParallelMutationCliffs} from '../utils/parallel-mutation-cliffs';
+import $ from 'cash-dom';
+import {PeptidesModel} from '../model';
+import {extractColInfo} from '../utils/misc';
+import {Subscription} from 'rxjs';
+export type MutationCliffsWithMonomers = {
+  cliffs: MutationCliffs,
+  monomers: string[]
+}
+
+export class MutationCliffsViewer extends DG.JsViewer {
+  public sequenceColumnName: string;
+  public seriesColumnName: string;
+  public activityColumnName: string;
+  public position = 1;
+  public yAxisType: 'Linear' | 'Logarithmic' = 'Linear';
+  constructor() {
+    super();
+    this.sequenceColumnName = this.column('sequence', {semType: DG.SEMTYPE.MACROMOLECULE, nullable: false});
+    this.seriesColumnName = this.column('series', {columnTypeFilter: 'categorical', nullable: false});
+    this.activityColumnName = this.column('activity', {columnTypeFilter: 'numerical', nullable: false});
+    this.position = this.int('position', 1, {nullable: false, showSlider: false, min: 1, max: 100, showPlusMinus: true, description: 'Position in the sequence to analyze (1 Based).', category: 'Data'});
+    this.yAxisType = this.string('yAxisType', 'Linear', {choices: ['Linear', 'Logarithmic'], description: 'Y-Axis scale type.', nullable: false, category: 'Data'}) as 'Linear' | 'Logarithmic';
+  }
+
+  onTableAttached(): void {
+    super.onTableAttached();
+    const seqCol = this.dataFrame.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
+    if (seqCol)
+        this.getProperty('sequenceColumnName')!.set(this, seqCol.name);
+    this.getProperty('activityColumnName')!.set(this, wu(this.dataFrame.columns.numerical).next().value.name);
+    const seriesCol = wu(this.dataFrame.columns.categorical)?.filter((c) => c.name !== this.sequenceColumnName && c.name?.toLowerCase().includes('series')).next()?.value;
+    if (seriesCol)
+        this.getProperty('seriesColumnName')!.set(this, seriesCol.name);
+
+    this.subs.push(DG.debounce(this.dataFrame.onFilterChanged, 200).subscribe(() => {
+      this.clearCache();
+      this.debouncedRender();
+    }));
+    this.debouncedRender();
+
+
+    this.subs.push(grok.events.onContextMenu.subscribe((e) => {
+      if (e.causedBy && e.causedBy.target && this._lineChart?.root.contains(e.causedBy.target)) {
+        e.causedBy.preventDefault();
+        e.causedBy.stopPropagation();
+        e.causedBy.stopImmediatePropagation();
+      }
+    }));
+  }
+
+  private _mutationCliffsData: Promise<MutationCliffsWithMonomers> | null = null;
+  private get mutationCliffsData(): Promise<MutationCliffsWithMonomers> {
+    if (this._mutationCliffsData)
+      return this._mutationCliffsData;
+
+    if (!this.activityColumnName || !this.sequenceColumnName || !this.position)
+      throw new Error('Activity column or Sequence column is not set, or position is invalid');
+
+    this._mutationCliffsData = new Promise<MutationCliffsWithMonomers>(async (resolve, reject) => {
+      try {
+        // const seqCol = this.dataFrame.col(this.sequenceColumnName)!;
+        const activityColRawData = this.dataFrame.col(this.activityColumnName)!.getRawData();
+
+        // const seqHelper = PeptideUtils.getSeqHelper();
+        // const seqHandler = seqHelper.getSeqHandler(seqCol);
+        // get single position
+        // const monomersAtPosition = seqHandler.getMonomersAtPosition(this.position - 1, true);
+        // const monomerCol = DG.Column.fromList('string', `Monomers at pos ${this.position}`, monomersAtPosition);
+        // const monomerRawData: RawColumn = {
+        //   rawData: monomerCol.getRawData(),
+        //   name: monomerCol.name,
+        //   cat: monomerCol.categories,
+        // };
+
+        const positionColumns = this.positionColumns;
+        const monomersAtPosition = positionColumns[this.position - 1].toList() as string[];
+        const monomerRawData = positionColumns.map(extractColInfo);
+
+        const mutationCliffs = await new ParallelMutationCliffs().calc(activityColRawData, monomerRawData,
+          {maxMutations: 1, minActivityDelta: 0, filter: this.dataFrame.filter.anyFalse ? new Uint32Array(this.dataFrame.filter.getBuffer().buffer) : undefined, singlePosition: {position: this.position - 1}},
+        );
+        resolve({cliffs: mutationCliffs, monomers: monomersAtPosition});
+      } catch (error) {
+        reject(error);
+      }
+    });
+    return this._mutationCliffsData;
+  }
+
+  private _dfSubs: Subscription[] = [];
+
+  private async calculateDf() {
+    if (!this.dataFrame || !this.activityColumnName || !this.sequenceColumnName || !this.position)
+      throw new Error('Activity column or Sequence column is not set, or position is invalid');
+    const mutationCliffs = await this.mutationCliffsData;
+    const uniqueIndexes = new Set<number>();
+    mutationCliffs.cliffs.forEach((positionMap) => {
+      positionMap.forEach((mcData) => { // should be only one position
+        Array.from(mcData.entries()).forEach(([from, toIndexes]) => {
+          uniqueIndexes.add(Number(from));
+          toIndexes.forEach((toIdx) => uniqueIndexes.add(Number(toIdx)));
+        });
+      });
+    });
+    const indexesArray = Array.from(uniqueIndexes.values()).sort((a, b) => a - b);
+    const dataFrameIndexToViewerDfIndex = new Map<number, number>();
+    indexesArray.forEach((dataFrameIdx, viewerDfIdx) => {
+      dataFrameIndexToViewerDfIndex.set(dataFrameIdx, viewerDfIdx);
+    });
+    const monomers = indexesArray.map((i) => mutationCliffs.monomers[i]);
+    const activityColRawData = this.dataFrame.col(this.activityColumnName)!.getRawData();
+    const activityValues = indexesArray.map((i) => activityColRawData[i] as number);
+    const monomerCol = DG.Column.fromList('string', `Position ${this.position}`, monomers);
+    const activityCol = DG.Column.fromList('double', this.activityColumnName, activityValues);
+    // add original indexes to be able to trace back
+
+    const cols = [monomerCol, activityCol];
+    if (this.seriesColumnName) {
+      const seriesColRawData = this.dataFrame.col(this.seriesColumnName)!.getRawData();
+      const seriesCats = this.dataFrame.col(this.seriesColumnName)!.categories;
+      const seriesValues = indexesArray.map((i) => seriesCats[seriesColRawData[i]] as string);
+      const seriesCol = DG.Column.fromList('string', this.seriesColumnName, seriesValues);
+      cols.push(seriesCol);
+    }
+    const df = DG.DataFrame.fromColumns(cols);
+    // add dummy columns corresponding to other numerical columns
+
+    Array.from(this.dataFrame.columns.numerical)
+      .filter((c) => c.name !== this.activityColumnName && c.name !== this.seriesColumnName)
+      .forEach((c) => {
+        df.columns.addNew(c.name, c.type);
+      });
+
+    // mouse over row handling back and forth
+    this._dfSubs.push(
+      df.onMouseOverRowChanged.subscribe((_) => {
+        if (df.mouseOverRowIdx >= 0) {
+          const originalIdx = indexesArray[df.mouseOverRowIdx];
+          this.dataFrame.mouseOverRowIdx = originalIdx;
+        }
+      }),
+    );
+    this._dfSubs.push(
+      this.dataFrame.onMouseOverRowChanged.subscribe((_) => {
+        if (this.dataFrame.mouseOverRowIdx >= 0) {
+          const viewerDfIdx = dataFrameIndexToViewerDfIndex.get(this.dataFrame.mouseOverRowIdx);
+          if (viewerDfIdx != undefined)
+            df.mouseOverRowIdx = viewerDfIdx;
+          else
+            df.mouseOverRowIdx = -1;
+        }
+      }),
+    );
+
+    this._dfSubs.push(
+      df.onCurrentRowChanged.subscribe((_) => {
+        if (df.currentRowIdx >= 0) {
+          const originalIdx = indexesArray[df.currentRowIdx];
+          this.dataFrame.currentRowIdx = originalIdx;
+        }
+      }),
+    );
+
+    let firedFromViewer = false;
+    let firedFromTable = false;
+    // Handle selection
+    this._dfSubs.push(
+      DG.debounce(df.onSelectionChanged, 100).subscribe((_) => {
+        const selected = df.selection;
+        if (firedFromViewer) {
+          firedFromViewer = false;
+          return;
+        }
+        firedFromTable = true;
+        this.dataFrame.selection.setAll(false, false);
+        if (!selected.anyTrue) {
+          this.dataFrame.selection.fireChanged();
+          return;
+        }
+        for (let rowIdx = -1; (rowIdx = selected.findNext(rowIdx, true)) !== -1;) {
+          const originalIdx = indexesArray[rowIdx];
+          this.dataFrame.selection.set(originalIdx, true, false);
+        }
+        this.dataFrame.selection.fireChanged();
+      }),
+    );
+
+    this._dfSubs.push(
+      DG.debounce(this.dataFrame.onSelectionChanged, 100).subscribe((_) => {
+        const selected = this.dataFrame.selection;
+        if (firedFromTable) {
+          firedFromTable = false;
+          return;
+        }
+        firedFromViewer = true;
+        df.selection.setAll(false, false);
+        if (!selected.anyTrue) {
+          df.selection.fireChanged();
+          return;
+        }
+        for (let rowIdx = -1; (rowIdx = selected.findNext(rowIdx, true)) !== -1;) {
+          const viewerDfIdx = dataFrameIndexToViewerDfIndex.get(rowIdx);
+          if (viewerDfIdx != undefined)
+            df.selection.set(viewerDfIdx, true, false);
+        }
+        df.selection.fireChanged();
+      }),
+    );
+
+    // mouse over row GROUP handling one way
+    // legend will be responsible for this
+    // this._dfSubs.push(
+    //   df.onMouseOverRowGroupChanged.subscribe((_) => {
+    //     const func = df.rows.mouseOverRowFunc;
+    //     if (!func || this.dataFrame.rowCount > 50_000)
+    //       return;
+    //     this.dataFrame.rows.highlight((i) => {
+    //       const viewerDfIdx = dataFrameIndexToViewerDfIndex.get(i);
+    //       return viewerDfIdx != undefined && func(viewerDfIdx);
+    //     });
+    //   }),
+    // );
+    return df;
+  }
+
+  private _positionColumns: DG.Column[] | null = null;
+  public get positionColumns(): DG.Column[] {
+    if (this._positionColumns)
+      return this._positionColumns;
+    if (!this.dataFrame)
+      return [];
+    // try to find model and its position columns if the SAR was run
+    const peptidesModel = PeptidesModel.getInstance(this.dataFrame);
+    const posCols = peptidesModel?.positionColumns;
+    if (posCols && posCols.length > 0) {
+      this._positionColumns = posCols;
+      return this._positionColumns;
+    }
+    // fallback: generate columns
+    const seqCol = this.dataFrame.col(this.sequenceColumnName)!;
+    const seqHelper = PeptideUtils.getSeqHelper();
+    const seqHandler = seqHelper.getSeqHandler(seqCol);
+    const length = seqHandler.maxLength;
+    const cols: DG.Column[] = [];
+    for (let i = 0; i < length; i++) {
+      const monomersAtPosition = seqHandler.getMonomersAtPosition(i, true);
+      const monomerCol = DG.Column.fromList('string', `Position ${i + 1}`, monomersAtPosition);
+      cols.push(monomerCol);
+    }
+    this._positionColumns = cols;
+    return this._positionColumns;
+  }
+
+  private _innerDf: Promise<DG.DataFrame> | null = null;
+  public get innerDf(): Promise<DG.DataFrame> {
+    if (this._innerDf)
+      return Promise.resolve(this._innerDf);
+    this._innerDf = this.calculateDf();
+    return this._innerDf;
+  }
+
+  private _lineChart: DG.LineChartViewer | null = null;
+
+  private async render() {
+    $(this.root).empty();
+    if (!this.dataFrame || !this.activityColumnName || !this.sequenceColumnName || !this.position) {
+      this.root.appendChild(ui.divText('Please set Activity column, Sequence column and Position properties.'));
+      return;
+    }
+
+    if (this._lineChart) {
+      try {
+        this._lineChart.detach();
+      } catch (e) {
+        console.error('Error detaching previous line chart:', e);
+      }
+      this._lineChart = null;
+    }
+
+    ui.setUpdateIndicator(this.root, true);
+    this.root.style.display = 'flex';
+    this.root.style.flexDirection = 'column';
+
+    const df = await this.innerDf;
+
+    this._lineChart = df.plot.line({
+      xColumnName: `Position ${this.position}`,
+      yColumnNames: [this.activityColumnName],
+      splitColumnNames: this.seriesColumnName ? [this.seriesColumnName] : [],
+      legendVisibility: this.seriesColumnName ? 'Always' : 'Never',
+      legendPosition: 'Right',
+      showXSelector: false,
+      showYSelector: true,
+      showSplitSelector: false,
+      xAxisLabelOrientation: 'Auto',
+      axisFont: 'normal normal 14px "Roboto"',
+      controlsFont: 'normal normal 14px "Roboto"',
+    } as Partial<DG.ILineChartSettings>) as DG.LineChartViewer;
+
+
+    this._lineChart.sub(this._lineChart.onPropertyValueChanged.subscribe((_e) => {
+      if (this._lineChart?.props?.yColumnNames && this._lineChart?.props?.yColumnNames?.[0] !== this.activityColumnName) {
+        const value = this._lineChart?.props?.yColumnNames?.[0];
+        setTimeout(() => this.getProperty('activityColumnName')!.set(this, value), 1);
+      }
+    }));
+
+    ui.setUpdateIndicator(this.root, false);
+    this.root.appendChild(this._lineChart.root);
+
+    const maxPosition = this.positionColumns.length + 1;
+    const positions = new Array<number>(maxPosition - 1).fill(0).map((_, i) => i + 1).map((v) => v.toString());
+    const positionInput = ui.input.choice('Position', {value: this.position.toString(), items: positions, nullable: false,
+      onValueChanged: (v) => {
+        if (!v)
+          return;
+        const intV = parseInt(v);
+        this.getProperty('position')!.set(this, intV);
+      },
+    });
+
+    positionInput.input.style.width = '40px';
+    this.root.appendChild(ui.divH([positionInput.root], {style: {justifyContent: 'center', marginTop: '4px', width: '100%', font: 'normal normal 14px "Roboto"'}}));
+
+    const seriesColSelector = ui.input.column('Series', {table: this.dataFrame,
+      filter: (col: DG.Column) => {
+        return col.isCategorical && col.name !== this.sequenceColumnName;
+      }, tooltipText: 'Select column for series splitting.',
+      onValueChanged: (col: DG.Column | null) => {
+        const colName = col ? col.name : undefined;
+        this.getProperty('seriesColumnName')!.set(this, colName);
+      }, value: this.seriesColumnName ? this.dataFrame.col(this.seriesColumnName)! : undefined,
+    });
+    this.root.prepend(ui.divH([seriesColSelector.root], {style: {justifyContent: 'flex-end', paddingBottom: '4px', padding: '8px', width: '100%', font: 'normal normal 14px "Roboto"'}}));
+  }
+
+  private _debounceTimer: any = null;
+  public debouncedRender() {
+    ui.setUpdateIndicator(this.root, true);
+    if (this._debounceTimer)
+      clearTimeout(this._debounceTimer);
+    this._debounceTimer = setTimeout(() => this.render(), 300);
+  }
+
+  private clearCache() {
+    this._mutationCliffsData = null;
+    this._innerDf = null;
+    this._dfSubs.forEach((s) => s.unsubscribe());
+    this._dfSubs = [];
+  }
+
+  detach(): void {
+    super.detach();
+    this._dfSubs.forEach((s) => s.unsubscribe());
+    this._dfSubs = [];
+    clearTimeout(this._debounceTimer);
+  }
+
+
+  onPropertyChanged(property: DG.Property | null): void {
+    super.onPropertyChanged(property);
+    if (property?.name === 'activityColumnName' || property?.name === 'sequenceColumnName' || property?.name === 'position' || property?.name === 'seriesColumnName') {
+      this.clearCache();
+      this.debouncedRender();
+    } if (property?.name === 'yAxisType') {
+      if (this._lineChart)
+        this._lineChart.props.yAxisType = this.yAxisType.toLowerCase() as DG.AxisType;
+    }
+  }
+}

package/src/viewers/position-statistics-viewer.ts

@@ -27,13 +27,13 @@ export class SequencePositionStatsViewer extends DG.JsViewer {
     this.leftMotifLength = this.int('leftMotifLength', 0, {nullable: false, min: 0, max: 10});
     this.rightMotifLength = this.int('rightMotifLength', 0, {nullable: false, min: 0, max: 10});
     this.showPositionInfo = this.bool('showPositionInfo', true, {nullable: false, defaultValue: true, description: 'Show position and overhangs info in the viewer header'});
-    grok.events.onContextMenu.subscribe((e) => {
+    this.subs.push(grok.events.onContextMenu.subscribe((e) => {
       if (e.causedBy && e.causedBy.target && this._boxPlotViewer?.root.contains(e.causedBy.target)) {
         e.causedBy.preventDefault();
         e.causedBy.stopPropagation();
         e.causedBy.stopImmediatePropagation();
       }
-    });
+    }));
   }
 
   getPositionFromColumn(): number {

package/src/widgets/distribution.ts

@@ -5,7 +5,8 @@ import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations'
 import $ from 'cash-dom';
 
 import * as C from '../utils/constants';
-import {AggregationColumns, getAggregatedColumnValues, getStats, StatsItem} from '../utils/statistics';
+import {AggregationColumns, bitSetToBitArray,
+  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';
@@ -13,7 +14,7 @@ import BitArray from '@datagrok-libraries/utils/src/bit-array';
 import {Selection} from '../utils/types';
 
 export type DistributionItemOptions = {
-  peptideSelection: DG.BitSet, columns: AggregationColumns, clusterColName?: string,
+  columns: AggregationColumns, clusterColName?: string,
   activityCol: DG.Column<number>, monomerPositionSelection: Selection, clusterSelection: Selection,
 };
 
@@ -143,8 +144,7 @@ export function getStatsTableMap(stats: StatsItem,
  */
 function getSingleDistribution(table: DG.DataFrame, stats: StatsItem, options: DistributionItemOptions,
   labelMap: DistributionLabelMap = {}): HTMLDivElement {
-  const hist = getActivityDistribution(getDistributionTable(options.activityCol, table.selection,
-    options.peptideSelection));
+  const hist = getActivityDistribution(getDistributionTable(options.activityCol, table.selection));
   const aggregatedColMap = getAggregatedColumnValues(table, Object.entries(options.columns),
     {filterDf: true, mask: DG.BitSet.fromBytes(stats.mask.buffer.buffer as ArrayBuffer, stats.mask.length)});
   const tableMap = getStatsTableMap(stats);
@@ -165,15 +165,17 @@ function getSingleDistribution(table: DG.DataFrame, stats: StatsItem, options: D
 function getDistributionCategory(category: DISTRIBUTION_CATEGORIES_KEYS | typeof general, table: DG.DataFrame,
   options: DistributionItemOptions): HTMLDivElement {
   let body: HTMLDivElement = ui.divText('No distribution');
+  const selectionAndFilter = table.selection.clone().and(table.filter);
+  const selectionAndFilterBA = BitArray.fromUint32Array(
+    selectionAndFilter.length, new Uint32Array(selectionAndFilter.getBuffer().buffer));
   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,
+        count: options.activityCol.length, pValue: null, meanDifference: 0, ratio: 1, mask: selectionAndFilterBA,
         mean: options.activityCol.stats.avg,
       } :
-      getStats(options.activityCol.getRawData(), bitArray);
+      getStats(options.activityCol.getRawData(), selectionAndFilterBA, bitSetToBitArray(table.filter));
 
     body = getSingleDistribution(table, stats, options);
     break;
@@ -207,6 +209,7 @@ function getDistributionForClusters(table: DG.DataFrame, options: Required<Distr
   const clusterCol = table.getCol(options.clusterColName);
   const clusterColCategories = clusterCol.categories;
   const clusterColData = clusterCol.getRawData() as Int32Array;
+  const filterBitArray = bitSetToBitArray(table.filter);
 
   // Build distributions for original clusters
   const selectedClustersCategoryIndexes = selectionObject[CLUSTER_TYPE.ORIGINAL]
@@ -220,7 +223,7 @@ function getDistributionForClusters(table: DG.DataFrame, options: Required<Distr
   }
   for (let selectedClusterIdx = 0; selectedClusterIdx < selectedClustersCategoryIndexes.length; selectedClusterIdx++) {
     const selectedClusterCategoryIndex = selectedClustersCategoryIndexes[selectedClusterIdx];
-    const stats = getStats(activityColData, clusterMasks[selectedClusterIdx]);
+    const stats = getStats(activityColData, clusterMasks[selectedClusterIdx], filterBitArray);
     distributions.push(getSingleDistribution(table, stats, options,
       {[SPLIT_CATEGORY.SELECTION]: clusterColCategories[selectedClusterCategoryIndex]}));
   }
@@ -230,7 +233,7 @@ function getDistributionForClusters(table: DG.DataFrame, options: Required<Distr
   for (const clusterColumnName of customClusterSelection) {
     const customClustCol = table.getCol(clusterColumnName);
     const bitArray = BitArray.fromUint32Array(rowCount, customClustCol.getRawData() as Uint32Array);
-    const stats = getStats(activityColData, bitArray);
+    const stats = getStats(activityColData, bitArray, filterBitArray);
     distributions.push(getSingleDistribution(table, stats, options,
       {[SPLIT_CATEGORY.SELECTION]: clusterColumnName}));
   }
@@ -254,6 +257,7 @@ function getDistributionForPositions(table: DG.DataFrame, options: DistributionI
   const positionColumns: (DG.Column<string> | undefined)[] = [];
   const positionColumnsCategories: (string[] | undefined)[] = [];
   const positionColumnsData: (Int32Array | undefined)[] = [];
+  const filterBitArray = bitSetToBitArray(table.filter);
 
   for (let posIdx = 0; posIdx < positions.length; posIdx++) {
     const position = positions[posIdx];
@@ -276,7 +280,7 @@ function getDistributionForPositions(table: DG.DataFrame, options: DistributionI
           mask.setTrue(i);
       }
     }
-    const stats = getStats(activityColData, mask);
+    const stats = getStats(activityColData, mask, filterBitArray);
     distributions.push(getSingleDistribution(table, stats, options, {[SPLIT_CATEGORY.SELECTION]: position}));
   }
 
@@ -299,6 +303,7 @@ function getDistributionForMonomers(table: DG.DataFrame, options: DistributionIt
   const positionColumnsCategories: (string[] | undefined)[] = [];
   const positionColumnsData: (Int32Array | undefined)[] = [];
   const activityColData = options.activityCol.getRawData();
+  const filterBitArray = bitSetToBitArray(table.filter);
 
   for (const monomer of monomers) {
     const posList = reversedSelectionObject[monomer];
@@ -316,7 +321,7 @@ function getDistributionForMonomers(table: DG.DataFrame, options: DistributionIt
           mask.setTrue(i);
       }
     }
-    const stats = getStats(activityColData, mask);
+    const stats = getStats(activityColData, mask, filterBitArray);
 
     distributions.push(getSingleDistribution(table, stats, options, {[SPLIT_CATEGORY.SELECTION]: monomer}));
   }

package/src/widgets/peptides.ts

@@ -192,7 +192,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): Di
     bitsetChanged.unsubscribe();
     if (sequencesCol) {
       const model = await startAnalysis(activityColumnChoice.value!, sequencesCol, clustersColumnChoice.value, df,
-        scaledCol, activityScalingMethod.value ?? C.SCALING_METHODS.NONE, {addSequenceSpace: false, addMCL: true,
+        scaledCol, activityScalingMethod.value ?? C.SCALING_METHODS.NONE, {addSequenceSpace: false, addMCL: generateClustersInput.value,
           useEmbeddingsClusters: generateClustersInput.value ?? false, mclSettings: mclOptions});
       return model !== null;
     }

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

@@ -1,8 +1,11 @@
+/* eslint-disable max-len */
 import BitArray from '@datagrok-libraries/utils/src/bit-array';
 
 onmessage = async (event): Promise<void> => {
   const {startIdx, endIdx, activityArray, monomerInfoArray, settings} = event.data;
   const filterArray: Uint32Array = settings.filter;
+  const singlePosition: {position: number} | undefined = settings.singlePosition;
+  const singlePositionIndex = singlePosition ? singlePosition.position : -1;
   const filter = filterArray ? new BitArray(filterArray, filterArray.length * 32) : null;
 
   const pos: string[] = [];
@@ -25,14 +28,15 @@ onmessage = async (event): Promise<void> => {
       if (Math.abs(delta) >= settings.minActivityDelta) {
         let substCounterFlag = false;
         let tempDataIdx = 0;
-        for (const monomerInfo of monomerInfoArray) {
+        for (let positionIndex = 0; positionIndex < monomerInfoArray.length; positionIndex++) {
+          const monomerInfo = monomerInfoArray[positionIndex];
           const seq1categoryIdx = monomerInfo.rawData[seq1Idx];
           const seq2categoryIdx = monomerInfo.rawData[seq2Idx];
           if (seq1categoryIdx === seq2categoryIdx)
             continue;
 
           substCounter++;
-          substCounterFlag = substCounter > settings.maxMutations;
+          substCounterFlag = substCounter > settings.maxMutations || (singlePositionIndex !== -1 && positionIndex !== singlePositionIndex);
           if (substCounterFlag)
             break;