@datagrok/peptides 1.17.4 → 1.17.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/peptides",
   "friendlyName": "Peptides",
-  "version": "1.17.4",
+  "version": "1.17.6",
   "author": {
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@datagrok-libraries/bio": "^5.39.14",
-    "@datagrok-libraries/ml": "^6.4.1",
+    "@datagrok-libraries/ml": "^6.4.10",
     "@datagrok-libraries/statistics": "^1.2.11",
     "@datagrok-libraries/utils": "^4.1.36",
     "@datagrok-libraries/tutorials": "^1.3.11",

package/src/model.ts

@@ -51,6 +51,8 @@ import {showMonomerTooltip} from './utils/tooltips';
 import {AggregationColumns, MonomerPositionStats} from './utils/statistics';
 import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter';
 import {getDbscanWorker} from '@datagrok-libraries/math';
+import {markovCluster} from '@datagrok-libraries/ml/src/MCL/clustering-view';
+import {DistanceAggregationMethods} from '@datagrok-libraries/ml/src/distance-matrix/types';
 
 export enum VIEWER_TYPE {
   MONOMER_POSITION = 'Monomer-Position',
@@ -99,6 +101,8 @@ export class PeptidesModel {
   accordionSource: VIEWER_TYPE | null = null;
   // sequence space viewer
   _sequenceSpaceViewer: DG.ScatterPlotViewer | null = null;
+  //MCL viewer
+  _mclViewer: DG.ScatterPlotViewer | null = null;
   /**
    * @param {DG.DataFrame}dataFrame - DataFrame to use for analysis
    */
@@ -151,6 +155,7 @@ export class PeptidesModel {
   // Peptides analysis settings
   _settings: type.PeptidesSettings | null = null;
   _sequenceSpaceCols: string[] = [];
+  _mclCols: string[] = [];
 
   /**
    * @return {type.PeptidesSettings}- Peptides analysis settings
@@ -185,6 +190,9 @@ export class PeptidesModel {
       case 'showDendrogram':
         updateVars.add('dendrogram');
         break;
+      case 'showSequenceSpace':
+        updateVars.add('showSequenceSpace');
+        break;
       case 'showLogoSummaryTable':
         updateVars.add('logoSummaryTable');
         break;
@@ -199,6 +207,10 @@ export class PeptidesModel {
         break;
       case 'sequenceSpaceParams':
         updateVars.add('sequenceSpaceParams');
+        break;
+      case 'mclSettings':
+        updateVars.add('mclSettings');
+        break;
       }
     }
     // Write updated settings
@@ -216,6 +228,8 @@ export class PeptidesModel {
           updateVars.add('clusterParams');
       }
     }
+    if (updateVars.has('sequenceSpaceParams'))
+      updateVars.delete('clusterParams');
 
     // Apply new settings
     for (const variable of updateVars) {
@@ -258,11 +272,16 @@ export class PeptidesModel {
         mpr.render();
         break;
       case 'sequenceSpaceParams':
-        this.addSequenceSpace({clusterEmbeddings: this.settings!.sequenceSpaceParams?.clusterEmbeddings});
+      case 'showSequenceSpace':
+        if (this.settings!.showSequenceSpace)
+          this.addSequenceSpace({clusterEmbeddings: this.settings!.sequenceSpaceParams?.clusterEmbeddings});
         break;
       case 'clusterParams':
         this.clusterEmbeddings();
         break;
+      case 'mclSettings':
+        this.addMCLClusters();
+        break;
       }
     }
   }
@@ -1170,6 +1189,67 @@ export class PeptidesModel {
     gridCol && (gridCol.visible = false);
   }
 
+  async addMCLClusters(): Promise<void> {
+    if (this._mclViewer !== null) {
+      try {
+        this._mclViewer?.detach();
+        this._mclViewer?.close();
+      } catch (_) {}
+    }
+    if (this._mclCols.length !== 0)
+      this._mclCols.forEach((col) => this.df.columns.remove(col));
+    this._mclCols = [];
+    const seqCol = this.df.getCol(this.settings!.sequenceColumnName!);
+    this.settings!.mclSettings ??= new type.MCLSettings();
+    const mclParams = this.settings?.mclSettings;
+
+    let counter = 0;
+    const addedColCount = 4;
+    const columnAddedSub = this.df.onColumnsAdded.subscribe((colArgs: DG.ColumnsArgs) => {
+      for (const col of colArgs.columns) {
+        if (col.name.toLowerCase().startsWith('embed') ||
+        col.name.toLowerCase().startsWith('cluster')) {
+          const gridCol = this.analysisView.grid.col(col.name);
+          if (gridCol == null || this._mclCols.includes(col.name))
+            continue;
+
+          gridCol.visible = false;
+          this._mclCols.push(col.name);
+          counter++;
+        }
+      }
+      if (counter === addedColCount)
+        columnAddedSub.unsubscribe();
+    });
+    const mclAdditionSub = grok.events.onViewerAdded.subscribe((info) => {
+      try {
+        const v = info.args.viewer as DG.ScatterPlotViewer;
+        if (v.type === DG.VIEWER.SCATTER_PLOT) {
+          if (this._sequenceSpaceViewer && this.analysisView.dockManager.findNode(this._sequenceSpaceViewer.root)) {
+            const rootNode = this.analysisView.dockManager.findNode(this._sequenceSpaceViewer.root);
+            setTimeout(() => {
+              this.analysisView.dockManager.dock(v, DG.DOCK_TYPE.FILL, rootNode);
+            });
+          }
+          mclAdditionSub.unsubscribe();
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    });
+
+    const bioPreprocessingFunc = DG.Func.find({package: 'Bio', name: 'macromoleculePreprocessingFunction'})[0];
+    const mclViewer = await markovCluster(
+      this.df, [seqCol], [mclParams!.distanceF], [1],
+      DistanceAggregationMethods.MANHATTAN, [bioPreprocessingFunc], [{
+        gapOpen: mclParams!.gapOpen, gapExtend: mclParams!.gapExtend,
+        fingerprintType: mclParams!.fingerprintType,
+      }], mclParams!.threshold, mclParams!.maxIterations,
+    );
+    mclAdditionSub.unsubscribe();
+    this._mclViewer = mclViewer ?? null;
+  }
+
   /**
    * Adds Sequence Space viewer to the analysis view
    */
@@ -1240,7 +1320,7 @@ export class PeptidesModel {
         if (col.name.toLowerCase().startsWith('embed_') ||
         ( seqSpaceSettings.clusterEmbeddings && col.name.toLowerCase().startsWith('cluster'))) {
           const gridCol = this.analysisView.grid.col(col.name);
-          if (gridCol == null)
+          if (gridCol == null || this._sequenceSpaceCols.includes(col.name))
             continue;
 
           gridCol.visible = false;
@@ -1252,8 +1332,25 @@ export class PeptidesModel {
         columnAddedSub.unsubscribe();
     });
 
+    const seqSpaceAdditionSub = grok.events.onViewerAdded.subscribe((info) => {
+      try {
+        const v = info.args.viewer as DG.ScatterPlotViewer;
+        if (v.type === DG.VIEWER.SCATTER_PLOT) {
+          if (this._mclViewer && this.analysisView.dockManager.findNode(this._mclViewer.root)) {
+            const rootNode = this.analysisView.dockManager.findNode(this._mclViewer.root);
+            setTimeout(() => {
+              this.analysisView.dockManager.dock(v, DG.DOCK_TYPE.FILL, rootNode);
+            });
+          }
+          seqSpaceAdditionSub.unsubscribe();
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    });
     const seqSpaceViewer: DG.ScatterPlotViewer | undefined =
       await grok.functions.call('Bio:sequenceSpaceTopMenu', seqSpaceParams);
+    seqSpaceAdditionSub.unsubscribe();
     if (!(seqSpaceViewer instanceof DG.ScatterPlotViewer))
       return;
 

package/src/package-test.ts

@@ -18,6 +18,10 @@ export {tests};
 //input: object testContext {optional: true}
 //output: dataframe result
 export async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {
+  // const helmInit = DG.Func.find({name: 'initHelm'})[0];
+  // if (helmInit)
+  //   await helmInit.apply();
+  testContext.catchUnhandled = false;
   const data = await runTests({category, test, testContext});
   return DG.DataFrame.fromObjects(data)!;
 }

package/src/tests/core.ts

@@ -12,29 +12,19 @@ import {ALIGNMENT, ALPHABET, NOTATION, TAGS as bioTAGS} from '@datagrok-librarie
 import {MonomerPosition} from '../viewers/sar-viewer';
 
 category('Core', () => {
-  let simpleTable: DG.DataFrame;
-  let simpleActivityCol: DG.Column<number>;
-  let simpleAlignedSeqCol: DG.Column<string>;
-  let simpleScaledCol: DG.Column<number>;
-
-  let complexTable: DG.DataFrame;
-  let complexActivityCol: DG.Column<number>;
-  let complexAlignedSeqCol: DG.Column<string>;
-  let complexScaledCol: DG.Column<number>;
   const alignedSequenceCol = 'AlignedSequence';
 
   let model: PeptidesModel | null = null;
-
   test('Start analysis: simple', async () => {
     const simpleActivityColName = 'IC50';
-    simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
-    simpleActivityCol = simpleTable.getCol(simpleActivityColName);
-    simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
+    const simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
+    const simpleActivityCol = simpleTable.getCol(simpleActivityColName);
+    const simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
     simpleAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
-    simpleScaledCol = scaleActivity(simpleActivityCol, C.SCALING_METHODS.MINUS_LG);
+    const simpleScaledCol = scaleActivity(simpleActivityCol, C.SCALING_METHODS.MINUS_LG);
 
     model = await startAnalysis(
       simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol, C.SCALING_METHODS.MINUS_LG);
@@ -47,15 +37,15 @@ category('Core', () => {
 
   test('Start analysis: сomplex', async () => {
     const complexActivityColName = 'Activity';
-    complexTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned_2.csv'));
-    complexActivityCol = complexTable.getCol(complexActivityColName);
-    complexAlignedSeqCol = complexTable.getCol('MSA');
+    const complexTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned_2.csv'));
+    const complexActivityCol = complexTable.getCol(complexActivityColName);
+    const complexAlignedSeqCol = complexTable.getCol('MSA');
     complexAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     complexAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.UN);
     complexAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.SEPARATOR);
     complexAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
     complexAlignedSeqCol.setTag(C.TAGS.SEPARATOR, '/');
-    complexScaledCol = scaleActivity(complexActivityCol, C.SCALING_METHODS.MINUS_LG);
+    const complexScaledCol = scaleActivity(complexActivityCol, C.SCALING_METHODS.MINUS_LG);
 
     model = await startAnalysis(
       complexActivityCol, complexAlignedSeqCol, null, complexTable, complexScaledCol, C.SCALING_METHODS.MINUS_LG);
@@ -68,14 +58,14 @@ category('Core', () => {
 
   test('Save and load project', async () => {
     const simpleActivityColName = 'IC50';
-    simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
-    simpleActivityCol = simpleTable.getCol(simpleActivityColName);
-    simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
+    const simpleTable = DG.DataFrame.fromCsv(await _package.files.readAsText('aligned.csv'));
+    const simpleActivityCol = simpleTable.getCol(simpleActivityColName);
+    const simpleAlignedSeqCol = simpleTable.getCol(alignedSequenceCol);
     simpleAlignedSeqCol.semType = DG.SEMTYPE.MACROMOLECULE;
     simpleAlignedSeqCol.setTag(C.TAGS.ALPHABET, ALPHABET.PT);
     simpleAlignedSeqCol.setTag(DG.TAGS.UNITS, NOTATION.FASTA);
     simpleAlignedSeqCol.setTag(bioTAGS.aligned, ALIGNMENT.SEQ_MSA);
-    simpleScaledCol = scaleActivity(simpleActivityCol, C.SCALING_METHODS.MINUS_LG);
+    const simpleScaledCol = scaleActivity(simpleActivityCol, C.SCALING_METHODS.MINUS_LG);
 
     model = await startAnalysis(simpleActivityCol, simpleAlignedSeqCol, null, simpleTable, simpleScaledCol,
       C.SCALING_METHODS.MINUS_LG);
@@ -106,4 +96,4 @@ category('Core', () => {
     await grok.dapi.tables.delete(sti);
     await grok.dapi.projects.delete(sp);
   }, {skipReason: 'ViewLayout should become ViewInfo in 1.18.'});
-});
+}, {clear: true});

package/src/tests/viewers.ts

@@ -24,7 +24,8 @@ category('Viewers: Basic', () => {
   const viewers = DG.Func.find({package: 'Peptides', tags: ['viewer']}).map((f) => f.friendlyName);
   for (const v of viewers) {
     test(v, async () => {
-      await testViewer(v, df.clone(), {detectSemanticTypes: true, arbitraryDfTest: false});
+      await testViewer(v, df.clone(), {detectSemanticTypes: true, arbitraryDfTest: false, readOnly: true});
+      await delay(1000);
     });
   }
 });

package/src/tests/widgets.ts

@@ -48,7 +48,7 @@ category('Widgets: Settings', () => {
 
     // Check number of panes
     const panes = settingsElements.accordion.panes.map((pane) => pane.name);
-    expect(panes.length, 4, `Expected 4 panes, got ${settingsElements.accordion.panes.length}`);
+    expect(panes.length, 5, `Expected 5 panes, got ${settingsElements.accordion.panes.length}`);
     for (const paneName of Object.values(SETTINGS_PANES))
       expect(panes.includes(paneName), true, `Pane ${paneName} is missing`);
 
@@ -153,6 +153,7 @@ category('Widgets: Actions', () => {
 
   before(async () => {
     df = DG.DataFrame.fromCsv(await _package.files.readAsText('tests/HELM_small.csv'));
+    await df.meta.detectSemanticTypes();
     activityCol = df.getCol(TEST_COLUMN_NAMES.ACTIVITY);
     sequenceCol = df.getCol(TEST_COLUMN_NAMES.SEQUENCE);
     sequenceCol.semType = DG.SEMTYPE.MACROMOLECULE;
@@ -179,13 +180,14 @@ category('Widgets: Actions', () => {
 
     const selection = model.df.selection;
     selection.set(0, true, false);
+    selection.set(1, true, false);
 
     const newViewId = model.createNewView();
     const currentTable = grok.shell.t;
 
     expect(currentTable.getTag(C.TAGS.MULTIPLE_VIEWS), '1', 'Current table is expected to have multiple views tag');
     expect(currentTable.getTag(DG.TAGS.ID), newViewId, 'Current table is expected to have the same UUID as new view');
-    expect(currentTable.rowCount, 1, 'Current table is expected to have 1 row');
+    expect(currentTable.rowCount, 2, 'Current table is expected to have 2 rows');
 
     await delay(500);
     const currentTableModel = currentTable.temp[PeptidesModel.modelName] as PeptidesModel;

package/src/utils/cell-renderer.ts

@@ -59,7 +59,7 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
 
   const x = currentMeanDifference >= 0 ? pValComplement : -pValComplement;
   const coef = DG.Color.toHtml(pVal === null ? DG.Color.lightLightGray :
-    DG.Color.scaleColor(x, -centeredPValLimit, centeredPValLimit));
+    DG.Color.scaleColor(x, -centeredPValLimit, centeredPValLimit, 255));
 
   const halfWidth = bounds.width / 2;
   const maxMeanDifference = Math.max(Math.abs(viewer.monomerPositionStats.general.minMeanDifference),
@@ -110,13 +110,17 @@ export function renderMutationCliffCell(canvasContext: CanvasRenderingContext2D,
  * @param bounds - Cell bounds.
  * @param color - Cell color.
  */
+
+function setAlpha(color: number, alpha: number): number {
+  return (color & 0x00ffffff | (alpha << 24)) >>> 0;
+}
 export function renderInvariantMapCell(canvasContext: CanvasRenderingContext2D, currentMonomer: string,
   currentPosition: string, invariantMapSelection: type.Selection, cellValue: number, bounds: 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));
+  color = DG.Color.fromHtml(DG.Color.toHtml(setAlpha(color, 255)));
   canvasContext.fillStyle = DG.Color.toHtml(color);
   canvasContext.fillRect(bounds.x, bounds.y, bounds.width, bounds.height);
   canvasContext.font = '13px Roboto, Roboto Local, sans-serif';

package/src/utils/misc.ts

@@ -271,6 +271,7 @@ export function modifySelection(selection: type.Selection, clusterOrMonomerPosit
  */
 export function highlightMonomerPosition(monomerPosition: type.SelectionItem, dataFrame: DG.DataFrame,
   monomerPositionStats: MonomerPositionStats): void {
+  if (!dataFrame) return;
   const bitArray = new BitArray(dataFrame.rowCount);
   if (monomerPosition.positionOrClusterType === C.COLUMNS_NAMES.MONOMER) {
     const positionStats = Object.values(monomerPositionStats);
@@ -387,3 +388,14 @@ export function isApplicableDataframe(table: DG.DataFrame, minRows: number = 2):
   return table.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE).length > 0 &&
     wu(table.columns.numerical).toArray().length > 0 && table.rowCount >= minRows;
 }
+
+export function debounce<T extends Array<any>, K>(f: (...args: T) => Promise<K>, timeout: number = 500,
+): (...args: T) => Promise<K> {
+  let timer: NodeJS.Timeout | number | undefined;
+  return async (...args: T) => {
+    return new Promise<K>((resolve) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => resolve(f(...args)), timeout);
+    });
+  };
+}

package/src/utils/types.ts

@@ -20,8 +20,19 @@ export interface PeptidesSettings {
   showMostPotentResidues?: boolean,
   showLogoSummaryTable?: boolean,
   showDendrogram?: boolean,
+  showSequenceSpace?: boolean,
   columns?: AggregationColumns,
   sequenceSpaceParams: SequenceSpaceParams,
+  mclSettings: MCLSettings,
+}
+
+export class MCLSettings {
+  maxIterations: number = 5;
+  threshold: number = 80;
+  distanceF: MmDistanceFunctionsNames = MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH;
+  gapOpen: number = 1;
+  gapExtend: number = 0.6;
+  fingerprintType: string = 'Morgan';
 }
 
 export class SequenceSpaceParams {

package/src/viewers/sar-viewer.ts

@@ -23,6 +23,7 @@ import {_package} from '../package';
 import {showTooltip} from '../utils/tooltips';
 import {calculateMonomerPositionStatistics, findMutations, MutationCliffsOptions} from '../utils/algorithms';
 import {
+  debounce,
   extractColInfo,
   getTotalAggColumns,
   highlightMonomerPosition,
@@ -91,6 +92,9 @@ export abstract class SARViewer extends DG.JsViewer implements ISARViewer {
   maxMutations: number;
   _scaledActivityColumn: DG.Column | null = null;
   doRender: boolean = true;
+  mutationCliffsDebouncer: (
+    activityArray: type.RawData, monomerInfoArray: type.RawColumn[], options?: MutationCliffsOptions
+    ) => Promise<type.MutationCliffs>;
 
   /** Sets common properties for inheritor viewers. */
   protected constructor() {
@@ -111,11 +115,16 @@ export abstract class SARViewer extends DG.JsViewer implements ISARViewer {
     this.minActivityDelta = this.float(SAR_PROPERTIES.MIN_ACTIVITY_DELTA, 0,
       {category: PROPERTY_CATEGORIES.MUTATION_CLIFFS, min: 0, max: 100});
     this.maxMutations = this.int(SAR_PROPERTIES.MAX_MUTATIONS, 1,
-      {category: PROPERTY_CATEGORIES.MUTATION_CLIFFS, min: 1, max: 50});
+      {category: PROPERTY_CATEGORIES.MUTATION_CLIFFS, min: 1, max: 20});
 
     this.columns = this.columnList(SAR_PROPERTIES.COLUMNS, [], {category: PROPERTY_CATEGORIES.AGGREGATION});
     this.aggregation = this.string(SAR_PROPERTIES.AGGREGATION, DG.AGG.AVG,
       {category: PROPERTY_CATEGORIES.AGGREGATION, choices: C.AGGREGATION_TYPES});
+
+    this.mutationCliffsDebouncer = debounce(
+      async (activityArray: type.RawData, monomerInfoArray: type.RawColumn[], options?: MutationCliffsOptions) => {
+        return await findMutations(activityArray, monomerInfoArray, options);
+      });
   }
 
   _viewerGrid: DG.Grid | null = null;
@@ -433,7 +442,7 @@ export abstract class SARViewer extends DG.JsViewer implements ISARViewer {
    * @return - mutation cliffs.
    */
   async calculateMutationCliffs(): Promise<MutationCliffs> {
-    const scaledActivityCol: DG.Column<number> = this.dataFrame.getCol(this.sequenceColumnName);
+    const scaledActivityCol: DG.Column<number> = this.dataFrame.getCol(this.activityColumnName);
     //TODO: set categories ordering the same to share compare indexes instead of strings
     const monomerCols: type.RawColumn[] = this.positionColumns.map(extractColInfo);
     const targetCol = this.targetColumnName ? extractColInfo(this.dataFrame.getCol(this.targetColumnName)) : null;
@@ -442,7 +451,7 @@ export abstract class SARViewer extends DG.JsViewer implements ISARViewer {
       maxMutations: this.maxMutations, minActivityDelta: this.minActivityDelta,
       targetCol, currentTarget: this.targetCategory,
     };
-    return await findMutations(scaledActivityCol.getRawData(), monomerCols, options);
+    return await this.mutationCliffsDebouncer(scaledActivityCol.getRawData(), monomerCols, options);
   }
 }
 

package/src/widgets/peptides.ts

@@ -130,7 +130,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): Di
     bitsetChanged.unsubscribe();
     if (sequencesCol) {
       const model = await startAnalysis(activityColumnChoice.value!, sequencesCol, clustersColumnChoice.value, df,
-        scaledCol, activityScalingMethod.value ?? C.SCALING_METHODS.NONE, {addSequenceSpace: true,
+        scaledCol, activityScalingMethod.value ?? C.SCALING_METHODS.NONE, {addSequenceSpace: false, addMCL: true,
           useEmbeddingsClusters: generateClustersInput.value ?? false});
       return model !== null;
     }
@@ -167,6 +167,7 @@ export function analyzePeptidesUI(df: DG.DataFrame, col?: DG.Column<string>): Di
 type AnalysisOptions = {
   addSequenceSpace?: boolean,
   useEmbeddingsClusters?: boolean,
+  addMCL?: boolean,
 };
 
 /**
@@ -207,8 +208,9 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
 
   const settings: type.PeptidesSettings = {
     sequenceColumnName: peptidesCol.name, activityColumnName: activityColumn.name, activityScaling: scaling,
-    columns: {}, showDendrogram: false,
+    columns: {}, showDendrogram: false, showSequenceSpace: false,
     sequenceSpaceParams: new type.SequenceSpaceParams(!!options.useEmbeddingsClusters && !clustersColumn),
+    mclSettings: new type.MCLSettings(),
   };
 
   if (clustersColumn) {
@@ -253,6 +255,25 @@ export async function startAnalysis(activityColumn: DG.Column<number>, peptidesC
         }, 100);
       }
     }
+  } else if (options.addMCL ?? false) {
+    await model.addMCLClusters();
+    if (!clustersColumn && (options.useEmbeddingsClusters ?? false)) {
+      const mclClusterCol = model._mclCols
+        .find(
+          (col) => model?.df.col(col) && col.toLowerCase().startsWith('cluster') && !col.toLowerCase().includes('size'),
+        );
+      if (mclClusterCol) {
+        const lstProps: ILogoSummaryTable = {
+          clustersColumnName: mclClusterCol, sequenceColumnName: peptidesCol.name, activityScaling: scaling,
+          activityColumnName: activityColumn.name,
+        };
+        await model.addLogoSummaryTable(lstProps);
+        setTimeout(() => {
+          model && (model?.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable)?.render &&
+          (model?.findViewer(VIEWER_TYPE.LOGO_SUMMARY_TABLE) as LogoSummaryTable)?.render();
+        }, 100);
+      }
+    }
   }
 
 

package/src/widgets/settings.ts

@@ -19,6 +19,7 @@ export enum SETTINGS_PANES {
   VIEWERS = 'Viewers',
   COLUMNS = 'Columns',
   SEQUENCE_SPACE = 'Sequence space',
+  MCL = 'MCL',
 }
 
 export enum GENERAL_INPUTS {
@@ -44,12 +45,22 @@ export enum SEQUENCE_SPACE_INPUTS {
   FINGERPRINT_TYPE = 'Fingerprint type',
 }
 
+export enum MCL_INPUTS {
+  DISTANCE_FUNCTION = 'Distance function',
+  GAP_OPEN = 'Gap open penalty',
+  GAP_EXTEND = 'Gap extend penalty',
+  FINGERPRINT_TYPE = 'Fingerprint type',
+  THRESHOLD = 'Similarity threshold',
+  MAX_ITERATIONS = 'Max iterations',
+}
+
 
 export const PANES_INPUTS = {
   [SETTINGS_PANES.GENERAL]: GENERAL_INPUTS,
   [SETTINGS_PANES.VIEWERS]: VIEWERS_INPUTS,
   [SETTINGS_PANES.COLUMNS]: COLUMNS_INPUTS,
   [SETTINGS_PANES.SEQUENCE_SPACE]: SEQUENCE_SPACE_INPUTS,
+  [SETTINGS_PANES.MCL]: MCL_INPUTS,
 };
 
 /**
@@ -69,7 +80,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   const result: type.PartialPeptidesSettings = {};
   const inputs: PaneInputs = {};
   const seqSpaceParams = settings?.sequenceSpaceParams ?? new type.SequenceSpaceParams();
-
+  const mclParams = settings?.mclSettings ?? new type.MCLSettings();
   // General pane options
   const activityCol = ui.columnInput(GENERAL_INPUTS.ACTIVITY, model.df,
     model.df.getCol(model.settings!.activityColumnName!), () => result.activityColumnName = activityCol.value!.name,
@@ -102,10 +113,23 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
   const isDendrogramEnabled = wu(model.analysisView.viewers).some((v) => v.type === VIEWER_TYPE.DENDROGRAM);
   const dendrogram = ui.boolInput(VIEWER_TYPE.DENDROGRAM, isDendrogramEnabled ?? false,
     () => result.showDendrogram = dendrogram.value) as DG.InputBase<boolean>;
+  const showSeqSpace = ui.boolInput('Sequence space', !!settings?.showSequenceSpace, () => {
+    result.showSequenceSpace = showSeqSpace.value ?? undefined;
+    if (showSeqSpace.value) {
+      seqSpacePane.root.style.display = 'flex';
+      if (!settings?.showSequenceSpace)
+        result.sequenceSpaceParams = seqSpaceParams;
+    } else {
+      seqSpacePane.root.style.display = 'none';
+      delete result.sequenceSpaceParams;
+    }
+    if (result.showSequenceSpace === settings?.showSequenceSpace)
+      delete result.showSequenceSpace;
+  });
   dendrogram.setTooltip('Show dendrogram viewer');
   dendrogram.enabled = getTreeHelperInstance() !== null;
 
-  accordion.addPane(SETTINGS_PANES.VIEWERS, () => ui.inputs([dendrogram]), true);
+  accordion.addPane(SETTINGS_PANES.VIEWERS, () => ui.inputs([dendrogram, showSeqSpace]), true);
   inputs[SETTINGS_PANES.VIEWERS] = [dendrogram];
 
   // Columns to include pane options
@@ -182,7 +206,7 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
         input.root.style.display = 'none';
     });
   }
-
+  // SEQ SPACE INPUTS
   const distanceFunctionInput = ui.choiceInput(SEQUENCE_SPACE_INPUTS.DISTANCE_FUNCTION, seqSpaceParams.distanceF,
     [distFNames.NEEDLEMANN_WUNSCH, distFNames.HAMMING, distFNames.LEVENSHTEIN, distFNames.MONOMER_CHEMICAL_DISTANCE],
     () => onSeqSpaceParamsChange('distanceF', distanceFunctionInput.value));
@@ -203,7 +227,8 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
     () => onSeqSpaceParamsChange('minPts', minPtsInput.value));
   minPtsInput.setTooltip('Minimum number of points in a cluster');
   const fingerprintTypesInput = ui.choiceInput('Fingerprint type', seqSpaceParams.fingerprintType,
-    ['Morgan', 'RDKit', 'Pattern'], () => onSeqSpaceParamsChange('fingerprintType', fingerprintTypesInput.value));
+    ['Morgan', 'RDKit', 'Pattern', 'AtomPair', 'MACCS', 'TopologicalTorsion'],
+    () => onSeqSpaceParamsChange('fingerprintType', fingerprintTypesInput.value));
   function correctSeqSpaceInputs(): void {
     toggleInputs([gapOpenInput, gapExtendInput], distanceFunctionInput.value === distFNames.NEEDLEMANN_WUNSCH);
     toggleInputs([epsilonInput, minPtsInput], clusterEmbeddingsInput.value === true);
@@ -212,14 +237,70 @@ export function getSettingsDialog(model: PeptidesModel): SettingsElements {
       distanceFunctionInput.value === distFNames.NEEDLEMANN_WUNSCH);
   }
   correctSeqSpaceInputs();
+  // END OF SEQ SPACE INPUTS
+
+  //MCL INPUTS
+
+  const modifiedMCLParams: Partial<type.MCLSettings> = {};
+  function onMCLParamsChange(fieldName: keyof type.MCLSettings, value: any): void {
+    correctMCLInputs();
+    //correctSeqSpaceInputs();
+    if (value === null || value === undefined || value === '')
+      return;
+    modifiedMCLParams[fieldName] = value;
+    let isAllSame = true;
+    for (const [key, val] of Object.entries(modifiedMCLParams)) {
+      if (val !== mclParams[key as keyof type.MCLSettings]) {
+        isAllSame = false;
+        break;
+      }
+    }
+    if (isAllSame)
+      delete result.mclSettings;
+    else
+      result.mclSettings = {...mclParams, ...modifiedMCLParams};
+  }
+
+  function correctMCLInputs(): void {
+    toggleInputs([mclGapOpenInput, mclGapExtendInput], mclDistanceFunctionInput.value === distFNames.NEEDLEMANN_WUNSCH);
+    toggleInputs([mclFingerprintTypesInput],
+      mclDistanceFunctionInput.value === distFNames.MONOMER_CHEMICAL_DISTANCE ||
+      mclDistanceFunctionInput.value === distFNames.NEEDLEMANN_WUNSCH);
+  }
+
+  const mclDistanceFunctionInput = ui.choiceInput(SEQUENCE_SPACE_INPUTS.DISTANCE_FUNCTION, mclParams.distanceF,
+    [distFNames.NEEDLEMANN_WUNSCH, distFNames.MONOMER_CHEMICAL_DISTANCE, distFNames.HAMMING, distFNames.LEVENSHTEIN],
+    () => onMCLParamsChange('distanceF', mclDistanceFunctionInput.value));
+  const mclGapOpenInput = ui.floatInput(SEQUENCE_SPACE_INPUTS.GAP_OPEN, mclParams.gapOpen,
+    () => onMCLParamsChange('gapOpen', mclGapOpenInput.value));
+  const mclGapExtendInput = ui.floatInput(SEQUENCE_SPACE_INPUTS.GAP_EXTEND, mclParams.gapExtend,
+    () => onMCLParamsChange('gapExtend', mclGapExtendInput.value));
+  const mclFingerprintTypesInput = ui.choiceInput('Fingerprint type', mclParams.fingerprintType,
+    ['Morgan', 'RDKit', 'Pattern', 'AtomPair', 'MACCS', 'TopologicalTorsion'],
+    () => onMCLParamsChange('fingerprintType', mclFingerprintTypesInput.value));
+  const mclThresholdInput = ui.intInput('Similarity threshold', mclParams.threshold ?? 80,
+    () => onMCLParamsChange('threshold', mclThresholdInput.value));
+  const mclMaxIterationsInput = ui.intInput('Max iterations', mclParams.maxIterations ?? 5,
+    () => onMCLParamsChange('maxIterations', mclMaxIterationsInput.value));
+  correctMCLInputs();
+
+  const mclInputs = [mclThresholdInput, mclDistanceFunctionInput, mclFingerprintTypesInput,
+    mclGapOpenInput, mclGapExtendInput, mclMaxIterationsInput];
+
+  accordion.addPane(SETTINGS_PANES.MCL, () => ui.inputs(mclInputs), true);
+  inputs[SETTINGS_PANES.MCL] = mclInputs;
+  // END OF MCL INPUTS
 
   const seqSpaceInputs = [distanceFunctionInput, fingerprintTypesInput, gapOpenInput,
     gapExtendInput, clusterEmbeddingsInput, epsilonInput, minPtsInput];
-  accordion.addPane(SETTINGS_PANES.SEQUENCE_SPACE, () => ui.inputs(seqSpaceInputs), true);
+  const seqSpacePane = accordion.addPane(SETTINGS_PANES.SEQUENCE_SPACE, () => ui.inputs(seqSpaceInputs), true);
   inputs[SETTINGS_PANES.SEQUENCE_SPACE] = seqSpaceInputs;
+  showSeqSpace.fireChanged();
   const dialog = ui.dialog('Peptides settings').add(accordion);
   dialog.root.style.width = '400px';
-  dialog.onOK(() => model.settings = result);
+  dialog.onOK(() => {
+    model.settings = result;
+  });
   dialog.show();
 
   return {dialog, accordion, inputs};