@datagrok/peptides 1.8.2 → 1.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/peptides",
   "friendlyName": "Peptides",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "author": {
     "name": "Volodymyr Dyma",
     "email": "vdyma@datagrok.ai"
@@ -16,8 +16,8 @@
     "@datagrok-libraries/bio": "^5.29.3",
     "@datagrok-libraries/ml": "^6.3.3",
     "@datagrok-libraries/statistics": "^1.1.7",
-    "@datagrok-libraries/utils": "^4.0.2",
-    "@datagrok-libraries/tutorials": "^1.3.1",
+    "@datagrok-libraries/utils": "^4.0.7",
+    "@datagrok-libraries/tutorials": "^1.3.2",
     "cash-dom": "^8.1.2",
     "datagrok-api": "^1.6.0",
     "file-loader": "^6.2.0",

package/src/demo/fasta.ts

@@ -20,7 +20,7 @@ export async function macromoleculeSarFastaDemoUI(): Promise<void> {
   simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
   simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
   simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
-  const simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
+  const simpleScaledCol = scaleActivity(simpleActivityCol, C.SCALING_METHODS.MINUS_LG);
 
   demo.step('Load data', async () => {grok.shell.addTableView(simpleTable);},
     {description: 'Load the dataset containing macromolecule sequences. Notice how Datagrok detects macromolecules ' +

package/src/model.ts

@@ -19,8 +19,8 @@ import * as uuid from 'uuid';
 
 import * as C from './utils/constants';
 import * as type from './utils/types';
-import {calculateSelected, extractMonomerInfo, scaleActivity, getStatsSummary} from './utils/misc';
-import {MonomerPosition, MostPotentResiduesViewer} from './viewers/sar-viewer';
+import {calculateSelected, extractColInfo, scaleActivity, getStatsSummary} from './utils/misc';
+import {MONOMER_POSITION_PROPERTIES, MonomerPosition, MostPotentResiduesViewer} from './viewers/sar-viewer';
 import * as CR from './utils/cell-renderer';
 import {mutationCliffsWidget} from './widgets/mutation-cliffs';
 import {getActivityDistribution, getDistributionLegend, getDistributionWidget, getStatsTableMap,
@@ -39,8 +39,8 @@ export type SummaryStats = {
   minPValue: number, maxPValue: number,
   minRatio: number, maxRatio: number,
 };
-export type PositionStats = { [monomer: string]: Stats } & { general: SummaryStats };
-export type MonomerPositionStats = { [position: string]: PositionStats } & { general: SummaryStats };
+export type PositionStats = {[monomer: string]: Stats} & {general: SummaryStats};
+export type MonomerPositionStats = {[position: string]: PositionStats} & {general: SummaryStats};
 export type ClusterStats = {[cluster: string]: Stats};
 export enum CLUSTER_TYPE {
   ORIGINAL = 'original',
@@ -78,11 +78,11 @@ export class PeptidesModel {
   _monomerPositionSelection!: type.PositionToAARList;
   _monomerPositionFilter!: type.PositionToAARList;
   _clusterSelection!: string[];
-  _mutationCliffs?: type.MutationCliffs;
+  _mutationCliffs: type.MutationCliffs | null = null;
   isInitialized = false;
   _analysisView?: DG.TableView;
 
-  monomerMap: { [key: string]: { molfile: string, fullName: string } } = {};
+  monomerMap: {[key: string]: {molfile: string, fullName: string}} = {};
   monomerLib: IMonomerLib | null = null; // To get monomers from lib(s)
   monomerWorks: MonomerWorks | null = null; // To get processed monomers
 
@@ -93,8 +93,8 @@ export class PeptidesModel {
   initBitset: DG.BitSet;
   isInvariantMapTrigger: boolean = false;
   headerSelectedMonomers: type.MonomerSelectionStats = {};
-  webLogoBounds: { [positon: string]: { [monomer: string]: DG.Rect } } = {};
-  cachedWebLogoTooltip: { bar: string; tooltip: HTMLDivElement | null; } = {bar: '', tooltip: null};
+  webLogoBounds: {[positon: string]: {[monomer: string]: DG.Rect}} = {};
+  cachedWebLogoTooltip: {bar: string, tooltip: HTMLDivElement | null} = {bar: '', tooltip: null};
   _monomerPositionDf?: DG.DataFrame;
   _alphabet?: string;
   _mostPotentResiduesDf?: DG.DataFrame;
@@ -170,18 +170,15 @@ export class PeptidesModel {
     return col.getTag(bioTAGS.alphabet);
   }
 
-  get mutationCliffs(): type.MutationCliffs {
-    if (this._mutationCliffs)
-      return this._mutationCliffs;
+  get mutationCliffs(): type.MutationCliffs | null {
+    // if (this._mutationCliffs)
+    //   return this._mutationCliffs;
 
-    const scaledActivityCol: DG.Column<number> = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
-    //TODO: set categories ordering the same to share compare indexes instead of strings
-    const monomerColumns: type.RawColumn[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER).map(extractMonomerInfo);
-    this._mutationCliffs = findMutations(scaledActivityCol.getRawData(), monomerColumns, this.settings);
-    return this._mutationCliffs;
+    // this.updateMutationCliffs(false);
+    return this._mutationCliffs!;
   }
 
-  set mutationCliffs(si: type.MutationCliffs) {
+  set mutationCliffs(si: type.MutationCliffs | null) {
     this._mutationCliffs = si;
   }
 
@@ -354,10 +351,7 @@ export class PeptidesModel {
         this.createScaledCol();
         break;
       case 'mutationCliffs':
-        const scaledActivityCol: DG.Column<number> = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
-        //TODO: set categories ordering the same to share compare indexes instead of strings
-        const monomerCols: type.RawColumn[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER).map(extractMonomerInfo);
-        this.mutationCliffs = findMutations(scaledActivityCol.getRawData(), monomerCols, this.settings);
+        this.updateMutationCliffs();
         break;
       case 'stats':
         this.monomerPositionStats = this.calculateMonomerPositionStatistics();
@@ -390,6 +384,22 @@ export class PeptidesModel {
     this._settingsSubject.next(this.settings);
   }
 
+  updateMutationCliffs(notify: boolean = true): void {
+    const scaledActivityCol: DG.Column<number> = this.df.getCol(C.COLUMNS_NAMES.ACTIVITY_SCALED);
+    //TODO: set categories ordering the same to share compare indexes instead of strings
+    const monomerCols: type.RawColumn[] = this.df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER).map(extractColInfo);
+    const targetCol = typeof this.settings.targetColumnName !== 'undefined' ?
+      extractColInfo(this.df.getCol(this.settings.targetColumnName)) : null;
+    const mpViewer = this.findViewer(VIEWER_TYPE.MONOMER_POSITION) as MonomerPosition | null;
+    const currentTarget = mpViewer?.getProperty(MONOMER_POSITION_PROPERTIES.TARGET)?.get(mpViewer);
+    const targetOptions = {targetCol: targetCol, currentTarget: currentTarget};
+    const mutationCliffs = findMutations(scaledActivityCol.getRawData(), monomerCols, this.settings, targetOptions);
+    if (notify)
+      this.mutationCliffs = mutationCliffs;
+    else
+      this._mutationCliffs = mutationCliffs;
+  }
+
   createMonomerPositionDf(): DG.DataFrame {
     const positions = this.splitSeqDf.columns.names();
     const matrixDf = this.matrixDf
@@ -1097,6 +1107,8 @@ export class PeptidesModel {
     this.updateGrid();
     this.fireBitsetChanged(true);
     this.analysisView.grid.invalidate();
+    if (typeof this.settings.targetColumnName === 'undefined')
+      this.updateMutationCliffs();
   }
 
   findViewer(viewerType: VIEWER_TYPE): DG.Viewer | null {
@@ -1121,6 +1133,12 @@ export class PeptidesModel {
     const [dockType, refNode, ratio] = mostPotentResidues === null ? [DG.DOCK_TYPE.DOWN, null, undefined] :
       [DG.DOCK_TYPE.LEFT, this.findViewerNode(VIEWER_TYPE.MOST_POTENT_RESIDUES), 0.7];
     dm.dock(monomerPosition, dockType, refNode, VIEWER_TYPE.MONOMER_POSITION, ratio);
+    if (typeof this.settings.targetColumnName !== 'undefined') {
+      const target = monomerPosition.getProperty(MONOMER_POSITION_PROPERTIES.TARGET)!;
+      const choices = this.df.getCol(this.settings.targetColumnName!).categories;
+      target.choices = choices;
+      target.set(monomerPosition, choices[0]);
+    }
   }
 
   async addMostPotentResidues(): Promise<void> {

package/src/package.ts

@@ -176,6 +176,7 @@ export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
 //name: Macromolecule SAR Analysis
 //description: Macromolecule SAR Analysis demo on peptide sequences in FASTA format
 //meta.demoPath: Bioinformatics | Macromolecule SAR Analysis
+//meta.isDemoScript: True
 export async function macromoleculeSarFastaDemo(): Promise<void> {
   return macromoleculeSarFastaDemoUI();
 }

package/src/tests/algorithms.ts

@@ -5,11 +5,13 @@ import {category, test, expect, before} from '@datagrok-libraries/utils/src/test
 import {_package} from '../package-test';
 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[];
   let settings: type.PeptidesSettings;
+  let targetCol: type.RawColumn;
 
   before(async () => {
     activityCol = DG.Column.fromList('int', 'test', [1, 2, 5]).getRawData();
@@ -22,29 +24,35 @@ category('Algorithms', () => {
       rawData: col.getRawData(),
       cat: col.categories,
     }));
+    targetCol = extractColInfo(DG.Column.fromList('string', 'target', ['1', '2', '2']));
     settings = {maxMutations: 1, minActivityDelta: 2};
   });
 
   test('MutationCliffs', async () => {
-    const substInfo: type.MutationCliffs = findMutations(activityCol, monomerColumns, settings);
-    expect(substInfo.has('C'), true);
-    expect(substInfo.has('D'), true);
-    expect(substInfo.has('A'), false);
+    // Check every pair
+    let mutationCliffsInfo: type.MutationCliffs = 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'`);
 
-    const c = substInfo.get('C')!;
-    const d = substInfo.get('D')!;
-    expect(c.has('3'), true);
-    expect(d.has('3'), true);
+    const c = mutationCliffsInfo.get('C')!;
+    const d = mutationCliffsInfo.get('D')!;
+    expect(c.has('3'), true, `MutationCliffsInfo['C'] should have key '3'`);
+    expect(d.has('3'), true, `MutationCliffsInfo['D'] should have key '3'`);
 
     const c3 = c.get('3')!;
     const d3 = d.get('3')!;
-    expect(c3.has(1), true);
-    expect(d3.has(2), true);
+    expect(c3.has(1), true, `MutationCliffsInfo['C']['3'] should have key 1`);
+    expect(d3.has(2), true, `MutationCliffsInfo['D']['3'] should have key 2`);
 
     const c31 = c3.get(1)!;
     const d32 = d3.get(2)!;
-    expect(c31[0], 2);
-    expect(d32[0], 1);
+    expect(c31[0], 2, `MutationCliffsInfo['C']['3'][1] should have value 2`);
+    expect(d32[0], 1, `MutationCliffsInfo['D']['3'][2] should have value 1`);
+
+    // Check with target
+    mutationCliffsInfo = findMutations(activityCol, monomerColumns, settings, {targetCol, currentTarget: '1'});
+    expect(mutationCliffsInfo.size, 0, `MutationCliffsInfo should be empty for target '1'`);
   });
 
   test('MutationCliffs - Benchmark 5k', async () => {

package/src/tests/core.ts

@@ -33,7 +33,7 @@ category('Core', () => {
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
-    simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
+    simpleScaledCol = scaleActivity(simpleActivityCol, C.SCALING_METHODS.MINUS_LG);
 
     model = await startAnalysis(
       simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, C.SCALING_METHODS.MINUS_LG);
@@ -53,7 +53,7 @@ category('Core', () => {
     complexAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
     complexAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
     complexAlignedSeqCol.setTag(C.TAGS.SEPARATOR, '/');
-    complexScaledCol = scaleActivity(complexActivityCol, '-lg');
+    complexScaledCol = scaleActivity(complexActivityCol, C.SCALING_METHODS.MINUS_LG);
 
     model = await startAnalysis(
       complexActivityCol, complexAlignedSeqCol, null, complexTable, complexScaledCol, C.SCALING_METHODS.MINUS_LG);
@@ -72,7 +72,7 @@ category('Core', () => {
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
-    simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
+    simpleScaledCol = scaleActivity(simpleActivityCol, C.SCALING_METHODS.MINUS_LG);
 
     model = await startAnalysis(
       simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, C.SCALING_METHODS.MINUS_LG);
@@ -104,7 +104,7 @@ category('Core', () => {
   test('Cluster stats - Benchmark HELM 5k', async () => {
     const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k_2.d42'))[0];
     const activityCol = df.getCol('Activity');
-    const scaledActivityCol = scaleActivity(activityCol, 'none');
+    const scaledActivityCol = scaleActivity(activityCol, C.SCALING_METHODS.NONE);
     const clustersCol = df.getCol('Cluster');
     const sequenceCol = df.getCol('HELM');
     sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
@@ -119,7 +119,7 @@ category('Core', () => {
   test('Monomer Position stats - Benchmark HELM 5k', async () => {
     const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
     const activityCol = df.getCol('Activity');
-    const scaledActivityCol = scaleActivity(activityCol, 'none');
+    const scaledActivityCol = scaleActivity(activityCol, C.SCALING_METHODS.NONE);
     const clustersCol = df.getCol('Cluster');
     const sequenceCol = df.getCol('HELM');
     sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
@@ -134,7 +134,7 @@ category('Core', () => {
   test('Analysis start - Benchmark HELM 5k', async () => {
     const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
     const activityCol = df.getCol('Activity');
-    const scaledActivityCol = scaleActivity(activityCol, 'none');
+    const scaledActivityCol = scaleActivity(activityCol, C.SCALING_METHODS.NONE);
     const clustersCol = df.getCol('Cluster');
     const sequenceCol = df.getCol('HELM');
     sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;

package/src/tests/viewers.ts

@@ -18,7 +18,7 @@ category('Viewers: Basic', () => {
   const viewers = DG.Func.find({package: 'Peptides', tags: ['viewer']}).map((f) => f.friendlyName);
   for (const v of viewers) {
     test(v, async () => {
-      await testViewer(v, df.clone(), true);
+      await testViewer(v, df.clone(), {detectSemanticTypes: true});
     }, {skipReason: 'GROK-11534'});
   }
 });

package/src/utils/algorithms.ts

@@ -5,20 +5,31 @@ import {getTypedArrayConstructor} from './misc';
 type MutationCliffInfo = {pos: string, seq1monomer: string, seq2monomer: string, seq1Idx: number, seq2Idx: number};
 
 export function findMutations(activityArray: type.RawData, monomerInfoArray: type.RawColumn[],
-  settings: type.PeptidesSettings = {}): type.MutationCliffs {
+  settings: type.PeptidesSettings = {},
+  targetOptions: {targetCol?: type.RawColumn | null, currentTarget?: string | null} = {}): 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 substitutionsInfo: type.MutationCliffs = new Map();
   const nRows = activityArray.length;
   for (let seq1Idx = 0; seq1Idx < nRows - 1; seq1Idx++) {
+    if (currentTargetIdx !== -1 && targetOptions.targetCol?.rawData[seq1Idx] !== currentTargetIdx)
+      continue;
+
     for (let seq2Idx = seq1Idx + 1; seq2Idx < nRows; seq2Idx++) {
+      if (currentTargetIdx !== -1 && targetOptions.targetCol?.rawData[seq2Idx] !== currentTargetIdx)
+        continue;
+
       let substCounter = 0;
       const activityValSeq1 = activityArray[seq1Idx];
       const activityValSeq2 = activityArray[seq2Idx];
       const delta = activityValSeq1 - activityValSeq2;
-      if (Math.abs(delta) < (settings.minActivityDelta ?? 0))
+      if (Math.abs(delta) < settings.minActivityDelta)
         continue;
 
       let substCounterFlag = false;
@@ -30,7 +41,7 @@ export function findMutations(activityArray: type.RawData, monomerInfoArray: typ
           continue;
 
         substCounter++;
-        substCounterFlag = substCounter > (settings.maxMutations ?? 1);
+        substCounterFlag = substCounter > settings.maxMutations;
         if (substCounterFlag)
           break;
 

package/src/utils/cell-renderer.ts

@@ -21,7 +21,7 @@ export function setAARRenderer(col: DG.Column, alphabet: string): void {
 
 export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D, currentAAR: string,
   currentPosition: string, monomerPositionStats: MonomerPositionStats, bound: DG.Rect,
-  mutationCliffsSelection: types.PositionToAARList, substitutionsInfo: types.MutationCliffs,
+  mutationCliffsSelection: types.PositionToAARList, substitutionsInfo: types.MutationCliffs | null = null,
   twoColorMode: boolean = false): void {
   const positionStats = monomerPositionStats[currentPosition];
   const pVal: number = positionStats[currentAAR].pValue;
@@ -58,7 +58,7 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
   canvasContext.closePath();
 
   canvasContext.fill();
-  if (substitutionsInfo.size > 0) {
+  if (substitutionsInfo !== null && substitutionsInfo.size > 0) {
     canvasContext.textBaseline = 'middle';
     canvasContext.textAlign = 'center';
     canvasContext.fillStyle = DG.Color.toHtml(DG.Color.black);

package/src/utils/misc.ts

@@ -15,15 +15,16 @@ export function getSeparator(col: DG.Column<string>): string {
   return col.getTag(C.TAGS.SEPARATOR) ?? '';
 }
 
-export function scaleActivity(activityCol: DG.Column<number>, scaling: string = 'none'): DG.Column<number> {
+export function scaleActivity(activityCol: DG.Column<number>, scaling: C.SCALING_METHODS = C.SCALING_METHODS.NONE,
+): DG.Column<number> {
   let formula = (x: number): number => x;
   switch (scaling) {
-  case 'none':
+  case C.SCALING_METHODS.NONE:
     break;
-  case 'lg':
+  case C.SCALING_METHODS.LG:
     formula = (x: number): number => Math.log10(x);
     break;
-  case '-lg':
+  case C.SCALING_METHODS.MINUS_LG:
     formula = (x: number): number => -Math.log10(x);
     break;
   default:
@@ -62,7 +63,7 @@ export function calculateSelected(df: DG.DataFrame): type.MonomerSelectionStats
 //     gc.cell.value == DG.INT_NULL || gc.cell.value == DG.FLOAT_NULL;
 // }
 
-export function extractMonomerInfo(col: DG.Column<string>): type.RawColumn {
+export function extractColInfo(col: DG.Column<string>): type.RawColumn {
   return {
     name: col.name,
     cat: col.categories,

package/src/utils/types.ts

@@ -15,6 +15,7 @@ export type PeptidesSettings = {
   sequenceColumnName?: string,
   activityColumnName?: string,
   clustersColumnName?: string,
+  targetColumnName?: string,
   scaling?: SCALING_METHODS,
   isBidirectional?: boolean,
   showMonomerPosition?: boolean,

package/src/viewers/sar-viewer.ts

@@ -11,18 +11,29 @@ export enum MONOMER_POSITION_MODE {
   INVARIANT_MAP = 'Invariant Map',
 }
 
+export enum MONOMER_POSITION_PROPERTIES {
+  COLOR_COLUMN_NAME = 'colorColumnName',
+  AGGREGATION = 'aggregation',
+  TARGET = 'target',
+};
+
 /** Structure-activity relationship viewer */
 export class MonomerPosition extends DG.JsViewer {
-  _titleHost = ui.divText('Mutation Cliffs', {id: 'pep-viewer-title'});
+  _titleHost = ui.divText(MONOMER_POSITION_MODE.MUTATION_CLIFFS, {id: 'pep-viewer-title'});
   _viewerGrid!: DG.Grid;
   _model!: PeptidesModel;
   colorColumnName: string;
   aggregation: string;
+  target: string;
 
   constructor() {
     super();
-    this.colorColumnName = this.string('colorColumnName', C.COLUMNS_NAMES.ACTIVITY_SCALED, {category: 'Invariant Map'});
-    this.aggregation = this.string('aggregation', 'avg', {category: 'Invariant Map', choices: Object.values(DG.AGG)});
+    this.target = this.string(MONOMER_POSITION_PROPERTIES.TARGET, null,
+      {category: MONOMER_POSITION_MODE.MUTATION_CLIFFS, choices: []});
+    this.colorColumnName = this.string(MONOMER_POSITION_PROPERTIES.COLOR_COLUMN_NAME, C.COLUMNS_NAMES.ACTIVITY_SCALED,
+      {category: MONOMER_POSITION_MODE.INVARIANT_MAP});
+    this.aggregation = this.string(MONOMER_POSITION_PROPERTIES.AGGREGATION, DG.AGG.AVG,
+      {category: MONOMER_POSITION_MODE.INVARIANT_MAP, choices: Object.values(DG.AGG)});
   }
 
   get name(): string {return VIEWER_TYPE.MONOMER_POSITION;}
@@ -65,6 +76,9 @@ 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.render();
   }
 
@@ -105,14 +119,14 @@ export class MonomerPosition extends DG.JsViewer {
           mutationCliffsMode.value = true;
           this.mode = MONOMER_POSITION_MODE.MUTATION_CLIFFS;
         });
-        mutationCliffsMode.addPostfix('Mutation Cliffs');
+        mutationCliffsMode.addPostfix(MONOMER_POSITION_MODE.MUTATION_CLIFFS);
         const invariantMapMode = ui.boolInput('', this.mode === MONOMER_POSITION_MODE.INVARIANT_MAP);
         invariantMapMode.root.addEventListener('click', () => {
           mutationCliffsMode.value = false;
           invariantMapMode.value = true;
           this.mode = MONOMER_POSITION_MODE.INVARIANT_MAP;
         });
-        invariantMapMode.addPostfix('Invariant Map');
+        invariantMapMode.addPostfix(MONOMER_POSITION_MODE.INVARIANT_MAP);
         const setDefaultProperties = (input: DG.InputBase): void => {
           $(input.root).find('.ui-input-editor').css('margin', '0px').attr('type', 'radio');
           $(input.root).find('.ui-input-description').css('padding', '0px').css('padding-left', '5px');
@@ -236,7 +250,6 @@ export class MostPotentResiduesViewer extends DG.JsViewer {
 function renderCell(args: DG.GridCellRenderArgs, model: PeptidesModel, isInvariantMap?: boolean,
   colorCol?: DG.Column<number>, colorAgg?: DG.AggregationType): void {
   const renderColNames = [...model.splitSeqDf.columns.names(), C.COLUMNS_NAMES.MEAN_DIFFERENCE];
-  // const mdCol = model.monomerPositionStats.getCol(C.COLUMNS_NAMES.MEAN_DIFFERENCE);
   const canvasContext = args.g;
   const bound = args.bounds;
 
@@ -323,8 +336,12 @@ export function showTooltip(cell: DG.GridCell, x: number, y: number, model: Pept
 
 function chooseAction(aar: string, position: string, isShiftPressed: boolean, isFilter: boolean,
   model: PeptidesModel): void {
-  if (!isShiftPressed)
-    model.initMonomerPositionSelection({cleanInit: true, notify: false});
+  if (!isShiftPressed) {
+    if (isFilter)
+      model.initMonomerPositionFilter({cleanInit: true, notify: false});
+    else
+      model.initMonomerPositionSelection({cleanInit: true, notify: false});
+  }
 
   model.modifyMonomerPositionSelection(aar, position, isFilter);
 }

package/src/widgets/mutation-cliffs.ts

@@ -6,53 +6,62 @@ import {PeptidesModel} from '../model';
 import {getSeparator} from '../utils/misc';
 
 export function mutationCliffsWidget(table: DG.DataFrame, model: PeptidesModel): DG.Widget {
-  const currentFilter = table.filter.getSelectedIndexes();
+  const filteredIndexes = table.filter.getSelectedIndexes();
   const substInfo = model.mutationCliffs;
   const currentCell = model.monomerPositionSelection;
   const positions = Object.keys(currentCell);
 
-  if (!positions.length)
+  if (!positions.length || substInfo === null)
     return new DG.Widget(ui.label('No mutations table generated'));
 
   const substitutionsArray: string[] = [];
   const deltaArray: number[] = [];
   const substitutedToArray: string[] = [];
   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[]>();
 
   for (const pos of positions) {
+    const posCol = table.getCol(pos);
+    const posColCategories = posCol.categories;
+    const posColData = posCol.getRawData();
+
     for (const aar of currentCell[pos]) {
       const substitutionsMap = substInfo.get(aar)?.get(pos) as Map<number, type.UTypedArray> | undefined;
       if (typeof substitutionsMap === 'undefined')
         continue;
 
-      const posCol = table.getCol(pos);
       for (const [referenceIdx, indexArray] of substitutionsMap.entries()) {
-        if (!currentFilter.includes(referenceIdx))
+        if (!filteredIndexes.includes(referenceIdx))
           continue;
 
         const forbiddentIndexes = seenIndexes.get(referenceIdx) ?? [];
-        const baseSequence = alignedSeqCol.get(referenceIdx);
-        const baseActivity = activityScaledCol.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) {
-          if (forbiddentIndexes.includes(subIdx) || !currentFilter.includes(subIdx))
+          if (forbiddentIndexes.includes(subIdx) || !filteredIndexes.includes(subIdx))
             continue;
 
           if (!seenIndexes.has(subIdx))
             seenIndexes.set(subIdx, []);
+          const subSeq = alignedSeqColCategories[alignedSeqColData[subIdx]];
 
           seenIndexes.get(subIdx)!.push(referenceIdx);
-          substitutionsArray.push(`${baseSequence}#${alignedSeqCol.get(subIdx)}`);
-          deltaArray.push(baseActivity - activityScaledCol.get(subIdx));
-          substitutedToArray.push(posCol.get(subIdx));
+          substitutionsArray.push(`${baseSequence}#${subSeq}`);
+          deltaArray.push(baseActivity - activityScaledColData[subIdx]);
+          substitutedToArray.push(posColCategories[posColData[subIdx]]);
         }
       }
     }
   }
 
-  if (!substitutionsArray.length)
+  if (substitutionsArray.length === 0)
     return new DG.Widget(ui.label('No mutations table generated'));
 
   const substCol = DG.Column.fromStrings('Mutation', substitutionsArray);

package/src/widgets/peptides.ts

@@ -72,8 +72,8 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
   const histogramHost = ui.div([], {id: 'pep-hist-host'});
 
   const activityScalingMethod = ui.choiceInput(
-    'Scaling', 'none', ['none', 'lg', '-lg'],
-    async (currentMethod: string): Promise<void> => {
+    'Scaling', C.SCALING_METHODS.NONE, Object.values(C.SCALING_METHODS),
+    async (currentMethod: C.SCALING_METHODS): Promise<void> => {
       scaledCol = scaleActivity(activityColumnChoice.value!, currentMethod);
 
       const hist = DG.DataFrame.fromColumns([scaledCol]).plot.histogram({
@@ -87,7 +87,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
       });
       histogramHost.lastChild?.remove();
       histogramHost.appendChild(hist.root);
-    });
+    }) as DG.InputBase<C.SCALING_METHODS | null>;
   activityScalingMethod.setTooltip('Function to apply for each value in activity column');
 
   const activityScalingMethodState = (): void => {
@@ -101,23 +101,27 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
   activityColumnChoice.fireChanged();
   activityScalingMethod.fireChanged();
 
-  const inputsList = [activityColumnChoice, activityScalingMethod, clustersColumnChoice];
+  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;
+    }
+  });
+  targetColumnChoice.nullable = true;
+
+  const inputsList = [activityColumnChoice, activityScalingMethod, clustersColumnChoice, targetColumnChoice];
   if (seqColInput !== null)
     inputsList.splice(0, 0, seqColInput);
 
-  const bitsetChanged = df.filter.onChanged.subscribe(() => {
-    activityScalingMethodState();
-  });
+  const bitsetChanged = df.filter.onChanged.subscribe(() => activityScalingMethodState());
 
   const startAnalysisCallback = async (): Promise<boolean> => {
     const sequencesCol = col ?? seqColInput!.value;
+    bitsetChanged.unsubscribe();
     if (sequencesCol) {
       const model = await startAnalysis(activityColumnChoice.value!, sequencesCol, clustersColumnChoice.value, df,
-        scaledCol, activityScalingMethod.stringValue as C.SCALING_METHODS ?? C.SCALING_METHODS.NONE);
-      if (model != null) {
-        bitsetChanged.unsubscribe();
-        return true;
-      }
+        scaledCol, activityScalingMethod.value ?? C.SCALING_METHODS.NONE, targetColumnChoice.value);
+      return model != null;
     }
     return false;
   };
@@ -151,10 +155,11 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>):
 
 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,
-): Promise<PeptidesModel | null> {
+  targetColumn: DG.Column<string> | null = null): Promise<PeptidesModel | null> {
   const progress = DG.TaskBarProgressIndicator.create('Loading SAR...');
   let model = null;
-  if (activityColumn.type === DG.TYPE.FLOAT || activityColumn.type === DG.TYPE.INT) {
+  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) {
     //prepare new DF
     const newDf = DG.DataFrame.create(currentDf.rowCount);
     const newDfCols = newDf.columns;
@@ -173,6 +178,9 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
       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)