@datagrok/peptides 1.14.1 → 1.15.1

package/src/tests/core.ts

@@ -38,15 +38,9 @@ category('Core', () => {
     model = await startAnalysis(
       simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, C.SCALING_METHODS.MINUS_LG);
     expect(model instanceof PeptidesModel, true, 'Model is null');
-    let overlayInit = false;
-    grok.log.debug('Waiting for overlay...');
-    model!._analysisView!.grid.onAfterDrawOverlay.subscribe(() => {
-      overlayInit = true;
-      grok.log.debug('Overlay initialized');
-    });
 
     model!.mutationCliffsSelection = {'11': ['D']};
-    await delay(500);
+    await delay(3000);
   });
 
   test('Start analysis: сomplex', async () => {
@@ -64,16 +58,9 @@ category('Core', () => {
     model = await startAnalysis(
       complexActivityCol, complexAlignedSeqCol, null, complexTable, complexScaledCol, C.SCALING_METHODS.MINUS_LG);
     expect(model instanceof PeptidesModel, true, 'Model is null');
-    let overlayInit = false;
-    model!._analysisView!.grid.onAfterDrawOverlay.subscribe(() => {
-      overlayInit = true;
-      grok.log.debug('Overlay initialized');
-    });
 
-    if (model !== null)
-      model.mutationCliffsSelection = {'13': ['-']};
-
-    await delay(500);
+    model!.mutationCliffsSelection = {'13': ['-']};
+    await delay(3000);
   });
 
   test('Save and load project', async () => {
@@ -105,7 +92,7 @@ category('Core', () => {
     const sp = await grok.dapi.projects.save(project);
 
     v.close();
-    await awaitCheck(() => typeof grok.shell.tableView('Peptides analysis') === 'undefined', 'Table never closed', 2000);
+    await awaitCheck(() => typeof grok.shell.tableView('Peptides analysis') === 'undefined', 'Table never closed', 3000);
 
     await sp.open();
     v = grok.shell.getTableView('Peptides analysis');
@@ -113,63 +100,5 @@ category('Core', () => {
     await grok.dapi.layouts.delete(sl);
     await grok.dapi.tables.delete(sti);
     await grok.dapi.projects.delete(sp);
-
-    await delay(500);
   });
-
-  test('Cluster stats - Benchmark HELM 5k', async () => {
-    if (!DG.Test.isInBenchmark)
-      return;
-
-    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k_2.d42'))[0];
-    const activityCol = df.getCol('Activity');
-    const scaledActivityCol = scaleActivity(activityCol, C.SCALING_METHODS.NONE);
-    const clustersCol = df.getCol('Cluster');
-    const sequenceCol = df.getCol('HELM');
-    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
-    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
-    const model = await startAnalysis(activityCol, sequenceCol, clustersCol, df, scaledActivityCol, C.SCALING_METHODS.NONE);
-
-    for (let i = 0; i < 5; ++i)
-      DG.time('Cluster stats', () => model?.calculateClusterStatistics());
-  }, {timeout: 10000});
-
-  test('Monomer Position stats - Benchmark HELM 5k', async () => {
-    if (!DG.Test.isInBenchmark)
-      return;
-
-    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
-    const activityCol = df.getCol('Activity');
-    const scaledActivityCol = scaleActivity(activityCol, C.SCALING_METHODS.NONE);
-    const clustersCol = df.getCol('Cluster');
-    const sequenceCol = df.getCol('HELM');
-    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
-    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
-    const model = await startAnalysis(activityCol, sequenceCol, clustersCol, df, scaledActivityCol, C.SCALING_METHODS.NONE);
-
-    for (let i = 0; i < 5; ++i)
-      DG.time('Monomer position stats', () => model?.calculateMonomerPositionStatistics());
-  }, {timeout: 10000});
-
-  test('Analysis start - Benchmark HELM 5k', async () => {
-    if (!DG.Test.isInBenchmark)
-      return;
-
-    const df = (await _package.files.readBinaryDataFrames('tests/aligned_5k.d42'))[0];
-    const activityCol = df.getCol('Activity');
-    const scaledActivityCol = scaleActivity(activityCol, C.SCALING_METHODS.NONE);
-    const clustersCol = df.getCol('Cluster');
-    const sequenceCol = df.getCol('HELM');
-    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
-    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
-
-    for (let i = 0; i < 5; ++i) {
-      await DG.timeAsync('Analysis start', async () => {
-        const model = await startAnalysis(activityCol, sequenceCol, clustersCol, df, scaledActivityCol, C.SCALING_METHODS.NONE);
-
-        if (model)
-          grok.shell.closeTable(model.df);
-      });
-    }
-  }, {timeout: 10000});
 });

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

@@ -1,6 +1,6 @@
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, before, expect, expectFloat, awaitCheck, delay} from '@datagrok-libraries/utils/src/test';
+import {category, test, before, expect, expectFloat, awaitCheck, delay, after} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
 import {PeptidesModel, VIEWER_TYPE, getAggregatedColName} from '../model';
 import {startAnalysis} from '../widgets/peptides';
@@ -38,6 +38,8 @@ category('Model: Settings', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('Activity scaling', async () => {
     const getError = (row: number, method: SCALING_METHODS): string =>
       `Activity mismatch at row ${row} for scaling method '${method}'`;
@@ -72,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

@@ -1,6 +1,6 @@
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, before, expect, delay} from '@datagrok-libraries/utils/src/test';
+import {category, test, before, expect, delay, after} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
 import {CLUSTER_TYPE, PeptidesModel} from '../model';
 import {startAnalysis} from '../widgets/peptides';
@@ -39,6 +39,8 @@ category('Table view', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('Tooltip', async () => {
     expect(model.showMonomerTooltip(firstPair.monomerOrCluster, 0, 0), true,
       `Couldn't structure for monomer ${firstPair.monomerOrCluster}`);
@@ -46,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;
@@ -65,7 +67,6 @@ category('Table view', () => {
 
     // Select first monomer-position pair
     model.modifyMutationCliffsSelection(firstPair);
-    await delay(500);
     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} ` +
@@ -73,7 +74,6 @@ category('Table view', () => {
 
     // Select second monomer-position pair
     model.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: false});
-    await delay(500);
     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 ` +
@@ -82,7 +82,6 @@ category('Table view', () => {
 
     // Deselect second monomer-position pair
     model.modifyMutationCliffsSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
-    await delay(500);
     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} ` +
@@ -90,7 +89,6 @@ category('Table view', () => {
 
     // Clear monomer-position selection
     model.initMutationCliffsSelection();
-    await delay(500);
     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`);
@@ -99,7 +97,6 @@ category('Table view', () => {
 
     // Select first cluster
     model.modifyClusterSelection(firstCluster);
-    await delay(500);
     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 ` +
@@ -107,7 +104,6 @@ category('Table view', () => {
 
     // Select second cluster
     model.modifyClusterSelection(secondCluster, {shiftPressed: true, ctrlPressed: false});
-    await delay(500);
     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 ` +
@@ -115,7 +111,6 @@ category('Table view', () => {
 
     // Deselect first cluster
     model.modifyClusterSelection(firstCluster, {shiftPressed: true, ctrlPressed: true});
-    await delay(500);
     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 ` +
@@ -123,7 +118,6 @@ category('Table view', () => {
 
     // Clear selection
     model.initClusterSelection();
-    await delay(500);
     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,7 +130,6 @@ category('Table view', () => {
 
     // Select by second monomer-position pair
     model.modifyInvariantMapSelection(secondPair);
-    await delay(500);
     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} ` +
@@ -144,7 +137,6 @@ category('Table view', () => {
 
     // Select by first monomer-position pair
     model.modifyInvariantMapSelection(firstPair, {shiftPressed: true, ctrlPressed: false});
-    await delay(500);
     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} ` +
@@ -152,7 +144,6 @@ category('Table view', () => {
 
     // Deselect filter for second monomer-position pair
     model.modifyInvariantMapSelection(secondPair, {shiftPressed: true, ctrlPressed: true});
-    await delay(500);
     expect(model.invariantMapSelection[secondPair.positionOrClusterType].includes(secondPair.monomerOrCluster), false,
       `Monomer ${secondPair.monomerOrCluster} is still filtered at position ${secondPair.positionOrClusterType} after ` +
       `deselection`);
@@ -162,7 +153,6 @@ category('Table view', () => {
 
     // Clear selection
     model.initInvariantMapSelection();
-    await delay(500);
     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

@@ -1,6 +1,6 @@
 import * as DG from 'datagrok-api/dg';
 
-import {before, category, delay, expect, test, testViewer} from '@datagrok-libraries/utils/src/test';
+import {after, before, category, delay, expect, test, testViewer} from '@datagrok-libraries/utils/src/test';
 import {aligned1} from './test-data';
 import {CLUSTER_TYPE, PeptidesModel, VIEWER_TYPE} from '../model';
 import {_package} from '../package-test';
@@ -50,6 +50,8 @@ category('Viewers: Monomer-Position', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('Tooltip', async () => {
     const cellCoordinates = {col: '9', row: 6};
     const gc = mpViewer.viewerGrid.cell(cellCoordinates.col, cellCoordinates.row);
@@ -102,6 +104,8 @@ category('Viewers: Most Potent Residues', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('Tooltip', async () => {
     const cellCoordinates = {col: 'Diff', row: 6};
     const gc = mprViewer.viewerGrid.cell(cellCoordinates.col, cellCoordinates.row);
@@ -139,6 +143,8 @@ category('Viewers: Logo Summary Table', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('Properties', async () => {
     // Change Logo Summary Table Web Logo Mode property to full
     const webLogoMode = lstViewer.getProperty(LST_PROPERTIES.WEB_LOGO_MODE);

package/src/tests/widgets.ts

@@ -1,7 +1,7 @@
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
 
-import {category, test, before, expect, delay} from '@datagrok-libraries/utils/src/test';
+import {category, test, before, expect, delay, after} from '@datagrok-libraries/utils/src/test';
 import {_package} from '../package-test';
 import {CLUSTER_TYPE, PeptidesModel, VIEWER_TYPE} from '../model';
 import {scaleActivity} from '../utils/misc';
@@ -40,6 +40,8 @@ category('Widgets: Settings', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('UI', async () => {
     const settingsElements = getSettingsDialog(model);
 
@@ -83,6 +85,8 @@ category('Widgets: Distribution panel', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('UI', async () => {
     getDistributionWidget(model.df, model);
   });
@@ -113,6 +117,8 @@ category('Widgets: Mutation cliffs', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('UI', async () => {
     mutationCliffsWidget(model.df, model);
   });
@@ -143,6 +149,8 @@ category('Widgets: Actions', () => {
     await delay(500);
   });
 
+  after(async () => await delay(3000));
+
   test('New view', async () => {
     // Set compound bitset: filter out 2 rows and select 1 among them
     const filter = model.df.filter;

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;
@@ -81,12 +81,16 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
 export function renderInvaraintMapCell(canvasContext: CanvasRenderingContext2D, currentMonomer: string,
   currentPosition: string, invariantMapSelection: types.Selection, cellValue: number, bound: DG.Rect,
   color: number): void {
+  //FIXME: This is a hack, because `color` value sometimes comes incomplete. E.g. we found that here `color` value is
+  // 255 and its contrast color would be black, which is not visible on blue (color code) background. The full number
+  // is actually 4278190335.
+  color = DG.Color.fromHtml(DG.Color.toHtml(color));
   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';
-  canvasContext.fillStyle = '#000';
+  canvasContext.fillStyle = DG.Color.toHtml(DG.Color.getContrastColor(color));
   canvasContext.fillText(cellValue.toString(), bound.x + (bound.width / 2), bound.y + (bound.height / 2), bound.width);
 
   const monomerSelection = invariantMapSelection[currentPosition];
@@ -114,18 +118,19 @@ export function drawLogoInBounds(ctx: CanvasRenderingContext2D, bounds: DG.Rect,
   drawOptions.symbolStyle ??= '16px Roboto, Roboto Local, sans-serif';
   drawOptions.upperLetterHeight ??= 12.2;
   drawOptions.upperLetterAscent ??= 0.25;
-  drawOptions.marginVertical ??= 5;
-  drawOptions.marginHorizontal ??= 5;
+  drawOptions.marginVertical ??= 2;
+  drawOptions.marginHorizontal ??= 2;
+  drawOptions.selectionWidth ??= 1;
   drawOptions.textHeight ??= 13;
   drawOptions.headerStyle ??= `bold ${drawOptions.textHeight * pr}px Roboto, Roboto Local, sans-serif`;
 
   const totalSpace = (sortedOrder.length - 1) * drawOptions.upperLetterAscent; // Total space between letters
   const barHeight = (bounds.height - 2 * drawOptions.marginVertical - totalSpace - 1.25 * drawOptions.textHeight) * pr;
   const leftShift = drawOptions.marginHorizontal * 2;
-  const barWidth = (bounds.width - leftShift * 2) * pr;
+  const barWidth = (bounds.width - (leftShift + drawOptions.marginHorizontal)) * pr;
   const xStart = (bounds.x + leftShift) * pr;
-  const selectionWidth = 4 * pr;
-  const xSelection = (bounds.x + 3) * pr;
+  const selectionWidth = Math.min(drawOptions.selectionWidth * pr, 1);
+  const xSelection = (bounds.x + 1) * pr;
   let currentY = (bounds.y + drawOptions.marginVertical) * pr;
 
   const monomerBounds: { [monomer: string]: DG.Rect } = {};

package/src/utils/constants.ts

@@ -43,6 +43,8 @@ export enum TAGS {
   MULTIPLE_VIEWS = 'isMultipleViews',
   IDENTITY_TEMPLATE = 'Identity template',
   SIMILARITY_TEMPLATE = 'Similarity template',
+  ANALYSIS_COL = 'isAnalysisCol',
+  POSITION_COL = 'isPositionCol',
 }
 
 export enum SEM_TYPES {