@datagrok/peptides 1.15.0 → 1.15.2

package/src/tests/{algorithms.ts → misc.ts}

@@ -7,6 +7,7 @@ import {findMutations} from '../utils/algorithms';
 import * as type from '../utils/types';
 import {extractColInfo} from '../utils/misc';
 
+
 category('Algorithms', () => {
   let activityCol: type.RawData;
   let monomerColumns: type.RawColumn[];
@@ -30,7 +31,7 @@ category('Algorithms', () => {
 
   test('MutationCliffs', async () => {
     // Check every pair
-    let mutationCliffsInfo: type.MutationCliffs = findMutations(activityCol, monomerColumns, settings);
+    let mutationCliffsInfo: type.MutationCliffs = await findMutations(activityCol, monomerColumns, settings);
     expect(mutationCliffsInfo.has('C'), true, `MutationCliffsInfo should have key 'C'`);
     expect(mutationCliffsInfo.has('D'), true, `MutationCliffsInfo should have key 'D'`);
     expect(mutationCliffsInfo.has('A'), false, `MutationCliffsInfo should not have key 'A'`);
@@ -51,21 +52,7 @@ category('Algorithms', () => {
     expect(d32[0], 1, `MutationCliffsInfo['D']['3'][2] should have value 1`);
 
     // Check with target
-    mutationCliffsInfo = findMutations(activityCol, monomerColumns, settings, {targetCol, currentTarget: '1'});
+    mutationCliffsInfo = await findMutations(activityCol, monomerColumns, settings, {targetCol, currentTarget: '1'});
     expect(mutationCliffsInfo.size, 0, `MutationCliffsInfo should be empty for target '1'`);
   });
-
-  test('MutationCliffs - Benchmark 5k', async () => {
-    if (!DG.Test.isInBenchmark)
-      return;
-
-    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
-    const activityCol: type.RawData = df.getCol('Activity').getRawData();
-    const monomerCols: type.RawColumn[] = [];
-    for (let i = 1; i < 16; ++i) {
-      const col = df.getCol(i.toString());
-      monomerCols.push({name: col.name, rawData: col.getRawData(), cat: col.categories});
-    }
-    DG.time('MutationCliffs', () => findMutations(activityCol, monomerCols));
-  }, {timeout: 5000});
 });

package/src/tests/model.ts

@@ -74,19 +74,6 @@ category('Model: Settings', () => {
       expectFloat(scaledActivityData[i], origActivityData[i], tolerance, getError(i, SCALING_METHODS.NONE));
   });
 
-  test('Bidirectional analysis', async () => {
-    // Check that bidirectional analysis is disabled by default
-    expect(model.settings.isBidirectional, false, 'Bidirectional analysis is enabled by default');
-
-    // Check that bidirectional analysis can be enabled
-    model.settings = {isBidirectional: true};
-    expect(model.settings.isBidirectional, true, 'Bidirectional analysis is disabled after enabling');
-
-    // Check that bidirectional analysis can be disabled
-    model.settings = {isBidirectional: false};
-    expect(model.settings.isBidirectional, false, 'Bidirectional analysis is enabled after disabling');
-  });
-
   test('Mutation Cliffs', async () => {
     // Check default mutation cliffs parameters
     expect(model.settings.maxMutations, mutationCliffsDefaultParams.maxMutations, `Max mutations mismatch: expected ` +

package/src/tests/table-view.ts

@@ -48,7 +48,7 @@ category('Table view', () => {
 
   test('Visible columns', async () => {
     const gridCols = model.analysisView.grid.columns;
-    const posCols = model.splitSeqDf.columns.names();
+    const posCols = model.positionColumns.toArray().map((col) => col.name);
     for (let colIdx = 1; colIdx < gridCols.length; colIdx++) {
       const col = gridCols.byIndex(colIdx)!;
       const tableColName = col.column!.name;

package/src/utils/algorithms.ts

@@ -1,22 +1,32 @@
+import * as DG from 'datagrok-api/dg';
 import * as C from './constants';
 import * as type from './types';
-import {getTypedArrayConstructor} from './misc';
+import {ParallelMutationCliffs} from './parallel-mutation-cliffs';
+import {CLUSTER_TYPE, ClusterStats, ClusterTypeStats,
+  MonomerPositionStats, PositionStats, SummaryStats} from '../model';
+import BitArray from '@datagrok-libraries/utils/src/bit-array';
+import {Stats, getStats} from './statistics';
 
-type MutationCliffInfo = {pos: string, seq1monomer: string, seq2monomer: string, seq1Idx: number, seq2Idx: number};
 
-export function findMutations(activityArray: type.RawData, monomerInfoArray: type.RawColumn[],
+export async function findMutations(activityArray: type.RawData, monomerInfoArray: type.RawColumn[],
   settings: type.PeptidesSettings = {},
-  targetOptions: {targetCol?: type.RawColumn | null, currentTarget?: string | null} = {}): type.MutationCliffs {
+  targetOptions: {targetCol?: type.RawColumn | null, currentTarget?: string | null} = {},
+): Promise<type.MutationCliffs> {
   const nCols = monomerInfoArray.length;
   if (nCols === 0)
     throw new Error(`PepAlgorithmError: Couldn't find any column of semType '${C.SEM_TYPES.MONOMER}'`);
 
   settings.minActivityDelta ??= 0;
   settings.maxMutations ??= 1;
-  const currentTargetIdx = targetOptions.targetCol?.cat!.indexOf(targetOptions.currentTarget!) ?? -1;
+  //const currentTargetIdx = targetOptions.targetCol?.cat!.indexOf(targetOptions.currentTarget!) ?? -1;
 
-  const substitutionsInfo: type.MutationCliffs = new Map();
-  const nRows = activityArray.length;
+  //const substitutionsInfo: type.MutationCliffs = new Map();
+  //const nRows = activityArray.length;
+
+  const substitutionsInfo =
+    await new ParallelMutationCliffs().calc(activityArray, monomerInfoArray, settings, targetOptions);
+  return substitutionsInfo;
+  /*
   for (let seq1Idx = 0; seq1Idx < nRows - 1; seq1Idx++) {
     if (currentTargetIdx !== -1 && targetOptions.targetCol?.rawData[seq1Idx] !== currentTargetIdx)
       continue;
@@ -33,11 +43,12 @@ export function findMutations(activityArray: type.RawData, monomerInfoArray: typ
         continue;
 
       let substCounterFlag = false;
-      const tempData: MutationCliffInfo[] = [];
+      const tempData: MutationCliffInfo[] = new Array(monomerInfoArray.length);
+      let tempDataIdx = 0;
       for (const monomerInfo of monomerInfoArray) {
-        const seq1category = monomerInfo.rawData[seq1Idx];
-        const seq2category = monomerInfo.rawData[seq2Idx];
-        if (seq1category === seq2category)
+        const seq1categoryIdx = monomerInfo.rawData[seq1Idx];
+        const seq2categoryIdx = monomerInfo.rawData[seq2Idx];
+        if (seq1categoryIdx === seq2categoryIdx)
           continue;
 
         substCounter++;
@@ -45,19 +56,22 @@ export function findMutations(activityArray: type.RawData, monomerInfoArray: typ
         if (substCounterFlag)
           break;
 
-        tempData.push({
+        tempData[tempDataIdx++] ={
           pos: monomerInfo.name,
-          seq1monomer: monomerInfo.cat![seq1category],
-          seq2monomer: monomerInfo.cat![seq2category],
+          seq1monomer: monomerInfo.cat![seq1categoryIdx],
+          seq2monomer: monomerInfo.cat![seq2categoryIdx],
           seq1Idx: seq1Idx,
           seq2Idx: seq2Idx,
-        });
+        };
       }
 
       if (substCounterFlag || substCounter === 0)
         continue;
 
-      for (const tempDataElement of tempData) {
+      // Separate processing loop in case substCOunter is 0 or out of restricted range to
+      // prevent unnecessary computations
+      for (let i = 0; i < tempDataIdx; i++) {
+        const tempDataElement = tempData[i];
         //Working with seq1monomer
         const seq1monomer = tempDataElement.seq1monomer;
         if (!substitutionsInfo.has(seq1monomer))
@@ -102,4 +116,140 @@ export function findMutations(activityArray: type.RawData, monomerInfoArray: typ
   }
 
   return substitutionsInfo;
+  */
+}
+
+export function calculateMonomerPositionStatistics(df: DG.DataFrame, positionColumns: DG.Column<string>[],
+  options: {isFiltered?: boolean, columns?: string[]} = {}): MonomerPositionStats {
+  options.isFiltered ??= false;
+  const monomerPositionObject = {general: {}} as MonomerPositionStats & {general: SummaryStats};
+  let activityColData: Float64Array = df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED).getRawData() as Float64Array;
+  let sourceDfLen = df.rowCount;
+
+  if (options.isFiltered) {
+    sourceDfLen = df.filter.trueCount;
+    const tempActivityData = new Float64Array(sourceDfLen);
+    const selectedIndexes = df.filter.getSelectedIndexes();
+    for (let i = 0; i < sourceDfLen; ++i)
+      tempActivityData[i] = activityColData[selectedIndexes[i]];
+    activityColData = tempActivityData;
+    positionColumns = DG.DataFrame.fromColumns(positionColumns).clone(df.filter).columns.toList();
+  }
+  options.columns ??= positionColumns.map((col) => col.name);
+
+  for (const posCol of positionColumns) {
+    if (!options.columns.includes(posCol.name))
+      continue;
+    const posColData = posCol.getRawData();
+    const posColCateogries = posCol.categories;
+    const currentPositionObject = {general: {}} as PositionStats & {general: SummaryStats};
+
+    for (let categoryIndex = 0; categoryIndex < posColCateogries.length; ++categoryIndex) {
+      const monomer = posColCateogries[categoryIndex];
+      if (monomer === '')
+        continue;
+
+      const boolArray: boolean[] = new Array(sourceDfLen).fill(false);
+      for (let i = 0; i < sourceDfLen; ++i) {
+        if (posColData[i] === categoryIndex)
+          boolArray[i] = true;
+      }
+      const bitArray = BitArray.fromValues(boolArray);
+      const stats = bitArray.allFalse || bitArray.allTrue ?
+        {count: sourceDfLen, meanDifference: 0, ratio: 1.0, pValue: null, mask: bitArray} :
+        getStats(activityColData, bitArray);
+      currentPositionObject[monomer] = stats;
+      getSummaryStats(currentPositionObject.general, stats);
+    }
+    monomerPositionObject[posCol.name] = currentPositionObject;
+    getSummaryStats(monomerPositionObject.general, null, currentPositionObject.general);
+  }
+  return monomerPositionObject;
+}
+
+export function getSummaryStats(
+  genObj: SummaryStats, stats: Stats | null = null, summaryStats: SummaryStats | null = null,
+): void {
+  if (stats === null && summaryStats === null)
+    throw new Error(`MonomerPositionStatsError: either stats or summaryStats must be present`);
+
+  const possibleMaxCount = stats?.count ?? summaryStats!.maxCount;
+  genObj.maxCount ??= possibleMaxCount;
+  if (genObj.maxCount < possibleMaxCount)
+    genObj.maxCount = possibleMaxCount;
+
+  const possibleMinCount = stats?.count ?? summaryStats!.minCount;
+  genObj.minCount ??= possibleMinCount;
+  if (genObj.minCount > possibleMinCount)
+    genObj.minCount = possibleMinCount;
+
+  const possibleMaxMeanDifference = stats?.meanDifference ?? summaryStats!.maxMeanDifference;
+  genObj.maxMeanDifference ??= possibleMaxMeanDifference;
+  if (genObj.maxMeanDifference < possibleMaxMeanDifference)
+    genObj.maxMeanDifference = possibleMaxMeanDifference;
+
+  const possibleMinMeanDifference = stats?.meanDifference ?? summaryStats!.minMeanDifference;
+  genObj.minMeanDifference ??= possibleMinMeanDifference;
+  if (genObj.minMeanDifference > possibleMinMeanDifference)
+    genObj.minMeanDifference = possibleMinMeanDifference;
+
+  if (!isNaN(stats?.pValue ?? NaN)) {
+    const possibleMaxPValue = stats?.pValue ?? summaryStats!.maxPValue;
+    genObj.maxPValue ??= possibleMaxPValue;
+    if (genObj.maxPValue < possibleMaxPValue)
+      genObj.maxPValue = possibleMaxPValue;
+
+    const possibleMinPValue = stats?.pValue ?? summaryStats!.minPValue;
+    genObj.minPValue ??= possibleMinPValue;
+    if (genObj.minPValue > possibleMinPValue)
+      genObj.minPValue = possibleMinPValue;
+  }
+
+  const possibleMaxRatio = stats?.ratio ?? summaryStats!.maxRatio;
+  genObj.maxRatio ??= possibleMaxRatio;
+  if (genObj.maxRatio < possibleMaxRatio)
+    genObj.maxRatio = possibleMaxRatio;
+
+  const possibleMinRatio = stats?.ratio ?? summaryStats!.minRatio;
+  genObj.minRatio ??= possibleMinRatio;
+  if (genObj.minRatio > possibleMinRatio)
+    genObj.minRatio = possibleMinRatio;
+}
+
+export function calculateClusterStatistics(df: DG.DataFrame, clustersColumnName: string,
+  customClusters: DG.Column<boolean>[]): ClusterTypeStats {
+  const rowCount = df.rowCount;
+  const origClustCol = df.getCol(clustersColumnName);
+  const origClustColData = origClustCol.getRawData();
+  const origClustColCat = origClustCol.categories;
+  const origClustMasks: BitArray[] = Array.from({length: origClustColCat.length},
+    () => new BitArray(rowCount, false));
+  for (let rowIdx = 0; rowIdx < rowCount; ++rowIdx)
+    origClustMasks[origClustColData[rowIdx]].setTrue(rowIdx);
+
+  const customClustMasks = customClusters.map(
+    (v) => BitArray.fromUint32Array(rowCount, v.getRawData() as Uint32Array));
+  const customClustColNamesList = customClusters.map((v) => v.name);
+
+  const activityColData: type.RawData = df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED).getRawData();
+
+  const origClustStats: ClusterStats = {};
+  const customClustStats: ClusterStats = {};
+
+  for (const clustType of Object.values(CLUSTER_TYPE)) {
+    const masks = clustType === CLUSTER_TYPE.ORIGINAL ? origClustMasks : customClustMasks;
+    const clustNames = clustType === CLUSTER_TYPE.ORIGINAL ? origClustColCat : customClustColNamesList;
+    const resultStats = clustType === CLUSTER_TYPE.ORIGINAL ? origClustStats : customClustStats;
+    for (let maskIdx = 0; maskIdx < masks.length; ++maskIdx) {
+      const mask = masks[maskIdx];
+      const stats = mask.allTrue || mask.allFalse ?
+        {count: mask.length, meanDifference: 0, ratio: 1.0, pValue: null, mask: mask} : getStats(activityColData, mask);
+      resultStats[clustNames[maskIdx]] = stats;
+    }
+  }
+
+  const resultStats = {} as ClusterTypeStats;
+  resultStats[CLUSTER_TYPE.ORIGINAL] = origClustStats;
+  resultStats[CLUSTER_TYPE.CUSTOM] = customClustStats;
+  return resultStats;
 }

package/src/utils/cell-renderer.ts

@@ -22,7 +22,7 @@ export function setMonomerRenderer(col: DG.Column, alphabet: string): void {
 export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D, currentMonomer: string,
   currentPosition: string, monomerPositionStats: MonomerPositionStats, bound: DG.Rect,
   mutationCliffsSelection: types.Selection, substitutionsInfo: types.MutationCliffs | null = null,
-  _twoColorMode: boolean = false, renderNums: boolean = true): void {
+  renderNums: boolean = true): void {
   const positionStats = monomerPositionStats[currentPosition];
   const pVal = positionStats![currentMonomer]!.pValue;
   const currentMeanDifference = positionStats![currentMonomer]!.meanDifference;

package/src/utils/constants.ts

@@ -44,6 +44,7 @@ export enum TAGS {
   IDENTITY_TEMPLATE = 'Identity template',
   SIMILARITY_TEMPLATE = 'Similarity template',
   ANALYSIS_COL = 'isAnalysisCol',
+  POSITION_COL = 'isPositionCol',
 }
 
 export enum SEM_TYPES {

package/src/utils/parallel-mutation-cliffs.ts

@@ -0,0 +1,106 @@
+
+import * as type from './types';
+
+export type ParallelMutationReturnType = {
+    // monomers1: string[],
+    // monomers2: string[],
+    pos: string[],
+    seq1Idxs: Uint32Array,
+    seq2Idxs: Uint32Array,
+}
+export class ParallelMutationCliffs {
+  private _workers: Worker[];
+  private _workerCount: number;
+
+  constructor() {
+    const threadCount = navigator.hardwareConcurrency;
+    this._workerCount = Math.max(threadCount - 2, 1);
+    this._workers = new Array(this._workerCount).fill(null)
+      .map(() => new Worker(new URL('../workers/mutation-cliffs-worker', import.meta.url)));
+  }
+
+  public async calc(activityArray: type.RawData, monomerInfoArray: type.RawColumn[],
+    settings: type.PeptidesSettings = {},
+    targetOptions: {targetCol?: type.RawColumn | null, currentTarget?: string | null} = {},
+  ): Promise<type.MutationCliffs> {
+    const substitutionsInfo: type.MutationCliffs = new Map();
+    try {
+      const currentTargetIdx = targetOptions.targetCol?.cat!.indexOf(targetOptions.currentTarget!) ?? -1;
+
+      const len = activityArray.length;
+      const promises = new Array<Promise<ParallelMutationReturnType>>(this._workerCount);
+      const matSize = len * (len - 1) / 2; // size of reduced upper triangular matrix
+      this._workerCount = Math.min(this._workerCount, matSize);
+      const chunkSize = matSize / this._workerCount;
+      // monomerInfoArray[m].cat and targetCol can contain some function from datagrok-api,
+      //which the worker can't serialize and fails. so we need to remove it
+      monomerInfoArray.forEach((monomerInfo) => {
+        monomerInfo.cat = monomerInfo.cat?.slice();
+      });
+      targetOptions.targetCol?.cat && (targetOptions.targetCol.cat = targetOptions.targetCol.cat.slice());
+      for (let idx = 0; idx < this._workerCount; idx++) {
+        promises[idx] = new Promise((resolveWorker, rejectWorker) => {
+          const startIdx = Math.floor(idx * chunkSize);
+          const endIdx = idx === this._workerCount - 1 ? matSize : Math.floor((idx + 1) * chunkSize);
+          this._workers[idx].postMessage(
+            {startIdx, endIdx, activityArray, monomerInfoArray, settings, currentTargetIdx, targetOptions});
+          this._workers[idx].onmessage = ({data: {pos, seq1Idxs, seq2Idxs, error}}): void => {
+            if (error) {
+              this._workers[idx]?.terminate();
+              rejectWorker(error);
+            } else {
+              this._workers[idx].terminate();
+              resolveWorker({pos, seq1Idxs, seq2Idxs});
+            }
+          };
+        });
+      }
+
+      const results = await Promise.all(promises);
+      const monomerPositionsMap = new Map<string, number>();
+      monomerInfoArray.forEach((monomerInfo, i) => {
+        monomerPositionsMap.set(monomerInfo.name, i);
+      });
+      results.filter(Boolean).forEach((result) => {
+        for (let i = 0; i< result.pos.length; i++) {
+        //getting monomers from monomerInfoArray by position
+          const monomerPos = monomerPositionsMap.get(result.pos[i])!;
+          const monomer1Cat = monomerInfoArray[monomerPos].rawData[result.seq1Idxs[i]];
+          const monomer1 = monomerInfoArray[monomerPos].cat![monomer1Cat];
+          const monomer2Cat = monomerInfoArray[monomerPos].rawData[result.seq2Idxs[i]];
+          const monomer2 = monomerInfoArray[monomerPos].cat![monomer2Cat];
+
+          // filling map
+          if (!substitutionsInfo.has(monomer1))
+            substitutionsInfo.set(monomer1, new Map());
+          if (!substitutionsInfo.has(monomer2))
+            substitutionsInfo.set(monomer2, new Map());
+          const position1Map = substitutionsInfo.get(monomer1)!;
+          const position2Map = substitutionsInfo.get(monomer2)!;
+          if (!position1Map.has(result.pos[i]))
+            position1Map.set(result.pos[i], new Map());
+          if (!position2Map.has(result.pos[i]))
+            position2Map.set(result.pos[i], new Map());
+          const indexes1Map = position1Map.get(result.pos[i])!;
+          const indexes2Map = position2Map.get(result.pos[i])!;
+          if (!indexes1Map.has(result.seq1Idxs[i]))
+            indexes1Map.set(result.seq1Idxs[i], []);
+          if (!indexes2Map.has(result.seq2Idxs[i]))
+            indexes2Map.set(result.seq2Idxs[i], []);
+          const indexes1 = indexes1Map.get(result.seq1Idxs[i])!;
+          const indexes2 = indexes2Map.get(result.seq2Idxs[i])!;
+          (indexes1 as number[]).push(result.seq2Idxs[i]);
+          (indexes2 as number[]).push(result.seq1Idxs[i]);
+        }
+      });
+    } catch (error) {
+      this.terminate();
+      console.error(error);
+    }
+    return substitutionsInfo;
+  }
+
+  public terminate(): void {
+    this._workers?.forEach((worker) => worker?.terminate());
+  }
+}

package/src/utils/types.ts

@@ -18,7 +18,6 @@ export type PeptidesSettings = {
   clustersColumnName?: string,
   targetColumnName?: string,
   scaling?: SCALING_METHODS,
-  isBidirectional?: boolean,
   showMonomerPosition?: boolean,
   showMostPotentResidues?: boolean,
   showLogoSummaryTable?: boolean,

package/src/viewers/logo-summary.ts

@@ -214,7 +214,6 @@ export class LogoSummaryTable extends DG.JsViewer {
     this.viewerGrid.sort([C.LST_COLUMN_NAMES.MEMBERS], [false]);
     this.updateFilter();
     const gridClustersCol = this.viewerGrid.col(C.LST_COLUMN_NAMES.CLUSTER)!;
-    // gridClustersCol.column!.name = C.LST_COLUMN_NAMES.CLUSTER;
     gridClustersCol.visible = true;
     this.viewerGrid.columns.setOrder([C.LST_COLUMN_NAMES.CLUSTER, C.LST_COLUMN_NAMES.MEMBERS,
       C.LST_COLUMN_NAMES.WEB_LOGO, C.LST_COLUMN_NAMES.DISTRIBUTION, C.LST_COLUMN_NAMES.MEAN_DIFFERENCE,
@@ -224,7 +223,7 @@ export class LogoSummaryTable extends DG.JsViewer {
 
     const webLogoCache = new DG.LruCache<number, DG.Viewer & IWebLogoViewer>();
     const distCache = new DG.LruCache<number, DG.Viewer<DG.IHistogramLookSettings>>();
-    const maxSequenceLen = this.model.splitSeqDf.columns.length;
+    const maxSequenceLen = this.model.positionColumns.toArray().length;
     const webLogoGridCol = this.viewerGrid.columns.byName(C.LST_COLUMN_NAMES.WEB_LOGO)!;
     webLogoGridCol.cellType = 'html';
     webLogoGridCol.width = 350;
@@ -270,7 +269,7 @@ export class LogoSummaryTable extends DG.JsViewer {
             const webLogoTable = this.createWebLogoDf(pepCol, clusterBitSet);
             viewer = await webLogoTable.plot
               .fromType('WebLogo', {positionHeight: this.webLogoMode, horizontalAlignment: HorizontalAlignments.LEFT,
-                maxHeight: 1000, minHeight: height, positionWidth: positionWidth});
+                maxHeight: 1000, minHeight: height, positionWidth: positionWidth, showPositionLabels: false});
             webLogoCache.set(currentRowIdx, viewer);
           }
           gridCell.element = viewer.root;

package/src/viewers/sar-viewer.ts

@@ -27,7 +27,7 @@ export class MonomerPosition extends DG.JsViewer {
   _titleHost = ui.divText(SELECTION_MODE.MUTATION_CLIFFS, {id: 'pep-viewer-title'});
   _viewerGrid!: DG.Grid;
   _model!: PeptidesModel;
-  colorCol: string;
+  color: string;
   aggregation: string;
   target: string;
   keyPressed: boolean = false;
@@ -37,7 +37,7 @@ export class MonomerPosition extends DG.JsViewer {
     super();
     this.target = this.string(MONOMER_POSITION_PROPERTIES.TARGET, null,
       {category: SELECTION_MODE.MUTATION_CLIFFS, choices: []});
-    this.colorCol = this.string(MONOMER_POSITION_PROPERTIES.COLOR_COLUMN_NAME, C.COLUMNS_NAMES.ACTIVITY_SCALED,
+    this.color = this.string(MONOMER_POSITION_PROPERTIES.COLOR_COLUMN_NAME, C.COLUMNS_NAMES.ACTIVITY_SCALED,
       {category: SELECTION_MODE.INVARIANT_MAP,
         choices: wu(grok.shell.t.columns.numerical).toArray().map((col) => col.name)});
     this.aggregation = this.string(MONOMER_POSITION_PROPERTIES.AGGREGATION, DG.AGG.AVG,
@@ -82,14 +82,14 @@ export class MonomerPosition extends DG.JsViewer {
   onPropertyChanged(property: DG.Property): void {
     super.onPropertyChanged(property);
     if (property.name === MONOMER_POSITION_PROPERTIES.TARGET)
-      this.model.updateMutationCliffs();
+      this.model.updateMutationCliffs().then(() => this.render(true));
 
-    this.render();
+    this.render(true);
   }
 
   createMonomerPositionDf(): DG.DataFrame {
     const uniqueMonomers = new Set<string>();
-    const splitSeqCols = this.model.splitSeqDf.columns;
+    const splitSeqCols = this.model.positionColumns.toArray();
     for (const col of splitSeqCols) {
       const colCat = col.categories;
       for (const cat of colCat) {
@@ -112,11 +112,11 @@ export class MonomerPosition extends DG.JsViewer {
     const monomerPositionDf = this.createMonomerPositionDf();
     this.viewerGrid = monomerPositionDf.plot.grid();
     this.viewerGrid.sort([C.COLUMNS_NAMES.MONOMER]);
-    this.viewerGrid.columns.setOrder([C.COLUMNS_NAMES.MONOMER, ...this.model.splitSeqDf.columns.names()]);
+    this.viewerGrid.columns.setOrder([C.COLUMNS_NAMES.MONOMER, ...this.model.positionColumns.toArray().map((col) => col.name)]);
     const monomerCol = monomerPositionDf.getCol(C.COLUMNS_NAMES.MONOMER);
     CR.setMonomerRenderer(monomerCol, this.model.alphabet);
     this.viewerGrid.onCellRender.subscribe((args: DG.GridCellRenderArgs) => renderCell(args, this.model,
-      this.mode === SELECTION_MODE.INVARIANT_MAP, this.dataFrame.getCol(this.colorCol), this.aggregation as DG.AGG));
+      this.mode === SELECTION_MODE.INVARIANT_MAP, this.dataFrame.getCol(this.color), this.aggregation as DG.AGG));
 
     this.viewerGrid.onCellTooltip((gridCell: DG.GridCell, x: number, y: number) => {
       if (!gridCell.isTableCell) {
@@ -367,7 +367,7 @@ export class MostPotentResidues extends DG.JsViewer {
           return;
         const monomerPosition = this.getMonomerPosition(gridCell);
         if (this.currentGridRowIdx !== null) {
-          const previousMonomerPosition = this.getMonomerPosition(this.viewerGrid.cell("Diff", this.currentGridRowIdx));
+          const previousMonomerPosition = this.getMonomerPosition(this.viewerGrid.cell('Diff', this.currentGridRowIdx));
           this.model.modifyMutationCliffsSelection(previousMonomerPosition, {shiftPressed: true, ctrlPressed: true}, false);
         }
         if (this.model.mutationCliffs?.get(monomerPosition.monomerOrCluster)?.get(monomerPosition.positionOrClusterType)?.size)
@@ -420,7 +420,7 @@ export class MostPotentResidues extends DG.JsViewer {
 
 function renderCell(args: DG.GridCellRenderArgs, model: PeptidesModel, isInvariantMap?: boolean,
   colorCol?: DG.Column<number>, colorAgg?: DG.AGG, renderNums?: boolean): void {
-  const renderColNames = [...model.splitSeqDf.columns.names(), C.COLUMNS_NAMES.MEAN_DIFFERENCE];
+  const renderColNames = [...model.positionColumns.toArray().map((col) => col.name), C.COLUMNS_NAMES.MEAN_DIFFERENCE];
   const canvasContext = args.g;
   const bound = args.bounds;
 
@@ -478,7 +478,7 @@ function renderCell(args: DG.GridCellRenderArgs, model: PeptidesModel, isInvaria
       canvasContext, currentMonomer, currentPosition, model.invariantMapSelection, value, bound, color);
   } else {
     CR.renderMutationCliffCell(canvasContext, currentMonomer, currentPosition, model.monomerPositionStats, bound,
-      model.mutationCliffsSelection, model.mutationCliffs, model.settings.isBidirectional, renderNums);
+      model.mutationCliffsSelection, model.mutationCliffs, renderNums);
   }
   args.preventDefault();
   canvasContext.restore();

package/src/widgets/mutation-cliffs.ts

@@ -147,11 +147,11 @@ export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel):
 
   const gridCols = model.analysisView.grid.columns;
   const originalGridColCount = gridCols.length;
-  const positionColumns = model.splitSeqDf.columns;
+  const positionColumns = model.positionColumns.toArray().map((col) => col.name);
   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)))
+    if (gridCol?.name === model.settings.sequenceColumnName || (gridCol?.visible === true && !positionColumns.includes(gridCol.name)))
       columnNames.push(gridCol!.name);
   }
 

package/src/widgets/peptides.ts

@@ -180,7 +180,6 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
       sequenceColumnName: peptidesCol.name,
       activityColumnName: activityColumn.name,
       scaling: scaling,
-      isBidirectional: false,
       columns: {},
       maxMutations: 1,
       minActivityDelta: 0,

package/src/widgets/settings.ts

@@ -22,7 +22,6 @@ export enum SETTINGS_PANES {
 export enum GENERAL_INPUTS {
   ACTIVITY = 'Activity',
   ACTIVITY_SCALING = 'Activity scaling',
-  BIDIRECTIONAL_ANALYSIS = 'Bidirectional analysis',
 }
 
 export enum VIEWERS_INPUTS {
@@ -51,7 +50,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   const accordion = ui.accordion();
   const settings = model.settings;
   const currentScaling = settings.scaling ?? C.SCALING_METHODS.NONE;
-  const currentBidirectional = settings.isBidirectional ?? false;
+  // const currentBidirectional = settings.isBidirectional ?? false;
   const currentMaxMutations = settings.maxMutations ?? 1;
   const currentMinActivityDelta = settings.minActivityDelta ?? 0;
   const currentColumns = settings.columns ?? {};
@@ -69,13 +68,9 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
     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>;
   activityScaling.setTooltip('Activity column transformation method');
-  const bidirectionalAnalysis = ui.boolInput(GENERAL_INPUTS.BIDIRECTIONAL_ANALYSIS, currentBidirectional,
-    () => result.isBidirectional = bidirectionalAnalysis.value) as DG.InputBase<boolean>;
-  bidirectionalAnalysis.setTooltip('Distinguish between positive and negative mean activity difference in ' +
-    'Monomer-Position and Most Potent Residues viewers');
 
-  accordion.addPane(SETTINGS_PANES.GENERAL, () => ui.inputs([activityCol, activityScaling, bidirectionalAnalysis]), true);
-  inputs[SETTINGS_PANES.GENERAL] = [activityCol, activityScaling, bidirectionalAnalysis];
+  accordion.addPane(SETTINGS_PANES.GENERAL, () => ui.inputs([activityCol, activityScaling]), true);
+  inputs[SETTINGS_PANES.GENERAL] = [activityCol, activityScaling];
 
   // Viewers pane options
   /* FIXME: combinations of adding and deleting viewers are not working properly