@datagrok/peptides 1.4.0 → 1.5.1

package/src/package-test.ts

@@ -3,6 +3,7 @@ import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
 
 import './tests/core';
 import './tests/peptide-space-test';
+import './tests/algorithms';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -2,12 +2,11 @@
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import * as C from './utils/constants';
 
 import {analyzePeptidesUI} from './widgets/peptides';
 import {PeptideSimilaritySpaceWidget} from './utils/peptide-similarity-space';
 import {manualAlignmentWidget} from './widgets/manual-alignment';
-import {MutationCliffsViewer, MostPotentResiduesViewer} from './viewers/sar-viewer';
+import {MonomerPosition, MostPotentResiduesViewer} from './viewers/sar-viewer';
 
 import {PeptideSpaceViewer} from './viewers/peptide-space-viewer';
 import {LogoSummary} from './viewers/logo-summary';
@@ -19,7 +18,7 @@ export const _package = new DG.Package();
 let currentTable: DG.DataFrame;
 let alignedSequenceColumn: DG.Column;
 
-export function getMonomerWorks() {
+export function getMonomerWorks(): MonomerWorks | null {
   return monomerWorks;
 };
 
@@ -41,7 +40,7 @@ export async function Peptides(): Promise<void> {
   const wikiLink = ui.link('wiki', 'https://github.com/datagrok-ai/public/blob/master/help/domains/bio/peptides.md');
   const textLink = ui.inlineText(['For more details, see our ', wikiLink, '.']);
   if (monomerWorks == null) {
-    let lib = await grok.functions.call('Bio:getBioLib');
+    const lib = await grok.functions.call('Bio:getBioLib');
     monomerWorks = new MonomerWorks(lib);
   }
   const appDescription = ui.info(
@@ -82,10 +81,13 @@ export async function Peptides(): Promise<void> {
 
 //top-menu: Bio | Peptides...
 //name: Bio Peptides
-export async function peptidesDialog(): Promise<DG.Dialog> {
-  const analyzeObject = await analyzePeptidesUI(grok.shell.t);
-  const dialog = ui.dialog('Analyze Peptides').add(analyzeObject.host).onOK(analyzeObject.callback);
-  dialog.show();
+export function peptidesDialog(): DG.Dialog {
+  const analyzeObject = analyzePeptidesUI(grok.shell.t);
+  const dialog = ui.dialog('Analyze Peptides').add(analyzeObject.host).onOK(async () => {
+    const startSuccess = analyzeObject.callback();
+    if (!startSuccess)
+      dialog.show();
+  });
   return dialog.show();
 }
 
@@ -93,9 +95,9 @@ export async function peptidesDialog(): Promise<DG.Dialog> {
 //tags: panel, widgets
 //input: column col {semType: Macromolecule}
 //output: widget result
-export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
+export function peptidesPanel(col: DG.Column): DG.Widget {
   [currentTable, alignedSequenceColumn] = getOrDefine(col.dataFrame, col);
-  const analyzeObject = await analyzePeptidesUI(currentTable, alignedSequenceColumn);
+  const analyzeObject = analyzePeptidesUI(currentTable, alignedSequenceColumn);
   return new DG.Widget(analyzeObject.host);
 }
 
@@ -103,8 +105,8 @@ export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
 //description: Peptides SAR Viewer
 //tags: viewer
 //output: viewer result
-export function sar(): MutationCliffsViewer {
-  return new MutationCliffsViewer();
+export function sar(): MonomerPosition {
+  return new MonomerPosition();
 }
 
 //name: peptide-sar-viewer-vertical
@@ -174,8 +176,7 @@ export function getPeptidesStructure(col: DG.Column): DG.Widget {
 
 function getOrDefine(dataframe?: DG.DataFrame, column?: DG.Column | null): [DG.DataFrame, DG.Column] {
   dataframe ??= grok.shell.t;
-  // column ??= dataframe.columns.bySemType(C.SEM_TYPES.MACROMOLECULE);
-  column ??= dataframe.getCol(C.COLUMNS_NAMES.MACROMOLECULE);
+  column ??= dataframe.columns.bySemType(DG.SEMTYPE.MACROMOLECULE)!;
   if (column === null)
     throw new Error('Table does not contain aligned sequence columns');
 

package/src/tests/algorithms.ts

@@ -1,29 +1,27 @@
-import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, expect, delay, before} from '@datagrok-libraries/utils/src/test';
+import {category, test, expect, before} from '@datagrok-libraries/utils/src/test';
 
 import {_package} from '../package-test';
-import {startAnalysis} from '../widgets/peptides';
-import {PeptidesModel} from '../model';
-import * as C from '../utils/constants';
-import {scaleActivity} from '../utils/misc';
-import {ALPHABET, TAGS, NOTATION, ALIGNMENT} from '@datagrok-libraries/bio';
 import {findMutations} from '../utils/algorithms';
 import * as type from '../utils/types';
 
 category('Algorithms', () => {
-  let activityCol: DG.Column<number>;
-  let monomerColumns: DG.Column<string>[];
+  let activityCol: type.RawData;
+  let monomerColumns: type.RawColumn[];
   let settings: type.PeptidesSettings;
 
   before(async () => {
-    activityCol = DG.Column.fromList('int', 'test', [1, 2, 5]);
+    activityCol = DG.Column.fromList('int', 'test', [1, 2, 5]).getRawData();
     monomerColumns = [
-      DG.Column.fromList('string', '1', 'ABC'.split('')),
-      DG.Column.fromList('string', '2', 'ACC'.split('')),
-      DG.Column.fromList('string', '3', 'ACD'.split('')),
-    ];
+      DG.Column.fromList('string', '1', 'AAA'.split('')),
+      DG.Column.fromList('string', '2', 'BCC'.split('')),
+      DG.Column.fromList('string', '3', 'CCD'.split('')),
+    ].map((col) => ({
+      name: col.name,
+      rawData: col.getRawData(),
+      cat: col.categories,
+    }));
     settings = {maxMutations: 1, minActivityDelta: 2};
   });
 
@@ -40,12 +38,23 @@ category('Algorithms', () => {
 
     const c3 = c.get('3')!;
     const d3 = d.get('3')!;
-    expect(c3.has(2), true);
-    expect(d3.has(3), true);
+    expect(c3.has(1), true);
+    expect(d3.has(2), true);
 
-    const c32 = c3.get(2)!;
-    const d33 = d3.get(3)!;
-    expect(c32[0], 3);
-    expect(d33[0], 2);
+    const c31 = c3.get(1)!;
+    const d32 = d3.get(2)!;
+    expect(c31[0], 2);
+    expect(d32[0], 1);
   });
+
+  test('MutationCliffs - Benchmark 5k', async () => {
+    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));
+  }, {skipReason: 'Benchmark'});
 });

package/src/tests/core.ts

@@ -15,14 +15,11 @@ category('Core', () => {
   let simpleActivityCol: DG.Column<number>;
   let simpleAlignedSeqCol: DG.Column<string>;
   let simpleScaledCol: DG.Column<number>;
-  let scalingFormula: (x: number) => number;
-  let simpleScaledColName: string;
 
   let complexTable: DG.DataFrame;
   let complexActivityCol: DG.Column<number>;
   let complexAlignedSeqCol: DG.Column<string>;
   let complexScaledCol: DG.Column<number>;
-  let complexScaledColName: string;
   const alignedSequenceCol = 'AlignedSequence';
 
   let model: PeptidesModel | null = null;
@@ -32,7 +29,7 @@ category('Core', () => {
     simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
     simpleActivityCol = simpleTable.getCol(simpleActivityColName);
     simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
-    simpleAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
+    simpleAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     simpleAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);
@@ -52,7 +49,7 @@ category('Core', () => {
     complexTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned_2.csv'));
     complexActivityCol = complexTable.getCol(complexActivityColName);
     complexAlignedSeqCol = complexTable.getCol('MSA');
-    complexAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
+    complexAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     complexAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.UN);
     complexAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
     complexAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);
@@ -74,7 +71,7 @@ category('Core', () => {
     simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
     simpleActivityCol = simpleTable.getCol(simpleActivityColName);
     simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
-    simpleAlignedSeqCol.semType = C.SEM_TYPES.MACROMOLECULE;
+    simpleAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     simpleAlignedSeqCol.setTag(TAGS.aligned, ALIGNMENT.SEQ_MSA);

package/src/tests/utils.ts

@@ -45,8 +45,8 @@ export async function _testDimensionalityReducer(
 
   const [X, Y] = embcols as Array<Float32Array>;
 
-  expect(X.every((v) => v !== null && v !== NaN), true);
-  expect(Y.every((v) => v !== null && v !== NaN), true);
+  expect(X.every((v) => v !== null && !Number.isNaN(v)), true);
+  expect(Y.every((v) => v !== null && !Number.isNaN(v)), true);
 }
 
 /**
@@ -64,12 +64,12 @@ export async function _testDimensionalityReducer(
 export async function _testPeptideSimilaritySpaceViewer(table: DG.DataFrame, alignedSequencesColumn: DG.Column,
   method: string, measure: string, cyclesCount: number): Promise<void> {
   const viewer = await createPeptideSimilaritySpaceViewer(
-    table, method, measure, cyclesCount, undefined, alignedSequencesColumn);
+    table, method, measure, cyclesCount, alignedSequencesColumn, undefined);
   const df = viewer.dataFrame;
 
   const axesNames = ['~X', '~Y', '~MW'];
   const axes = axesNames.map((v) => df.getCol(v).getRawData() as Float32Array);
 
   for (const ax of axes)
-    expect(ax.every((v) => v !== null && v !== NaN), true);
+    expect(ax.every((v) => v !== null && !Number.isNaN(v)), true);
 }

package/src/utils/algorithms.ts

@@ -1,34 +1,32 @@
-import * as DG from 'datagrok-api/dg';
-
 import * as C from './constants';
 import * as type from './types';
 import {getTypedArrayConstructor} from './misc';
 
-//TODO: move out
-export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG.Column<string>[],
+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.SubstitutionsInfo {
-  const nCols = monomerColumns.length;
+  const nCols = monomerInfoArray.length;
   if (nCols == 0)
     throw new Error(`PepAlgorithmError: Couldn't find any column of semType '${C.SEM_TYPES.MONOMER}'`);
 
   const substitutionsInfo: type.SubstitutionsInfo = new Map();
-  const nRows = activityCol.length;
+  const nRows = activityArray.length;
   for (let seq1Idx = 0; seq1Idx < nRows - 1; seq1Idx++) {
     for (let seq2Idx = seq1Idx + 1; seq2Idx < nRows; seq2Idx++) {
       let substCounter = 0;
-      const activityValSeq1 = activityCol.get(seq1Idx)!;
-      const activityValSeq2 = activityCol.get(seq2Idx)!;
+      const activityValSeq1 = activityArray[seq1Idx];
+      const activityValSeq2 = activityArray[seq2Idx];
       const delta = activityValSeq1 - activityValSeq2;
       if (Math.abs(delta) < (settings.minActivityDelta ?? 0))
         continue;
 
       let substCounterFlag = false;
-      const tempData: { pos: string, seq1monomer: string, seq2monomer: string, seq1Idx: number, seq2Idx: number }[] =
-        [];
-      for (const currentPosCol of monomerColumns) {
-        const seq1monomer = currentPosCol.get(seq1Idx)!;
-        const seq2monomer = currentPosCol.get(seq2Idx)!;
-        if (seq1monomer == seq2monomer)
+      const tempData: MutationCliffInfo[] = [];
+      for (const monomerInfo of monomerInfoArray) {
+        const seq1category = monomerInfo.rawData[seq1Idx];
+        const seq2category = monomerInfo.rawData[seq2Idx];
+        if (seq1category == seq2category)
           continue;
 
         substCounter++;
@@ -37,9 +35,9 @@ export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG
           break;
 
         tempData.push({
-          pos: currentPosCol.name,
-          seq1monomer: seq1monomer,
-          seq2monomer: seq2monomer,
+          pos: monomerInfo.name,
+          seq1monomer: monomerInfo.cat![seq1category],
+          seq2monomer: monomerInfo.cat![seq2category],
           seq1Idx: seq1Idx,
           seq2Idx: seq2Idx,
         });
@@ -49,20 +47,22 @@ export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG
         continue;
 
       for (const tempDataElement of tempData) {
-        const position = tempDataElement.pos;
-
         //Working with seq1monomer
         const seq1monomer = tempDataElement.seq1monomer;
         if (!substitutionsInfo.has(seq1monomer))
           substitutionsInfo.set(seq1monomer, new Map());
 
+        const position = tempDataElement.pos;
+
         let positionsMap = substitutionsInfo.get(seq1monomer)!;
         if (!positionsMap.has(position))
           positionsMap.set(position, new Map());
 
         let indexes = positionsMap.get(position)!;
-
-        !indexes.has(seq1Idx) ? indexes.set(seq1Idx, [seq2Idx]) : (indexes.get(seq1Idx)! as number[]).push(seq2Idx);
+        if (indexes.has(seq1Idx))
+          (indexes.get(seq1Idx)! as number[]).push(seq2Idx);
+        else
+          indexes.set(seq1Idx, [seq2Idx]);
 
         //Working with seq2monomer
         const seq2monomer = tempDataElement.seq2monomer;
@@ -74,7 +74,10 @@ export function findMutations(activityCol: DG.Column<number>, monomerColumns: DG
           positionsMap.set(position, new Map());
 
         indexes = positionsMap.get(position)!;
-        !indexes.has(seq2Idx) ? indexes.set(seq2Idx, [seq1Idx]) : (indexes.get(seq2Idx)! as number[]).push(seq1Idx);
+        if (indexes.has(seq2Idx))
+          (indexes.get(seq2Idx)! as number[]).push(seq1Idx);
+        else
+          indexes.set(seq2Idx, [seq1Idx]);
       }
     }
   }

package/src/utils/cell-renderer.ts

@@ -11,11 +11,10 @@ function renderCellSelection(canvasContext: CanvasRenderingContext2D, bound: DG.
 }
 
 /** A function that sets amino acid residue cell renderer to the specified column */
-export function setAARRenderer(col: DG.Column, alphabet: string, grid: DG.Grid, timeout: number = 500): void {
+export function setAARRenderer(col: DG.Column, alphabet: string): void {
   col.semType = C.SEM_TYPES.MONOMER;
   col.setTag('cell.renderer', C.SEM_TYPES.MONOMER);
   col.tags[C.TAGS.ALPHABET] = alphabet;
-  // setTimeout(() => grid.columns.byName(col.name)!.width = 60, timeout);
 }
 
 export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D, currentAAR: string,
@@ -62,9 +61,10 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
   if (substitutionsInfo.size > 0) {
     canvasContext.textBaseline = 'middle';
     canvasContext.textAlign = 'center';
-    // canvasContext.fillStyle = DG.Color.toHtml(DG.Color.getContrastColor(DG.Color.fromHtml(coef)));
     canvasContext.fillStyle = DG.Color.toHtml(DG.Color.black);
     canvasContext.font = '13px Roboto, Roboto Local, sans-serif';
+    canvasContext.shadowBlur = 5;
+    canvasContext.shadowColor = DG.Color.toHtml(DG.Color.white);
     let substValue = 0;
     substitutionsInfo.get(currentAAR)?.get(currentPosition)?.forEach((idxs) => substValue += idxs.length);
     if (substValue && substValue != 0)
@@ -77,7 +77,10 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
 }
 
 export function renderInvaraintMapCell(canvasContext: CanvasRenderingContext2D, currentAAR: string,
-  currentPosition: string, invariantMapSelection: types.PositionToAARList, cellValue: number, bound: DG.Rect): void {
+  currentPosition: string, invariantMapSelection: types.PositionToAARList, cellValue: number, bound: DG.Rect,
+  color: number): void {
+  canvasContext.fillStyle = DG.Color.toHtml(color);
+  canvasContext.fillRect(bound.x, bound.y, bound.width, bound.height);
   canvasContext.font = '13px Roboto, Roboto Local, sans-serif';
   canvasContext.textAlign = 'center';
   canvasContext.textBaseline = 'middle';
@@ -89,7 +92,7 @@ export function renderInvaraintMapCell(canvasContext: CanvasRenderingContext2D,
     renderCellSelection(canvasContext, bound);
 }
 
-export function renderLogoSummaryCell(canvasContext: CanvasRenderingContext2D, cellValue: number,
+export function renderLogoSummaryCell(canvasContext: CanvasRenderingContext2D, cellValue: string, cellRawData: number,
   clusterSelection: number[], bound: DG.Rect): void {
   canvasContext.font = '13px Roboto, Roboto Local, sans-serif';
   canvasContext.textAlign = 'center';
@@ -97,7 +100,7 @@ export function renderLogoSummaryCell(canvasContext: CanvasRenderingContext2D, c
   canvasContext.fillStyle = '#000';
   canvasContext.fillText(cellValue.toString(), bound.x + (bound.width / 2), bound.y + (bound.height / 2), bound.width);
 
-  if (clusterSelection.includes(cellValue))
+  if (clusterSelection.includes(cellRawData))
     renderCellSelection(canvasContext, bound);
 }
 
@@ -111,25 +114,26 @@ export function drawLogoInBounds(ctx: CanvasRenderingContext2D, bounds: DG.Rect,
   drawOptions.marginVertical ??= 5;
   drawOptions.marginHorizontal ??= 5;
 
+  const pr = window.devicePixelRatio;
   const totalSpaceBetweenLetters = (statsInfo.orderedIndexes.length - 1) * drawOptions.upperLetterAscent;
-  const barHeight = bounds.height - 2 * drawOptions.marginVertical - totalSpaceBetweenLetters;
+  const barHeight = (bounds.height - 2 * drawOptions.marginVertical - totalSpaceBetweenLetters) * pr;
   const leftShift = drawOptions.marginHorizontal * 2;
-  const barWidth = bounds.width - leftShift * 2;
-  const xStart = bounds.x + leftShift;
-  const selectionWidth = 4;
-  const xSelection = bounds.x + 3;
-  let currentY = bounds.y + drawOptions.marginVertical;
+  const barWidth = (bounds.width - leftShift * 2) * pr;
+  const xStart = (bounds.x + leftShift) * pr;
+  const selectionWidth = 4 * pr;
+  const xSelection = (bounds.x + 3) * pr;
+  let currentY = (bounds.y + drawOptions.marginVertical) * pr;
 
   const monomerBounds: {[monomer: string]: DG.Rect} = {};
   for (const index of statsInfo.orderedIndexes) {
     const monomer = statsInfo.monomerCol.get(index)!;
     const monomerHeight = barHeight * (statsInfo.countCol.get(index)! / rowCount);
     const selectionHeight = barHeight * ((monomerSelectionStats[monomer] ?? 0) / rowCount);
-    const currentBound = new DG.Rect(xStart, currentY, barWidth, monomerHeight);
+    const currentBound = new DG.Rect(xStart / pr, currentY / pr, barWidth / pr, monomerHeight / pr);
     monomerBounds[monomer] = currentBound;
 
     ctx.resetTransform();
-    if (monomer !== '-') {
+    if (monomer !== '-' && monomer !== '') {
       const monomerTxt = bio.monomerToShort(monomer, 5);
       const mTm: TextMetrics = ctx.measureText(monomerTxt);
 
@@ -142,10 +146,12 @@ export function drawLogoInBounds(ctx: CanvasRenderingContext2D, bounds: DG.Rect,
       ctx.textBaseline = 'top';
       ctx.font = drawOptions.fontStyle;
       // Hacks to scale uppercase characters to target rectangle
-      ctx.setTransform(barWidth / mTm.width, 0, 0, monomerHeight / drawOptions.upperLetterHeight, xStart, currentY);
+      const widthTransform = barWidth / mTm.width;
+      const heightTransfrom = monomerHeight / drawOptions.upperLetterHeight;
+      ctx.setTransform(widthTransform, 0, 0, heightTransfrom, xStart, currentY);
       ctx.fillText(monomerTxt, 0, 0);
     }
-    currentY += monomerHeight + drawOptions.upperLetterAscent;
+    currentY += monomerHeight + drawOptions.upperLetterAscent * pr;
   }
 
   return monomerBounds;

package/src/utils/constants.ts

@@ -1,16 +1,13 @@
 export enum COLUMNS_NAMES {
   SPLIT_COL = '~split',
-  ACTIVITY = '~activity',
-  ACTIVITY_SCALED = 'activity_scaled',
-  ALIGNED_SEQUENCE = '~aligned_sequence',
+  ACTIVITY_SCALED = 'Scaled activity',
   MONOMER = 'AAR',
   POSITION = 'Pos',
   P_VALUE = 'pValue',
   MEAN_DIFFERENCE = 'Mean difference',
   COUNT = 'Count',
   RATIO = 'Ratio',
-  CLUSTERS = 'clusters',
-  MACROMOLECULE = 'macromolecule',
+  MEMBERS = 'Members',
 }
 
 export enum CATEGORIES {
@@ -25,47 +22,17 @@ export enum TAGS {
   SELECTION = 'selection',
   ALPHABET = 'alphabet',
   FILTER = 'filter',
-  CLUSTERS = 'clusters',
   SAR_MODE = 'sarMode',
   CLUSTER_SELECTION = 'clusterSelection',
   VISIBLE = 'visible',
+  SETTINGS = 'settings',
 }
 
 export enum SEM_TYPES {
   MONOMER = 'Monomer',
-  MACROMOLECULE = 'Macromolecule',
   MACROMOLECULE_DIFFERENCE = 'MacromoleculeDifference',
-  ACTIVITY = 'activity',
-  ACTIVITY_SCALED = 'activityScaled',
 }
 
-export const STATS = 'stats';
-
 export const EMBEDDING_STATUS = 'embeddingStatus';
 
 export const PEPTIDES_ANALYSIS = 'isPeptidesAnalysis';
-
-export enum FLAGS {
-  CELL_CHANGING = 'isCellChanging',
-}
-
-export const aarGroups = {
-  'R': 'PC', 'H': 'PC', 'K': 'PC',
-  'D': 'NC', 'E': 'NC',
-  'S': 'U', 'T': 'U', 'N': 'U', 'Q': 'U',
-  'C': 'SC', 'U': 'SC', 'G': 'SC', 'P': 'SC',
-  'A': 'H', 'V': 'H', 'I': 'H', 'L': 'H', 'M': 'H', 'F': 'H', 'Y': 'H', 'W': 'H',
-  '-': '-',
-};
-
-export const groupDescription: {[key: string]: {'description': string, aminoAcids: string[]}} = {
-  'PC': {'description': 'Positive Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['R', 'H', 'K']},
-  'NC': {'description': 'Negative Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['D', 'E']},
-  'U': {'description': 'Amino Acids with Polar Uncharged Side Chains', 'aminoAcids': ['S', 'T', 'N', 'Q']},
-  'SC': {'description': 'Special Cases', 'aminoAcids': ['C', 'U', 'G', 'P']},
-  'H': {
-    'description': 'Amino Acids with Hydrophobic Side Chain',
-    'aminoAcids': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
-  },
-  '-': {'description': 'Unknown Amino Acid', 'aminoAcids': ['-']},
-};

package/src/utils/misc.ts

@@ -2,11 +2,6 @@ import * as DG from 'datagrok-api/dg';
 import * as C from './constants';
 import * as type from './types';
 
-import {AminoacidsPalettes} from '@datagrok-libraries/bio/src/aminoacids';
-import {NucleotidesPalettes} from '@datagrok-libraries/bio/src/nucleotides';
-import {UnknownSeqPalettes} from '@datagrok-libraries/bio/src/unknown';
-import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
-
 export function getTypedArrayConstructor(
   maxNum: number): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor {
   return maxNum < 256 ? Uint8Array :
@@ -20,27 +15,23 @@ export function getSeparator(col: DG.Column<string>): string {
 
 export function scaleActivity(activityCol: DG.Column<number>, scaling: string = 'none'): DG.Column<number> {
   let formula = (x: number): number => x;
-  let newColName = 'activity';
   switch (scaling) {
   case 'none':
     break;
   case 'lg':
     formula = (x: number): number => Math.log10(x);
-    newColName = `Log10(${newColName})`;
     break;
   case '-lg':
     formula = (x: number): number => -Math.log10(x);
-    newColName = `-Log10(${newColName})`;
     break;
   default:
     throw new Error(`ScalingError: method \`${scaling}\` is not available.`);
   }
-  const scaledCol = DG.Column.float(C.COLUMNS_NAMES.ACTIVITY_SCALED, activityCol.length).init((i) => {
-    const val = activityCol.get(i);
-    return val ? formula(val) : val;
-  });
-  scaledCol.semType = C.SEM_TYPES.ACTIVITY_SCALED;
-  scaledCol.setTag('gridName', newColName);
+  const scaledCol: DG.Column<number> = DG.Column.float(C.COLUMNS_NAMES.ACTIVITY_SCALED, activityCol.length)
+    .init((i) => {
+      const val = activityCol.get(i);
+      return val ? formula(val) : val;
+    });
 
   return scaledCol;
 }
@@ -53,7 +44,7 @@ export function calculateSelected(df: DG.DataFrame): type.MonomerSelectionStats
       const monomer = col.get(idx);
       if (!monomer)
         continue;
-      
+
       selectedObj[col.name] ??= {};
       selectedObj[col.name][monomer] ??= 0;
       selectedObj[col.name][monomer] += 1;
@@ -67,3 +58,11 @@ export function isGridCellInvalid(gc: DG.GridCell | null): boolean {
   return !gc || !gc.cell.value || !gc.tableColumn || gc.tableRowIndex == null || gc.tableRowIndex == -1 ||
     gc.cell.value == DG.INT_NULL || gc.cell.value == DG.FLOAT_NULL;
 }
+
+export function extractMonomerInfo(col: DG.Column<string>): type.RawColumn {
+  return {
+    name: col.name,
+    cat: col.categories,
+    rawData: col.getRawData(),
+  };
+}

package/src/utils/peptide-similarity-space.ts

@@ -38,14 +38,11 @@ export function cleanAlignedSequencesColumn(col: DG.Column): Array<string> {
  * @param {boolean} [zoom=false] Whether to fit view.
  * @return {Promise<DG.ScatterPlotViewer>} A viewer.
  */
-export async function createPeptideSimilaritySpaceViewer(
-  table: DG.DataFrame, method: string, measure: string, cyclesCount: number, view?: DG.TableView, col?: DG.Column,
-): Promise<DG.ScatterPlotViewer> {
+export async function createPeptideSimilaritySpaceViewer(table: DG.DataFrame, method: string, measure: string,
+  cyclesCount: number, col: DG.Column, activityColName?: string, view?: DG.TableView): Promise<DG.ScatterPlotViewer> {
   const pi = DG.TaskBarProgressIndicator.create('Creating embedding...');
 
   const axesNames = ['~X', '~Y', '~MW'];
-  // col ??= table.columns.bySemType(C.SEM_TYPES.MACROMOLECULE)!;
-  col ??= table.getCol(C.COLUMNS_NAMES.MACROMOLECULE);
   const columnData = col.toList().map((v) => AlignedSequenceEncoder.clean(v));
 
   const reduceDimRes: IReduceDimensionalityResult = await createDimensinalityReducingWorker(
@@ -81,7 +78,7 @@ export async function createPeptideSimilaritySpaceViewer(
       table.columns.insert(newCol);
   }
 
-  const colorColName = table.columns.bySemType(C.SEM_TYPES.ACTIVITY)?.name ?? '~MW';
+  const colorColName = activityColName ?? '~MW';
   const viewerOptions = {
     x: '~X', y: '~Y', color: colorColName, size: '~MW', title: 'Peptide Space',
     showYSelector: false, showXSelector: false, showColorSelector: false, showSizeSelector: false,
@@ -137,7 +134,7 @@ export class PeptideSimilaritySpaceWidget {
    */
   public async drawViewer(): Promise<DG.Viewer> {
     const viewer = await createPeptideSimilaritySpaceViewer(
-      this.currentDf, this.method, this.metrics, this.cycles, undefined, this.alignedSequencesColumn);
+      this.currentDf, this.method, this.metrics, this.cycles, this.alignedSequencesColumn, undefined);
     viewer.root.style.width = 'auto';
     return viewer;
   }

package/src/utils/statistics.ts

@@ -1,6 +1,5 @@
-import * as DG from 'datagrok-api/dg';
-
 import {tTest} from '@datagrok-libraries/statistics/src/tests';
+import {RawData} from './types';
 
 export type Stats = {
   count: number,
@@ -9,21 +8,31 @@ export type Stats = {
   ratio: number,
 };
 
-type StatsData = Float32Array | Float64Array | Int32Array | Uint32Array | number[];
+export type MaskInfo = {
+  trueCount: number,
+  falseCount: number,
+  mask: boolean[] | Int32Array,
+};
+
+export function getStats(data: RawData | number[], maskInfo: MaskInfo): Stats {
+  const selected = new Float32Array(maskInfo.trueCount);
+  const rest = new Float32Array(maskInfo.falseCount);
 
-export function getStats(data: StatsData, mask: DG.BitSet): Stats {
-  const selected = new Float32Array(mask.trueCount);
-  const rest = new Float32Array(mask.falseCount);
   let selectedIndex = 0;
   let restIndex = 0;
-  data.forEach((v, i) => mask.get(i) ? selected[selectedIndex++] = v : rest[restIndex++] = v);
+  for (let i = 0; i < data.length; ++i) {
+    if (maskInfo.mask[i])
+      selected[selectedIndex++] = data[i];
+    else
+      rest[restIndex++] = data[i];
+  }
 
   const testResult = tTest(selected, rest);
   const currentMeanDiff = testResult['Mean difference']!;
   return {
     count: selected.length,
-    pValue: testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'],
-    meanDifference: currentMeanDiff,
+    pValue: testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'] || 0,
+    meanDifference: currentMeanDiff || 0,
     ratio: selected.length / data.length,
   };
 }