@datagrok/peptides 1.7.2 → 1.8.1

package/src/package-test.ts

@@ -5,6 +5,9 @@ import './tests/core';
 import './tests/peptide-space-test';
 import './tests/algorithms';
 import './tests/viewers';
+import './tests/widgets';
+import './tests/table-view';
+import './tests/model';
 
 export const _package = new DG.Package();
 export {tests};

package/src/package.ts

@@ -7,23 +7,37 @@ import {analyzePeptidesUI} from './widgets/peptides';
 import {PeptideSimilaritySpaceWidget} from './utils/peptide-similarity-space';
 import {manualAlignmentWidget} from './widgets/manual-alignment';
 import {MonomerPosition, MostPotentResiduesViewer} from './viewers/sar-viewer';
-
+import {getTreeHelper, ITreeHelper} from '@datagrok-libraries/bio/src/trees/tree-helper';
+import {IDendrogramService, getDendrogramService} from '@datagrok-libraries/bio/src/trees/dendrogram';
 import {PeptideSpaceViewer} from './viewers/peptide-space-viewer';
-import {LogoSummary} from './viewers/logo-summary';
+import {LogoSummaryTable} from './viewers/logo-summary';
 import {MonomerWorks} from '@datagrok-libraries/bio/src/monomer-works/monomer-works';
 import {PeptidesModel} from './model';
+import {macromoleculeSarFastaDemoUI} from './demo/fasta';
 
 let monomerWorks: MonomerWorks | null = null;
+let treeHelper: ITreeHelper | null = null;
+let dendrogramService: IDendrogramService | null = null;
 
 export const _package = new DG.Package();
 
-export function getMonomerWorks(): MonomerWorks | null {
-  return monomerWorks;
+export function getMonomerWorksInstance(): MonomerWorks {
+  return monomerWorks!;
+}
+
+export function getTreeHelperInstance(): ITreeHelper {
+  return treeHelper!;
+}
+
+export function getDendrogramServiceInstance(): IDendrogramService {
+  return dendrogramService!;
 }
 
 //tags: init
 export async function initPeptides(): Promise<void> {
   monomerWorks ??= new MonomerWorks(await grok.functions.call('Bio:getBioLib'));
+  treeHelper ??= await getTreeHelper();
+  dendrogramService ??= await getDendrogramService();
 }
 
 async function openDemoData(chosenFile: string): Promise<void> {
@@ -44,24 +58,22 @@ export function Peptides(): 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, '.']);
 
-  const appDescription = ui.info(
-    [
-      ui.list([
-        '- automatic recognition of peptide sequences',
-        '- native integration with tons of Datagrok out-of-the box features (visualization, filtering, clustering, ' +
+  const appDescription = ui.info([
+    ui.list([
+      '- automatic recognition of peptide sequences',
+      '- native integration with tons of Datagrok out-of-the box features (visualization, filtering, clustering, ' +
         'multivariate analysis, etc)',
-        '- custom rendering in the spreadsheet',
-        '- interactive logo plots',
-        '- rendering residues',
-        '- structure-activity relationship:',
-        ' ',
-        'a) highlighting statistically significant changes in activity in the [position, monomer] spreadsheet',
-        'b) for the specific [position, monomer], visualizing changes of activity distribution (specific monomer in ' +
+      '- custom rendering in the spreadsheet',
+      '- interactive logo plots',
+      '- rendering residues',
+      '- structure-activity relationship:',
+      ' ',
+      'a) highlighting statistically significant changes in activity in the [position, monomer] spreadsheet',
+      'b) for the specific [position, monomer], visualizing changes of activity distribution (specific monomer in ' +
         'this position vs rest of the monomers in this position)',
-        'c) interactivity',
-      ]),
-    ],
-    'Use and analyse peptide sequence data to support your research:',
+      'c) interactivity',
+    ]),
+  ], 'Use and analyse peptide sequence data to support your research:',
   );
 
   const windows = grok.shell.windows;
@@ -80,7 +92,7 @@ export function Peptides(): void {
   ]);
 }
 
-//top-menu: Bio | Peptides...
+//top-menu: Bio | SAR | Peptides...
 //name: Bio Peptides
 export function peptidesDialog(): DG.Dialog {
   const analyzeObject = analyzePeptidesUI(grok.shell.t);
@@ -101,32 +113,36 @@ export function peptidesPanel(col: DG.Column): DG.Widget {
   return new DG.Widget(analyzeObject.host);
 }
 
-//name: peptide-sar-viewer
-//description: Peptides SAR Viewer
+//name: Monomer-Position
+//description: Peptides Monomer-Position Viewer
 //tags: viewer
+//meta.icon: files/icons/peptide-sar-viewer.svg
 //output: viewer result
-export function sar(): MonomerPosition {
+export function monomerPosition(): MonomerPosition {
   return new MonomerPosition();
 }
 
-//name: peptide-sar-viewer-vertical
-//description: Peptides Vertical SAR Viewer
+//name: Most Potent Residues
+//description: Peptides Most Potent Residues Viewer
 //tags: viewer
+//meta.icon: files/icons/peptide-sar-vertical-viewer.svg
 //output: viewer result
-export function sarVertical(): MostPotentResiduesViewer {
+export function mostPotentResidues(): MostPotentResiduesViewer {
   return new MostPotentResiduesViewer();
 }
 
-//name: logo-summary-viewer
+//name: Logo Summary Table
 //tags: viewer
+//meta.icon: files/icons/logo-summary-viewer.svg
 //output: viewer result
-export function logoSummary(): LogoSummary {
-  return new LogoSummary();
+export function logoSummaryTable(): LogoSummaryTable {
+  return new LogoSummaryTable();
 }
 
 //name: peptide-space-viewer
 //description: Peptide Space Viewer
 //tags: viewer
+//meta.icon: files/icons/peptide-space-viewer.svg
 //output: viewer result
 export function peptideSpace(): PeptideSpaceViewer {
   return new PeptideSpaceViewer();
@@ -155,3 +171,11 @@ export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
   const widget = new PeptideSimilaritySpaceWidget(col, grok.shell.v as DG.TableView);
   return widget.draw();
 }
+
+// --- Demo ---
+//name: Macromolecule SAR Analysis
+//description: Macromolecule SAR Analysis demo on peptide sequences in FASTA format
+//meta.demoPath: Bioinformatics | Macromolecule SAR Analysis
+export async function macromoleculeSarFastaDemo(): Promise<void> {
+  return macromoleculeSarFastaDemoUI();
+}

package/src/tests/algorithms.ts

@@ -26,7 +26,7 @@ category('Algorithms', () => {
   });
 
   test('MutationCliffs', async () => {
-    const substInfo: type.SubstitutionsInfo = findMutations(activityCol, monomerColumns, settings);
+    const substInfo: type.MutationCliffs = findMutations(activityCol, monomerColumns, settings);
     expect(substInfo.has('C'), true);
     expect(substInfo.has('D'), true);
     expect(substInfo.has('A'), false);

package/src/tests/core.ts

@@ -35,11 +35,12 @@ category('Core', () => {
     simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
     simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
 
-    model = await startAnalysis(simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, '-lg');
+    model = await startAnalysis(
+      simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, C.SCALING_METHODS.MINUS_LG);
     expect(model instanceof PeptidesModel, true);
 
     if (model != null)
-      model.mutationCliffsSelection = {'11': ['D']};
+      model.monomerPositionSelection = {'11': ['D']};
   });
 
   test('Start analysis: сomplex', async () => {
@@ -55,11 +56,11 @@ category('Core', () => {
     complexScaledCol = scaleActivity(complexActivityCol, '-lg');
 
     model = await startAnalysis(
-      complexActivityCol, complexAlignedSeqCol, null, complexTable, complexScaledCol, '-lg');
+      complexActivityCol, complexAlignedSeqCol, null, complexTable, complexScaledCol, C.SCALING_METHODS.MINUS_LG);
     expect(model instanceof PeptidesModel, true);
 
     if (model != null)
-      model.mutationCliffsSelection = {'13': ['-']};
+      model.monomerPositionSelection = {'13': ['-']};
   });
 
   test('Save and load project', async () => {
@@ -73,7 +74,8 @@ category('Core', () => {
     simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
     simpleScaledCol = scaleActivity(simpleActivityCol, '-lg');
 
-    model = await startAnalysis(simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, '-lg');
+    model = await startAnalysis(
+      simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, C.SCALING_METHODS.MINUS_LG);
     let v = grok.shell.getTableView('Peptides analysis');
     const d = v.dataFrame;
     const layout = v.saveLayout();
@@ -107,7 +109,8 @@ category('Core', () => {
     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, 'none');
+    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());
@@ -121,7 +124,8 @@ category('Core', () => {
     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, 'none');
+    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());
@@ -138,7 +142,8 @@ category('Core', () => {
 
     for (let i = 0; i < 5; ++i) {
       await DG.timeAsync('Analysis start', async () => {
-        const model = await startAnalysis(activityCol, sequenceCol, clustersCol, df, scaledActivityCol, 'none');
+        const model = await startAnalysis(
+          activityCol, sequenceCol, clustersCol, df, scaledActivityCol, C.SCALING_METHODS.NONE);
         if (model)
           grok.shell.closeTable(model.df);
       });

package/src/tests/model.ts

@@ -0,0 +1,152 @@
+import * as DG from 'datagrok-api/dg';
+
+import {category, test, before, expect, expectFloat, delay} from '@datagrok-libraries/utils/src/test';
+import {_package} from '../package-test';
+import {PeptidesModel, VIEWER_TYPE, getAggregatedColName} from '../model';
+import {startAnalysis} from '../widgets/peptides';
+import {scaleActivity} from '../utils/misc';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {COLUMNS_NAMES, SCALING_METHODS} from '../utils/constants';
+import {LogoSummaryTable} from '../viewers/logo-summary';
+
+category('Model: Settings', () => {
+  let df: DG.DataFrame;
+  let model: PeptidesModel;
+  let activityCol: DG.Column<number>;
+  let sequenceCol: DG.Column<string>;
+  let clusterCol: DG.Column<any>;
+  let scaledActivityCol: DG.Column<number>;
+
+  const mutationCliffsDefaultParams = {maxMutations: 1, minActivityDelta: 0};
+  const mutationCliffsTestParams = {maxMutations: 2, minActivityDelta: 0.5};
+
+  before(async () => {
+    df = DG.DataFrame.fromCsv(await _package.files.readAsText('tests/HELM_small.csv'));
+    activityCol = df.getCol('activity');
+    sequenceCol = df.getCol('sequence');
+    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+    scaledActivityCol = scaleActivity(activityCol, SCALING_METHODS.NONE);
+    clusterCol = df.getCol('cluster');
+    const tempModel = await startAnalysis(activityCol, sequenceCol, clusterCol, df, scaledActivityCol,
+      SCALING_METHODS.NONE);
+    if (tempModel === null)
+      throw new Error('Model is null');
+    model = tempModel;
+  });
+
+  test('Activity scaling', async () => {
+    const getError = (row: number, method: SCALING_METHODS): string =>
+      `Activity mismatch at row ${row} for scaling method '${method}'`;
+    const tolerance = 0.0001;
+    const origActivityData =
+      model.df.getCol(model.settings.activityColumnName!).getRawData();
+    const scaledActivity = model.df.getCol(COLUMNS_NAMES.ACTIVITY_SCALED);
+    const dfLen = model.df.rowCount;
+
+    // Check initial 'none' scaling
+    let scaledActivityData = scaledActivity.getRawData();
+    for (let i = 0; i < dfLen; i++)
+      expectFloat(scaledActivityData[i], origActivityData[i], tolerance, getError(i, SCALING_METHODS.NONE));
+
+    // Check 'lg' scaling
+    model.settings = {scaling: SCALING_METHODS.LG};
+    scaledActivityData = scaledActivity.getRawData();
+    for (let i = 0; i < dfLen; i++)
+      expectFloat(scaledActivityData[i], Math.log10(origActivityData[i]), tolerance, getError(i, SCALING_METHODS.LG));
+
+    // Check '-lg' scaling
+    model.settings = {scaling: SCALING_METHODS.MINUS_LG};
+    scaledActivityData = scaledActivity.getRawData();
+    for (let i = 0; i < dfLen; i++) {
+      expectFloat(scaledActivityData[i], -Math.log10(origActivityData[i]), tolerance,
+        getError(i, SCALING_METHODS.MINUS_LG));
+    }
+
+    // Check 'none' scaling
+    model.settings = {scaling: SCALING_METHODS.NONE};
+    scaledActivityData = scaledActivity.getRawData();
+    for (let i = 0; i < dfLen; i++)
+      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 ` +
+      `${mutationCliffsDefaultParams.maxMutations}, actual ${model.settings.maxMutations}`);
+    expect(model.settings.minActivityDelta, mutationCliffsDefaultParams.minActivityDelta, `Min activity delta ` +
+      `mismatch: expected ${mutationCliffsDefaultParams.minActivityDelta}, actual ${model.settings.minActivityDelta}`);
+
+    // Check test mutation cliffs parameters
+    model.settings = {maxMutations: mutationCliffsTestParams.maxMutations,
+      minActivityDelta: mutationCliffsTestParams.minActivityDelta};
+    expect(model.settings.maxMutations, mutationCliffsTestParams.maxMutations, `Max mutations mismatch: expected ` +
+      `${mutationCliffsTestParams.maxMutations}, actual ${model.settings.maxMutations}`);
+    expect(model.settings.minActivityDelta, mutationCliffsTestParams.minActivityDelta, `Min activity delta ` +
+      `mismatch: expected ${mutationCliffsTestParams.minActivityDelta}, actual ${model.settings.minActivityDelta}`);
+  });
+
+  test('Include columns', async () => {
+    const columnName = 'rank';
+    const testColumns = {[columnName]: DG.AGG.AVG};
+
+    // Include column
+    model.settings = {columns: testColumns};
+
+    expect(Object.keys(model.settings.columns!)[0], Object.keys(testColumns)[0], 'Expected to include column ' +
+      `'${Object.keys(testColumns)[0]}' but '${Object.keys(model.settings.columns!)[0]}' is included instead`);
+    expect(model.settings.columns![columnName], testColumns[columnName], `Expected to aggregate column ` +
+      `'${Object.keys(testColumns)[0]}' with '${testColumns[columnName]}' but aggregated with ` +
+      `'${model.settings.columns![columnName]}' instead`);
+
+    expect(model.analysisView.grid.col(columnName)?.visible, true, `Expected to show column '${columnName}' but ` +
+      `it is hidden`);
+
+    const lstViewer = model.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable;
+    const aggColName = getAggregatedColName(testColumns[columnName], columnName);
+    expect(lstViewer.viewerGrid.col(aggColName) !== null, true, `Expected to include column '${columnName}' in ` +
+      `${VIEWER_TYPE.LOGO_SUMMARY_TABLE} but it is absent`);
+
+    // Remove column
+    model.settings = {columns: {}};
+    expect(Object.keys(model.settings.columns!).length, 0,
+      `Expected to remove all column aggregations but columns {${Object.keys(model.settings.columns!).join(' & ')}} ` +
+      `are still included`);
+
+    expect(model.analysisView.grid.col(columnName)?.visible, false, `Expected to hide column '${columnName}' but ` +
+      `it is shown`);
+
+    expect(lstViewer.viewerGrid.col(aggColName) === null, true, `Expected to remove column '${columnName}' from ` +
+      `${VIEWER_TYPE.LOGO_SUMMARY_TABLE} but it is still present`);
+  });
+
+  test('Dendrogram', async () => {
+    // Enable dendrogram
+    model.settings = {showDendrogram: true};
+    expect(model.settings.showDendrogram, true, 'Dendrogram is disabled after enabling');
+
+    await delay(5000);
+
+    expect(model.findViewer(VIEWER_TYPE.DENDROGRAM) !== null, true,
+      'Dendrogram is not present in the view after 5s delay');
+
+    // Disable dendrogram
+    model.settings = {showDendrogram: false};
+    expect(model.settings.showDendrogram, false, 'Dendrogram is enabled after disabling');
+    expect(model.findViewer(VIEWER_TYPE.DENDROGRAM) === null, true,
+      'Dendrogram is present in the view after disabling');
+  }, {skipReason: 'Need to find a way to replace _package variable to call for Bio function with tests'});
+});

package/src/tests/peptide-space-test.ts

@@ -1,4 +1,4 @@
-import {/*before, after, */after, category, test} from '@datagrok-libraries/utils/src/test';
+import {category, test} from '@datagrok-libraries/utils/src/test';
 import * as utils from './utils';
 import {DimensionalityReducer} from '@datagrok-libraries/ml/src/reduce-dimensionality';
 import {cleanAlignedSequencesColumn} from '../utils/peptide-similarity-space';
@@ -7,7 +7,6 @@ import {aligned1} from './test-data';
 import * as DG from 'datagrok-api/dg';
 import * as grok from 'datagrok-api/grok';
 import {StringMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
-import {_package} from '../package-test';
 
 let table: DG.DataFrame;
 let view: DG.TableView;

package/src/tests/table-view.ts

@@ -0,0 +1,158 @@
+import * as DG from 'datagrok-api/dg';
+
+import {category, test, before, expect} from '@datagrok-libraries/utils/src/test';
+import {_package} from '../package-test';
+import {PeptidesModel} from '../model';
+import {startAnalysis} from '../widgets/peptides';
+import {scaleActivity} from '../utils/misc';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {COLUMNS_NAMES, SCALING_METHODS} from '../utils/constants';
+
+category('Table view', () => {
+  let df: DG.DataFrame;
+  let model: PeptidesModel;
+  let activityCol: DG.Column<number>;
+  let sequenceCol: DG.Column<string>;
+  let clusterCol: DG.Column<any>;
+  let scaledActivityCol: DG.Column<number>;
+  const scaling = 'none' as SCALING_METHODS;
+
+  const firstMonomerPair = {monomer: 'N', position: '4', count: 7};
+  const secondMonomerPair = {monomer: 'meI', position: '1', count: 10};
+  const firstCluster = {name: '0', count: 3};
+  const secondCluster = {name: '1', count: 3};
+
+  before(async () => {
+    df = DG.DataFrame.fromCsv(await _package.files.readAsText('tests/HELM_small.csv'));
+    activityCol = df.getCol('activity');
+    sequenceCol = df.getCol('sequence');
+    sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    sequenceCol.setTag(DG.TAGS.UNITS, NOTATION.HELM);
+    scaledActivityCol = scaleActivity(activityCol, scaling);
+    clusterCol = df.getCol('cluster');
+    const tempModel = await startAnalysis(activityCol, sequenceCol, clusterCol, df, scaledActivityCol, scaling);
+    if (tempModel === null)
+      throw new Error('Model is null');
+    model = tempModel;
+  });
+
+  test('Tooltip', async () => {
+    expect(model.showMonomerTooltip(firstMonomerPair.monomer, 0, 0), true,
+      `Couldn't structure for monomer ${firstMonomerPair.monomer}`);
+  }, {skipReason: 'Need to find a way to replace _package variable to call for Bio function with tests'});
+
+  test('Visible columns', async () => {
+    const gridCols = model.analysisView.grid.columns;
+    const posCols = model.splitSeqDf.columns.names();
+    const visibleColumns = Object.keys(model.settings.columns ?? {});
+    for (let colIdx = 1; colIdx < gridCols.length; colIdx++) {
+      const col = gridCols.byIndex(colIdx)!;
+      const tableColName = col.column!.name;
+      expect(col.visible, posCols.includes(tableColName) || (tableColName === COLUMNS_NAMES.ACTIVITY_SCALED) ||
+        visibleColumns.includes(tableColName));
+    }
+  });
+
+  test('Selection', async () => {
+    const selection = model.df.selection;
+
+    for (const [position, selectedMonomers] of Object.entries(model.monomerPositionSelection))
+      expect(selectedMonomers.length, 0, `Selection is not empty for position ${position} after initialization`);
+
+    // Select first monomer-position pair
+    model.modifyMonomerPositionSelection(firstMonomerPair.monomer, firstMonomerPair.position, false);
+    expect(model.monomerPositionSelection[firstMonomerPair.position].includes(firstMonomerPair.monomer), true,
+      `Monomer ${firstMonomerPair.monomer} is not selected at position ${firstMonomerPair.position}`);
+    expect(selection.trueCount, firstMonomerPair.count, `Selection count is not equal to ${firstMonomerPair.count} ` +
+      `for monomer ${firstMonomerPair.monomer} at position ${firstMonomerPair.position}`);
+
+    // Select second monomer-position pair
+    model.modifyMonomerPositionSelection(secondMonomerPair.monomer, secondMonomerPair.position, false);
+    expect(model.monomerPositionSelection[secondMonomerPair.position].includes(secondMonomerPair.monomer), true,
+      `Monomer ${secondMonomerPair.monomer} is not selected at position ${secondMonomerPair.position}`);
+    expect(selection.trueCount, secondMonomerPair.count, `Selection count is not equal to ${secondMonomerPair.count} ` +
+      `for monomer ${secondMonomerPair.monomer} at position ${secondMonomerPair.position}`);
+
+    // Deselect second monomer-position pair
+    model.modifyMonomerPositionSelection(secondMonomerPair.monomer, secondMonomerPair.position, false);
+    expect(model.monomerPositionSelection[secondMonomerPair.position].includes(secondMonomerPair.monomer), false,
+      `Monomer ${secondMonomerPair.monomer} is still selected at position ${secondMonomerPair.position} after ` +
+      `deselection`);
+    expect(selection.trueCount, firstMonomerPair.count, `Selection count is not equal to ${firstMonomerPair.count} ` +
+      `for monomer ${firstMonomerPair.monomer} at position ${firstMonomerPair.position}`);
+
+    // Clear monomer-position selection
+    model.initMonomerPositionSelection({cleanInit: true});
+    for (const [position, selectedMonomers] of Object.entries(model.monomerPositionSelection)) {
+      expect(selectedMonomers.length, 0, `Selection is not empty for position ${position} after clearing ` +
+        `monomer-position selection`);
+    }
+    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`);
+    expect(selection.trueCount, firstCluster.count, `Selection count is not equal to ${firstCluster.count} for ` +
+      `cluster ${firstCluster.name}`);
+
+    // Select second cluster
+    model.modifyClusterSelection(secondCluster.name);
+    expect(model.clusterSelection.includes(secondCluster.name), true,
+      `Cluster ${secondCluster.name} 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}`);
+
+    // Deselect first cluster
+    model.modifyClusterSelection(firstCluster.name);
+    expect(model.clusterSelection.includes(firstCluster.name), false,
+      `Cluster ${firstCluster.name} 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}`);
+
+    // Clear selection
+    model.initClusterSelection();
+    expect(model.clusterSelection.length, 0, `Selection is not empty after clearing cluster selection`);
+    expect(selection.trueCount, 0, `Selection count is not equal to 0 after clearing cluster selection`);
+  });
+
+  test('Filtering', async () => {
+    const filter = model.df.filter;
+
+    for (const [position, filteredMonomers] of Object.entries(model.monomerPositionFilter))
+      expect(filteredMonomers.length, 0, `Filter is not empty for position ${position} after initialization`);
+
+    // Filter by second monomer-position pair
+    model.modifyMonomerPositionSelection(secondMonomerPair.monomer, secondMonomerPair.position, true);
+    expect(model.monomerPositionFilter[secondMonomerPair.position].includes(secondMonomerPair.monomer), true,
+      `Monomer ${secondMonomerPair.monomer} is not filtered at position ${secondMonomerPair.position}`);
+    expect(filter.trueCount, secondMonomerPair.count, `Filter count is not equal to ${secondMonomerPair.count} ` +
+      `for monomer ${secondMonomerPair.monomer} at position ${secondMonomerPair.position}`);
+
+    // Filter by first monomer-position pair
+    model.modifyMonomerPositionSelection(firstMonomerPair.monomer, firstMonomerPair.position, true);
+    expect(model.monomerPositionFilter[firstMonomerPair.position].includes(firstMonomerPair.monomer), true,
+      `Monomer ${firstMonomerPair.monomer} is not filtered at position ${firstMonomerPair.position}`);
+    expect(filter.trueCount, firstMonomerPair.count, `Filter count is not equal to ${firstMonomerPair.count} ` +
+      `for monomer ${firstMonomerPair.monomer} at position ${firstMonomerPair.position}`);
+
+    // Deselect filter for second monomer-position pair
+    model.modifyMonomerPositionSelection(secondMonomerPair.monomer, secondMonomerPair.position, true);
+    expect(model.monomerPositionFilter[secondMonomerPair.position].includes(secondMonomerPair.monomer), false,
+      `Monomer ${secondMonomerPair.monomer} is still filtered at position ${secondMonomerPair.position} after ` +
+      `deselection`);
+    expect(filter.trueCount, firstMonomerPair.count, `Filter count is not equal to ${firstMonomerPair.count} ` +
+      `for monomer ${firstMonomerPair.monomer} at position ${firstMonomerPair.position} after deselection of ` +
+      `monomer ${secondMonomerPair.monomer} at position ${secondMonomerPair.position}`);
+
+    // Clear selection
+    model.initMonomerPositionFilter({cleanInit: true});
+    expect(filter.trueCount, df.rowCount, `Filter count is not equal to ${df.rowCount} after clearing ` +
+      `monomer-position filter`);
+
+    for (const [position, filteredMonomers] of Object.entries(model.monomerPositionFilter)) {
+      expect(filteredMonomers.length, 0, `Filter is not empty for position ${position} after clearing ` +
+        `monomer-position filter`);
+    }
+  });
+});