@datagrok/peptides 1.12.0 → 1.13.1

package/src/package.ts

@@ -173,7 +173,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
+//meta.isDemoScript: False
 export async function macromoleculeSarFastaDemo(): Promise<void> {
   return macromoleculeSarFastaDemoUI();
 }

package/src/tests/core.ts

@@ -44,10 +44,6 @@ category('Core', () => {
       overlayInit = true;
       grok.log.debug('Overlay initialized');
     });
-    model!._analysisView!.grid.onBeforeDrawOverlay.subscribe(() => {
-      overlayInit = false;
-      grok.log.debug('Overlay is drawing');
-    });
 
     // Ensure grid finished initializing to prevent Unhandled exceptions
     let accrodionInit = false;
@@ -58,7 +54,7 @@ category('Core', () => {
     await awaitCheck(() => overlayInit, 'Overlay never finished initializing', 2000);
 
     model!.mutationCliffsSelection = {'11': ['D']};
-  }, {skipReason: 'GROK-13790: Unhandled exception'});
+  }, {skipReason: 'Ignore unhandled exceptions in tests'});
 
   test('Start analysis: сomplex', async () => {
     const complexActivityColName = 'Activity';
@@ -80,10 +76,6 @@ category('Core', () => {
       overlayInit = true;
       grok.log.debug('Overlay initialized');
     });
-    model!._analysisView!.grid.onBeforeDrawOverlay.subscribe(() => {
-      overlayInit = false;
-      grok.log.debug('Overlay is drawing');
-    });
 
     // Ensure grid finished initializing to prevent Unhandled exceptions
     let accrodionInit = false;
@@ -95,7 +87,7 @@ category('Core', () => {
 
     if (model !== null)
       model.mutationCliffsSelection = {'13': ['-']};
-  }, {skipReason: 'GROK-13790: Unhandled exception'});
+  }, {skipReason: 'Ignore unhandled exceptions in tests'});
 
   test('Save and load project', async () => {
     const simpleActivityColName = 'IC50';

package/src/tests/table-view.ts

@@ -3,7 +3,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, test, before, expect, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
-import {PeptidesModel} from '../model';
+import {CLUSTER_TYPE, PeptidesModel} from '../model';
 import {startAnalysis} from '../widgets/peptides';
 import {scaleActivity} from '../utils/misc';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
@@ -19,10 +19,10 @@ category('Table view', () => {
   let scaledActivityCol: DG.Column<number>;
   const scaling = 'none' as SCALING_METHODS;
 
-  const firstPair = {monomer: 'Aze', position: '10', mcCount: 3, imCount: 1};
-  const secondPair = {monomer: 'meI', position: '1', mcCount: 2, imCount: 10};
-  const firstCluster = {name: '0', count: 3};
-  const secondCluster = {name: '1', count: 3};
+  const firstPair = {monomerOrCluster: 'Aze', positionOrClusterType: '10', mcCount: 3, imCount: 1};
+  const secondPair = {monomerOrCluster: 'meI', positionOrClusterType: '1', mcCount: 2, imCount: 10};
+  const firstCluster = {monomerOrCluster: '0', positionOrClusterType: CLUSTER_TYPE.ORIGINAL, count: 3};
+  const secondCluster = {monomerOrCluster: '1', positionOrClusterType: CLUSTER_TYPE.ORIGINAL, count: 3};
 
   before(async () => {
     df = DG.DataFrame.fromCsv(await _package.files.readAsText('tests/HELM_small.csv'));
@@ -49,8 +49,8 @@ category('Table view', () => {
   });
 
   test('Tooltip', async () => {
-    expect(model.showMonomerTooltip(firstPair.monomer, 0, 0), true,
-      `Couldn't structure for monomer ${firstPair.monomer}`);
+    expect(model.showMonomerTooltip(firstPair.monomerOrCluster, 0, 0), true,
+      `Couldn't structure for monomer ${firstPair.monomerOrCluster}`);
   }, {skipReason: 'Need to find a way to replace _package variable to call for Bio function with tests'});
 
   test('Visible columns', async () => {
@@ -73,29 +73,29 @@ category('Table view', () => {
       expect(selectedMonomers.length, 0, `Selection is not empty for position ${position} after initialization`);
 
     // Select first monomer-position pair
-    model.modifyMonomerPositionSelection(firstPair.monomer, firstPair.position, false);
-    expect(model.mutationCliffsSelection[firstPair.position].includes(firstPair.monomer), true,
-      `Monomer ${firstPair.monomer} is not selected at position ${firstPair.position}`);
+    model.modifyMutationCliffsSelection(firstPair);
+    expect(model.mutationCliffsSelection[firstPair.positionOrClusterType].includes(firstPair.monomerOrCluster), true,
+      `Monomer ${firstPair.monomerOrCluster} is not selected at position ${firstPair.positionOrClusterType}`);
     expect(selection.trueCount, firstPair.mcCount, `Selection count is not equal to ${firstPair.mcCount} ` +
-      `for monomer ${firstPair.monomer} at position ${firstPair.position}`);
+      `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType}`);
 
     // Select second monomer-position pair
-    model.modifyMonomerPositionSelection(secondPair.monomer, secondPair.position, false);
-    expect(model.mutationCliffsSelection[secondPair.position].includes(secondPair.monomer), true,
-      `Monomer ${secondPair.monomer} is not selected at position ${secondPair.position}`);
+    model.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: false});
+    expect(model.mutationCliffsSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), true,
+      `Monomer ${secondPair.monomerOrCluster} is not selected at position ${secondPair.positionOrClusterType}`);
     expect(selection.trueCount, secondPair.mcCount + firstPair.mcCount, `Selection count is not equal ` +
-      `to ${secondPair.mcCount + firstPair.mcCount} for monomer ${secondPair.monomer} at ` +
-      `position ${secondPair.position}`);
+      `to ${secondPair.mcCount + firstPair.mcCount} for monomer ${secondPair.monomerOrCluster} at ` +
+      `position ${secondPair.positionOrClusterType}`);
 
     // Deselect second monomer-position pair
-    model.modifyMonomerPositionSelection(secondPair.monomer, secondPair.position, false);
-    expect(model.mutationCliffsSelection[secondPair.position].includes(secondPair.monomer), false,
-      `Monomer ${secondPair.monomer} is still selected at position ${secondPair.position} after deselection`);
+    model.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
+    expect(model.mutationCliffsSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), false,
+      `Monomer ${secondPair.monomerOrCluster} is still selected at position ${secondPair.positionOrClusterType} after deselection`);
     expect(selection.trueCount, firstPair.mcCount, `Selection count is not equal to ${firstPair.mcCount} ` +
-      `for monomer ${firstPair.monomer} at position ${firstPair.position}`);
+      `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType}`);
 
     // Clear monomer-position selection
-    model.initMutationCliffsSelection({cleanInit: true});
+    model.initMutationCliffsSelection();
     for (const [position, selectedMonomers] of Object.entries(model.mutationCliffsSelection)) {
       expect(selectedMonomers.length, 0, `Selection is not empty for position ${position} after clearing ` +
         `monomer-position selection`);
@@ -103,29 +103,29 @@ category('Table view', () => {
     expect(selection.trueCount, 0, `Selection count is not equal to 0 after clearing monomer-position selection`);
 
     // Select first cluster
-    model.modifyClusterSelection(firstCluster.name);
-    expect(model.clusterSelection.includes(firstCluster.name), true,
-      `Cluster ${firstCluster.name} is not selected`);
+    model.modifyClusterSelection(firstCluster);
+    expect(model.clusterSelection[firstCluster.positionOrClusterType].includes(firstCluster.monomerOrCluster), true,
+      `Cluster ${firstCluster.monomerOrCluster} is not selected`);
     expect(selection.trueCount, firstCluster.count, `Selection count is not equal to ${firstCluster.count} for ` +
-      `cluster ${firstCluster.name}`);
+      `cluster ${firstCluster.monomerOrCluster}`);
 
     // Select second cluster
-    model.modifyClusterSelection(secondCluster.name);
-    expect(model.clusterSelection.includes(secondCluster.name), true,
-      `Cluster ${secondCluster.name} is not selected`);
+    model.modifyClusterSelection(secondCluster, {shiftPressed: true, ctrlPressed: false});
+    expect(model.clusterSelection[secondCluster.positionOrClusterType].includes(secondCluster.monomerOrCluster), true,
+      `Cluster ${secondCluster.monomerOrCluster} is not selected`);
     expect(selection.trueCount, firstCluster.count + secondCluster.count, `Selection count is not equal to ` +
-      `${firstCluster.count + secondCluster.count} for cluster ${firstCluster.name} and cluster ${secondCluster.name}`);
+      `${firstCluster.count + secondCluster.count} for cluster ${firstCluster.monomerOrCluster} and cluster ${secondCluster.monomerOrCluster}`);
 
     // Deselect first cluster
-    model.modifyClusterSelection(firstCluster.name);
-    expect(model.clusterSelection.includes(firstCluster.name), false,
-      `Cluster ${firstCluster.name} is still selected after deselection`);
+    model.modifyClusterSelection(firstCluster, {shiftPressed: true, ctrlPressed: true});
+    expect(model.clusterSelection[firstCluster.positionOrClusterType].includes(firstCluster.monomerOrCluster), false,
+      `Cluster ${firstCluster.monomerOrCluster} is still selected after deselection`);
     expect(selection.trueCount, secondCluster.count, `Selection count is not equal to ${secondCluster.count} for ` +
-      `cluster ${secondCluster.name} after deselection of cluster ${firstCluster.name}`);
+      `cluster ${secondCluster.monomerOrCluster} after deselection of cluster ${firstCluster.monomerOrCluster}`);
 
     // Clear selection
     model.initClusterSelection();
-    expect(model.clusterSelection.length, 0, `Selection is not empty after clearing cluster selection`);
+    expect(model.isClusterSelectionEmpty, true, `Selection is not empty after clearing cluster selection`);
     expect(selection.trueCount, 0, `Selection count is not equal to 0 after clearing cluster selection`);
   });
 
@@ -136,30 +136,30 @@ category('Table view', () => {
       expect(filteredMonomers.length, 0, `Filter is not empty for position ${position} after initialization`);
 
     // Select by second monomer-position pair
-    model.modifyMonomerPositionSelection(secondPair.monomer, secondPair.position, true);
-    expect(model.invariantMapSelection[secondPair.position].includes(secondPair.monomer), true,
-      `Monomer ${secondPair.monomer} is not filtered at position ${secondPair.position}`);
+    model.modifyInvariantMapSelection(secondPair);
+    expect(model.invariantMapSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), true,
+      `Monomer ${secondPair.monomerOrCluster} is not filtered at position ${secondPair.positionOrClusterType}`);
     expect(selection.trueCount, secondPair.imCount, `Filter count is not equal to ${secondPair.imCount} ` +
-      `for monomer ${secondPair.monomer} at position ${secondPair.position}`);
+      `for monomer ${secondPair.monomerOrCluster} at position ${secondPair.positionOrClusterType}`);
 
     // Select by first monomer-position pair
-    model.modifyMonomerPositionSelection(firstPair.monomer, firstPair.position, true);
-    expect(model.invariantMapSelection[firstPair.position].includes(firstPair.monomer), true,
-      `Monomer ${firstPair.monomer} is not filtered at position ${firstPair.position}`);
+    model.modifyInvariantMapSelection(firstPair, {shiftPressed: true, ctrlPressed: false});
+    expect(model.invariantMapSelection[firstPair.positionOrClusterType].includes(firstPair.monomerOrCluster), true,
+      `Monomer ${firstPair.monomerOrCluster} is not filtered at position ${firstPair.positionOrClusterType}`);
     expect(selection.trueCount, secondPair.imCount, `Filter count is not equal to ${secondPair.imCount} ` +
-      `for monomer ${firstPair.monomer} at position ${firstPair.position}`);
+      `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType}`);
 
     // Deselect filter for second monomer-position pair
-    model.modifyMonomerPositionSelection(secondPair.monomer, secondPair.position, true);
-    expect(model.invariantMapSelection[secondPair.position].includes(secondPair.monomer), false,
-      `Monomer ${secondPair.monomer} is still filtered at position ${secondPair.position} after ` +
+    model.modifyInvariantMapSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
+    expect(model.invariantMapSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), false,
+      `Monomer ${secondPair.monomerOrCluster} is still filtered at position ${secondPair.positionOrClusterType} after ` +
       `deselection`);
     expect(selection.trueCount, firstPair.imCount, `Filter count is not equal to ${firstPair.imCount} ` +
-      `for monomer ${firstPair.monomer} at position ${firstPair.position} after deselection of ` +
-      `monomer ${secondPair.monomer} at position ${secondPair.position}`);
+      `for monomer ${firstPair.monomerOrCluster} at position ${firstPair.positionOrClusterType} after deselection of ` +
+      `monomer ${secondPair.monomerOrCluster} at position ${secondPair.positionOrClusterType}`);
 
     // Clear selection
-    model.initInvariantMapSelection({cleanInit: true});
+    model.initInvariantMapSelection();
     expect(selection.trueCount, 0, `Filter count is not equal to ${0} after clearing monomer-position filter`);
 
     for (const [position, filteredMonomers] of Object.entries(model.invariantMapSelection)) {

package/src/tests/viewers.ts

@@ -3,12 +3,12 @@ import * as DG from 'datagrok-api/dg';
 
 import {awaitCheck, before, category, expect, test, testViewer} from '@datagrok-libraries/utils/src/test';
 import {aligned1} from './test-data';
-import {PeptidesModel, VIEWER_TYPE} from '../model';
+import {CLUSTER_TYPE, PeptidesModel, VIEWER_TYPE} from '../model';
 import {_package} from '../package-test';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {scaleActivity} from '../utils/misc';
 import {startAnalysis} from '../widgets/peptides';
-import {MONOMER_POSITION_MODE, MonomerPosition, MostPotentResidues, showTooltip} from '../viewers/sar-viewer';
+import {SELECTION_MODE, MonomerPosition, MostPotentResidues} from '../viewers/sar-viewer';
 import {SCALING_METHODS} from '../utils/constants';
 import {LST_PROPERTIES, LogoSummaryTable} from '../viewers/logo-summary';
 import {PositionHeight} from '@datagrok-libraries/bio/src/viewers/web-logo';
@@ -63,7 +63,8 @@ category('Viewers: Monomer-Position', () => {
   test('Tooltip', async () => {
     const cellCoordinates = {col: '9', row: 6};
     const gc = mpViewer.viewerGrid.cell(cellCoordinates.col, cellCoordinates.row);
-    expect(showTooltip(gc, 0, 0, model), true,
+    const mp = mpViewer.getMonomerPosition(gc);
+    expect(model.showTooltip(mp, 0, 0), true,
       `Tooltip is not shown for grid cell at column '${cellCoordinates.col}', row ${cellCoordinates.row}`);
   });
 
@@ -71,16 +72,16 @@ category('Viewers: Monomer-Position', () => {
     if (mpViewer === null)
       throw new Error('Monomer-Position viewer doesn\'t exist');
 
-    expect(mpViewer.mode, MONOMER_POSITION_MODE.MUTATION_CLIFFS,
-      `Default Monomer-Position mode is not ${MONOMER_POSITION_MODE.MUTATION_CLIFFS}`);
+    expect(mpViewer.mode, SELECTION_MODE.MUTATION_CLIFFS,
+      `Default Monomer-Position mode is not ${SELECTION_MODE.MUTATION_CLIFFS}`);
 
-    mpViewer.mode = MONOMER_POSITION_MODE.INVARIANT_MAP;
-    expect(mpViewer.mode, MONOMER_POSITION_MODE.INVARIANT_MAP,
-      `Monomer-Position mode is not ${MONOMER_POSITION_MODE.INVARIANT_MAP} after switching`);
+    mpViewer.mode = SELECTION_MODE.INVARIANT_MAP;
+    expect(mpViewer.mode, SELECTION_MODE.INVARIANT_MAP,
+      `Monomer-Position mode is not ${SELECTION_MODE.INVARIANT_MAP} after switching`);
 
-    mpViewer.mode = MONOMER_POSITION_MODE.MUTATION_CLIFFS;
-    expect(mpViewer.mode, MONOMER_POSITION_MODE.MUTATION_CLIFFS,
-      `Monomer-Position mode is not ${MONOMER_POSITION_MODE.MUTATION_CLIFFS} after switching`);
+    mpViewer.mode = SELECTION_MODE.MUTATION_CLIFFS;
+    expect(mpViewer.mode, SELECTION_MODE.MUTATION_CLIFFS,
+      `Monomer-Position mode is not ${SELECTION_MODE.MUTATION_CLIFFS} after switching`);
   });
 }, {clear: false});
 
@@ -123,7 +124,8 @@ category('Viewers: Most Potent Residues', () => {
   test('Tooltip', async () => {
     const cellCoordinates = {col: 'Diff', row: 6};
     const gc = mprViewer.viewerGrid.cell(cellCoordinates.col, cellCoordinates.row);
-    expect(showTooltip(gc, 0, 0, model), true,
+    const mp = mprViewer.getMonomerPosition(gc);
+    expect(model.showTooltip(mp, 0, 0), true,
       `Tooltip is not shown for grid cell at column '${cellCoordinates.col}', row ${cellCoordinates.row}`);
   });
 });
@@ -183,7 +185,7 @@ category('Viewers: Logo Summary Table', () => {
 
   test('Tooltip', async () => {
     const cluster = '0';
-    const tooltipElement = lstViewer.showTooltip(cluster, 0, 0);
+    const tooltipElement = lstViewer.showTooltip({monomerOrCluster: cluster, positionOrClusterType: CLUSTER_TYPE.ORIGINAL}, 0, 0);
     expect(tooltipElement !== null, true, `Tooltip is not shown for cluster '${cluster}'`);
   });
 }, {clear: false});

package/src/tests/widgets.ts

@@ -3,7 +3,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {category, test, before, expect, awaitCheck} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
-import {PeptidesModel, VIEWER_TYPE} from '../model';
+import {CLUSTER_TYPE, PeptidesModel, VIEWER_TYPE} from '../model';
 import {scaleActivity} from '../utils/misc';
 import {startAnalysis} from '../widgets/peptides';
 import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
@@ -221,13 +221,12 @@ category('Widgets: Actions', () => {
     const customClusterList = wu(model.customClusters).toArray();
     expect(customClusterList.length, 1, 'Expected to have 1 custom cluster');
     const clustName = customClusterList[0].name;
-    expect(model.df.col(clustName) !== null, true,
-      'Expected to have custom cluster column in the table');
+    expect(model.df.col(clustName) !== null, true, 'Expected to have custom cluster column in the table');
     expect(lstViewer.viewerGrid.table.getCol(C.LST_COLUMN_NAMES.CLUSTER).categories.indexOf(clustName) !== -1, true,
       'Expected to have custom cluster in the Logo Summary Table');
 
     // Remove custom cluster
-    model.modifyClusterSelection(clustName);
+    model.modifyClusterSelection({monomerOrCluster: clustName, positionOrClusterType: CLUSTER_TYPE.CUSTOM});
     lstViewer.removeCluster();
     expect(wu(model.customClusters).toArray().length, 0, 'Expected to have 0 custom clusters after removing one');
     expect(model.df.col(clustName) === null, true,

package/src/utils/cell-renderer.ts

@@ -2,7 +2,7 @@ import * as DG from 'datagrok-api/dg';
 
 import * as C from './constants';
 import * as types from './types';
-import {PositionStats, MonomerPositionStats} from '../model';
+import {PositionStats, MonomerPositionStats, CLUSTER_TYPE} from '../model';
 import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
 import {monomerToShort} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
@@ -13,40 +13,34 @@ export function renderCellSelection(canvasContext: CanvasRenderingContext2D, bou
 }
 
 /** A function that sets amino acid residue cell renderer to the specified column */
-export function setAARRenderer(col: DG.Column, alphabet: string): void {
+export function setMonomerRenderer(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;
 }
 
-export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D, currentAAR: string,
+export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D, currentMonomer: string,
   currentPosition: string, monomerPositionStats: MonomerPositionStats, bound: DG.Rect,
-  mutationCliffsSelection: types.PositionToAARList, substitutionsInfo: types.MutationCliffs | null = null,
-  twoColorMode: boolean = false, renderNums: boolean = true): void {
+  mutationCliffsSelection: types.Selection, substitutionsInfo: types.MutationCliffs | null = null,
+  _twoColorMode: boolean = false, renderNums: boolean = true): void {
   const positionStats = monomerPositionStats[currentPosition];
-  const pVal: number = positionStats[currentAAR].pValue;
-  const currentMeanDiff = positionStats[currentAAR].meanDifference;
-
-  let coef: string;
-  const isMeanDeltaNegative = currentMeanDiff < 0;
-  if (pVal < 0.01)
-    coef = isMeanDeltaNegative && twoColorMode ? '#FF7900' : '#299617';
-  else if (pVal < 0.05)
-    coef = isMeanDeltaNegative && twoColorMode ? '#FFA500' : '#32CD32';
-  else if (pVal < 0.1)
-    coef = isMeanDeltaNegative && twoColorMode ? '#FBCEB1' : '#98FF98';
-  else
-    coef = DG.Color.toHtml(DG.Color.lightLightGray);
-
-
-  const minMeanDifference = twoColorMode ? 0 : monomerPositionStats.general.minMeanDifference;
-  const maxMeanDifference = twoColorMode ?
-    Math.max(Math.abs(monomerPositionStats.general.minMeanDifference), monomerPositionStats.general.maxMeanDifference) :
-    monomerPositionStats.general.maxMeanDifference;
-  const currentMeanDifference = twoColorMode ? Math.abs(currentMeanDiff) : currentMeanDiff;
-
-  const rCoef = (currentMeanDifference - minMeanDifference) / (maxMeanDifference - minMeanDifference);
-
+  const pVal = positionStats![currentMonomer]!.pValue;
+  const currentMeanDifference = positionStats![currentMonomer]!.meanDifference;
+
+  // Transform p-value to increase intensity for smaller values and decrease for larger values
+  const maxPValComplement = 1 - positionStats!.general.maxPValue;
+  const minPValComplement = 1 - positionStats!.general.minPValue;
+  const pValCentering = Math.min(maxPValComplement, minPValComplement);
+  const centeredMaxPValComplement = maxPValComplement - pValCentering;
+  const centeredMinPValComplement = minPValComplement - pValCentering;
+  const centeredPValLimit = Math.max(centeredMaxPValComplement, centeredMinPValComplement);
+  const pValComplement = pVal === null ? 0 : 1 - pVal - pValCentering;
+
+  const coef = DG.Color.toHtml(pVal === null ? DG.Color.lightLightGray :
+    DG.Color.scaleColor(currentMeanDifference >= 0 ? pValComplement : -pValComplement, -centeredPValLimit, centeredPValLimit));
+
+  const maxMeanDifference = Math.max(Math.abs(monomerPositionStats.general.minMeanDifference), monomerPositionStats.general.maxMeanDifference);
+  const rCoef = Math.abs(currentMeanDifference) / maxMeanDifference;
   const maxRadius = 0.9 * (bound.width > bound.height ? bound.height : bound.width) / 2;
   const radius = Math.floor(maxRadius * rCoef);
 
@@ -54,12 +48,12 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
   const midY = bound.y + bound.height / 2;
   canvasContext.beginPath();
   canvasContext.fillStyle = coef;
-  canvasContext.arc(midX, midY, radius < 3 ? 3 : radius, 0, Math.PI * 2, true);
+  canvasContext.arc(midX, midY, radius < 3 || pVal === null ? 3 : radius, 0, Math.PI * 2, true);
   canvasContext.closePath();
   canvasContext.fill();
 
   if (renderNums) {
-    const substitutions = substitutionsInfo?.get(currentAAR)?.get(currentPosition)?.entries() ?? null;
+    const substitutions = substitutionsInfo?.get(currentMonomer)?.get(currentPosition)?.entries() ?? null;
     if (substitutions !== null) {
       canvasContext.textBaseline = 'middle';
       canvasContext.textAlign = 'center';
@@ -79,13 +73,13 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
     }
   }
 
-  const aarSelection = mutationCliffsSelection[currentPosition];
-  if (aarSelection && aarSelection.includes(currentAAR))
+  const monomerSelection = mutationCliffsSelection[currentPosition];
+  if (monomerSelection && monomerSelection.includes(currentMonomer))
     renderCellSelection(canvasContext, bound);
 }
 
-export function renderInvaraintMapCell(canvasContext: CanvasRenderingContext2D, currentAAR: string,
-  currentPosition: string, invariantMapSelection: types.PositionToAARList, cellValue: number, bound: DG.Rect,
+export function renderInvaraintMapCell(canvasContext: CanvasRenderingContext2D, currentMonomer: string,
+  currentPosition: string, invariantMapSelection: types.Selection, cellValue: number, bound: DG.Rect,
   color: number): void {
   canvasContext.fillStyle = DG.Color.toHtml(color);
   canvasContext.fillRect(bound.x, bound.y, bound.width, bound.height);
@@ -95,20 +89,20 @@ export function renderInvaraintMapCell(canvasContext: CanvasRenderingContext2D,
   canvasContext.fillStyle = '#000';
   canvasContext.fillText(cellValue.toString(), bound.x + (bound.width / 2), bound.y + (bound.height / 2), bound.width);
 
-  const aarSelection = invariantMapSelection[currentPosition];
-  if (aarSelection && aarSelection.includes(currentAAR))
+  const monomerSelection = invariantMapSelection[currentPosition];
+  if (monomerSelection && monomerSelection.includes(currentMonomer))
     renderCellSelection(canvasContext, bound);
 }
 
 export function renderLogoSummaryCell(canvasContext: CanvasRenderingContext2D, cellValue: string,
-  clusterSelection: string[], bound: DG.Rect): void {
+  clusterSelection: types.Selection, bound: DG.Rect): void {
   canvasContext.font = '13px Roboto, Roboto Local, sans-serif';
   canvasContext.textAlign = 'center';
   canvasContext.textBaseline = 'middle';
   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[CLUSTER_TYPE.CUSTOM].includes(cellValue) || clusterSelection[CLUSTER_TYPE.ORIGINAL].includes(cellValue))
     renderCellSelection(canvasContext, bound);
 }
 
@@ -136,7 +130,7 @@ export function drawLogoInBounds(ctx: CanvasRenderingContext2D, bounds: DG.Rect,
 
   const monomerBounds: { [monomer: string]: DG.Rect } = {};
   for (const monomer of sortedOrder) {
-    const monomerHeight = barHeight * (stats[monomer].count / rowCount);
+    const monomerHeight = barHeight * (stats[monomer]!.count / rowCount);
     const selectionHeight = barHeight * ((monomerSelectionStats[monomer] ?? 0) / rowCount);
     const currentBound = new DG.Rect(xStart / pr, currentY / pr, barWidth / pr, monomerHeight / pr);
     monomerBounds[monomer] = currentBound;

package/src/utils/constants.ts

@@ -29,6 +29,7 @@ export enum TAGS {
   POSITION = 'pos',
   SEPARATOR = 'separator',
   SELECTION = 'selection',
+  MUTATION_CLIFFS_SELECTION = 'mutationCliffsSelection',
   ALPHABET = 'alphabet',
   FILTER = 'filter',
   INVARIANT_MAP_SELECTION = 'invariantMapSelection',

package/src/utils/misc.ts

@@ -1,11 +1,8 @@
-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 './constants';
 import * as type from './types';
 import {StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';
-import {getSplitter} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
-import {TAGS as bioTags} from '@datagrok-libraries/bio/src/utils/macromolecule';
 
 export function getTypedArrayConstructor(
   maxNum: number): Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor {
@@ -44,9 +41,9 @@ export function scaleActivity(activityCol: DG.Column<number>, scaling: C.SCALING
 }
 
 //TODO: optimize
-export function calculateSelected(df: DG.DataFrame): type.MonomerSelectionStats {
+export function calculateSelected(df: DG.DataFrame): type.SelectionStats {
   const monomerColumns: DG.Column<string>[] = df.columns.bySemTypeAll(C.SEM_TYPES.MONOMER);
-  const selectedObj: type.MonomerSelectionStats = {};
+  const selectedObj: type.SelectionStats = {};
   for (const idx of df.selection.getSelectedIndexes()) {
     for (const col of monomerColumns) {
       const monomer = col.get(idx);

package/src/utils/statistics.ts

@@ -5,12 +5,18 @@ import BitArray from '@datagrok-libraries/utils/src/bit-array';
 
 export type Stats = {
   count: number,
-  pValue: number,
+  pValue: number | null,
   meanDifference: number,
   ratio: number,
+  mask: BitArray,
 };
 
 export function getStats(data: RawData | number[], bitArray: BitArray): Stats {
+  if (data.length !== bitArray.length && data.some((v, i) => i >= bitArray.length ? v !== 0 : false))
+    throw new Error('PeptidesError: Data and bit array have different lengths');
+  if (bitArray.falseCount() === 0 || bitArray.trueCount() === 0)
+    throw new Error('PeptidesError: One of the samples is empty');
+
   const selected = new Float32Array(bitArray.trueCount());
   const rest = new Float32Array(bitArray.falseCount());
 
@@ -23,13 +29,26 @@ export function getStats(data: RawData | number[], bitArray: BitArray): Stats {
       rest[restIndex++] = data[i];
   }
 
+  if (selected.length === 1 || rest.length === 1) {
+    const selectedMean = selected.reduce((a, b) => a + b, 0) / selected.length;
+    const restMean = rest.reduce((a, b) => a + b, 0) / rest.length;
+    return {
+      count: selected.length,
+      pValue: null,
+      meanDifference: selectedMean - restMean,
+      ratio: selected.length / (bitArray.length),
+      mask: bitArray,
+    };
+  }
+
   const testResult = tTest(selected, rest);
   const currentMeanDiff = testResult['Mean difference']!;
   return {
     count: selected.length,
-    pValue: testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'] || 0,
-    meanDifference: currentMeanDiff || 0,
+    pValue: testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'],
+    meanDifference: currentMeanDiff,
     ratio: selected.length / (bitArray.length),
+    mask: bitArray,
   };
 }
 

package/src/utils/types.ts

@@ -1,15 +1,16 @@
 import * as DG from 'datagrok-api/dg';
 import {SCALING_METHODS} from './constants';
+import {ClusterType} from '../model';
 
 export type DataFrameDict = {[key: string]: DG.DataFrame};
 
 export type RawData = Int32Array | Uint32Array | Float32Array | Float64Array;
 export type UTypedArray = Uint8Array | Uint16Array | Uint32Array;
-//AAR: (Position: (index: indexList))
+//Monomer: (Position: (index: indexList))
 export type MutationCliffs = Map<string, Map<string, Map<number, number[] | UTypedArray>>>;
-export type PositionToAARList = {[postiton: string]: string[]};
-
-export type MonomerSelectionStats = {[position: string]: {[monomer: string]: number}};
+export type Selection = {[positionOrClusterType: string | ClusterType]: string[]};
+export type SelectionItem = {positionOrClusterType: string | ClusterType, monomerOrCluster: string};
+export type SelectionStats = {[positionOrClusterType: string | ClusterType]: { [monomerOrCluster: string]: number}};
 
 export type PeptidesSettings = {
   sequenceColumnName?: string,
@@ -48,4 +49,4 @@ export type StatsInfo = {
 
 export type RawColumn = {name: string, rawData: RawData, cat?: string[]};
 
-export type CustomClusters = {[clusterName: string]: number[] | Int32Array};
+export type SelectionOptions = {shiftPressed: boolean, ctrlPressed: boolean};