@datagrok/bio 2.1.11 → 2.4.2

package/src/package.ts

@@ -7,24 +7,14 @@ export const _package = new DG.Package();
 
 import {MacromoleculeDifferenceCellRenderer, MonomerCellRenderer} from './utils/cell-renderer';
 import {VdRegionsViewer} from './viewers/vd-regions-viewer';
-import {runKalign, testMSAEnoughMemory} from './utils/multiple-sequence-alignment';
-import {SequenceAlignment, Aligned} from './seq_align';
-import {getEmbeddingColsNames, sequenceSpace, sequenceSpaceByFingerprints} from './analysis/sequence-space';
+import {runKalign} from './utils/multiple-sequence-alignment';
+import {SequenceAlignment} from './seq_align';
+import {getEmbeddingColsNames, sequenceSpaceByFingerprints} from './analysis/sequence-space';
 import {getActivityCliffs} from '@datagrok-libraries/ml/src/viewers/activity-cliffs';
 import {
-  createLinesGrid,
-  createPropPanelElement,
-  createTooltipElement,
-  getChemSimilaritiesMarix,
-  getSimilaritiesMarix
+  createLinesGrid, createPropPanelElement, createTooltipElement, getChemSimilaritiesMatrix,
 } from './analysis/sequence-activity-cliffs';
-import {
-  createJsonMonomerLibFromSdf,
-  encodeMonomers,
-  getMolfilesFromSeq
-} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {HELM_CORE_LIB_FILENAME} from '@datagrok-libraries/bio/src/utils/const';
-import {getMacroMol} from './utils/atomic-works';
 import {MacromoleculeSequenceCellRenderer} from './utils/cell-renderer';
 import {convert} from './utils/convert';
 import {getMacroMolColumnPropertyPanel, representationsWidget} from './widgets/representations';
@@ -36,23 +26,39 @@ import {splitAlignedSequences} from '@datagrok-libraries/bio/src/utils/splitter'
 import * as C from './utils/constants';
 import {SequenceSimilarityViewer} from './analysis/sequence-similarity-viewer';
 import {SequenceDiversityViewer} from './analysis/sequence-diversity-viewer';
-import {invalidateMols, MONOMERIC_COL_TAGS, substructureSearchDialog} from './substructure-search/substructure-search';
+import {substructureSearchDialog} from './substructure-search/substructure-search';
 import {saveAsFastaUI} from './utils/save-as-fasta';
 import {BioSubstructureFilter} from './widgets/bio-substructure-filter';
-import {getMonomericMols} from './calculations/monomerLevelMols';
 import {delay} from '@datagrok-libraries/utils/src/test';
-import {from, Observable, Subject} from 'rxjs';
 import {
-  TAGS as bio_TAGS,
-  Monomer, IMonomerLib, MonomerWorks, MonomerLib, readLibrary,
-  SeqPalette, UnitsHandler, WebLogoViewer, getStats, splitterAsHelm
-} from '@datagrok-libraries/bio';
-
-const STORAGE_NAME = 'Libraries';
-const LIB_PATH = 'System:AppData/Bio/libraries';
-const LIBS_PATH = 'libraries/';
+  getStats,
+  NOTATION,
+  splitterAsHelm,
+  TAGS as bioTAGS,
+  ALPHABET
+} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {pepseaMethods, runPepsea} from './utils/pepsea';
+import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
+import {SeqPalette} from '@datagrok-libraries/bio/src/seq-palettes';
+import {UnitsHandler} from '@datagrok-libraries/bio/src/utils/units-handler';
+import {WebLogoViewer} from './viewers/web-logo-viewer';
+import {createJsonMonomerLibFromSdf, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
+import {LIB_PATH, LIB_STORAGE_NAME, MonomerLibHelper} from './utils/monomer-lib';
+import {getMacromoleculeColumn} from './utils/ui-utils';
+import {IUMAPOptions, ITSNEOptions} from '@datagrok-libraries/ml/src/reduce-dimensionality';
+import {SequenceSpaceFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/seq-space-editor';
+import {ActivityCliffsFunctionEditor} from '@datagrok-libraries/ml/src/functionEditors/activity-cliffs-editor';
+
+// /** Avoid reassinging {@link monomerLib} because consumers subscribe to {@link IMonomerLib.onChanged} event */
+// let monomerLib: MonomerLib | null = null;
+
+//name: getMonomerLibHelper
+//description:
+//output: object result
+export function getMonomerLibHelper(): IMonomerLibHelper {
+  return MonomerLibHelper.instance;
+}
 
-let monomerLib: IMonomerLib | null = null;
 export let hydrophobPalette: SeqPaletteCustom | null = null;
 
 export class SeqPaletteCustom implements SeqPalette {
@@ -67,16 +73,21 @@ export class SeqPaletteCustom implements SeqPalette {
   }
 }
 
+// let loadLibrariesPromise: Promise<void> = Promise.resolve();
+
 //tags: init
 export async function initBio() {
-  await loadLibraries();
-  let monomers: string[] = [];
-  let logPs: number[] = [];
+  // loadLibrariesPromise = loadLibrariesPromise.then(() => {
+  await MonomerLibHelper.instance.loadLibraries(); // from initBio()
+  // });
+  // await loadLibrariesPromise;
+  const monomerLib = MonomerLibHelper.instance.getBioLib();
+  const monomers: string[] = [];
+  const logPs: number[] = [];
   const module = await grok.functions.call('Chem:getRdKitModule');
 
-
   const series = monomerLib!.getMonomerMolsByType('PEPTIDE')!;
-  Object.keys(series).forEach(symbol => {
+  Object.keys(series).forEach((symbol) => {
     monomers.push(symbol);
     const block = series[symbol].replaceAll('#R', 'O ');
     const mol = module.get_mol(block);
@@ -88,38 +99,34 @@ export async function initBio() {
   const sum = logPs.reduce((a, b) => a + b, 0);
   const avg = (sum / logPs.length) || 0;
 
-  let palette: { [monomer: string]: string } = {};
-  for (let i = 0; i < monomers.length; i++) {
+  const palette: { [monomer: string]: string } = {};
+  for (let i = 0; i < monomers.length; i++)
     palette[monomers[i]] = logPs[i] < avg ? '#4682B4' : '#DC143C';
-  }
 
   hydrophobPalette = new SeqPaletteCustom(palette);
 }
 
-async function loadLibraries() {
-  //TODO handle if files are in place
-
-  let uploadedLibraries: string[] = Object.values(await grok.dapi.userDataStorage.get(STORAGE_NAME, true));
-  if (uploadedLibraries.length == 0 && monomerLib == null)
-    monomerLib = new MonomerLib({});
-  for (let i = 0; i < uploadedLibraries.length; ++i)
-    await monomerManager(uploadedLibraries[i]);
-}
-
-//name: monomerManager
-//input: string value
-export async function monomerManager(value: string) {
-  if (monomerLib == null)
-    monomerLib = await readLibrary(LIB_PATH, value);
-  else {
-    monomerLib!.update(await readLibrary(LIB_PATH, value));
-  }
+//name: sequenceTooltip
+//tags: tooltip
+//input: column col {semType: Macromolecule}
+//output: widget result
+export async function sequenceTooltip(col: DG.Column): Promise<DG.Widget<any>> {
+  const tv = grok.shell.tv;
+  const viewer = await tv.dataFrame.plot.fromType('WebLogo', {
+    sequenceColumnName: col.name,
+    backgroundColor: 0xFFfdffe5,
+    fitArea: false,
+    positionHeight: 'Entropy',
+    fixWidth: true
+  });
+  viewer.root.style.height = '50px';
+  return viewer;
 }
 
 //name: getBioLib
 //output: object monomerLib
-export function getBioLib(): IMonomerLib | null {
-  return monomerLib;
+export function getBioLib(): IMonomerLib {
+  return MonomerLibHelper.instance.getBioLib();
 }
 
 //name: manageFiles
@@ -132,30 +139,38 @@ export async function manageFiles() {
 }
 
 //name: Manage Libraries
-//tags: panel, widgets
 //input: column seqColumn {semType: Macromolecule}
+//tags: panel, exclude-actions-panel
 //output: widget result
 export async function libraryPanel(seqColumn: DG.Column): Promise<DG.Widget> {
   //@ts-ignore
-  let filesButton: HTMLButtonElement = ui.button('Manage', manageFiles);
-  let divInputs: HTMLDivElement = ui.div();
-  let librariesList: string[] = (await _package.files.list(`${LIBS_PATH}`, false, '')).map(it => it.fileName);
-  let uploadedLibraries: string[] = Object.values(await grok.dapi.userDataStorage.get(STORAGE_NAME, true));
-  for (let i = 0; i < uploadedLibraries.length; ++i) {
-    let libraryName: string = uploadedLibraries[i];
-    divInputs.append(ui.boolInput(libraryName, true, async () => {
-      grok.dapi.userDataStorage.remove(STORAGE_NAME, libraryName, true);
-      await loadLibraries();
-    }).root);
-  }
-  let unusedLibraries: string[] = librariesList.filter(x => !uploadedLibraries.includes(x));
-  for (let i = 0; i < unusedLibraries.length; ++i) {
-    let libraryName: string = unusedLibraries[i];
-    divInputs.append(ui.boolInput(libraryName, false, () => {
-      monomerManager(libraryName);
-      grok.dapi.userDataStorage.postValue(STORAGE_NAME, libraryName, libraryName, true);
-    }).root);
+  const filesButton: HTMLButtonElement = ui.button('Manage', manageFiles);
+  const divInputs: HTMLDivElement = ui.div();
+  const libFileNameList: string[] = (await grok.dapi.files.list(`${LIB_PATH}`, false, ''))
+    .map((it) => it.fileName);
+  const librariesUserSettingsSet: Set<string> = new Set<string>(Object.keys(
+    await grok.dapi.userDataStorage.get(LIB_STORAGE_NAME, true)));
+
+  let userStoragePromise: Promise<void> = Promise.resolve();
+  for (const libFileName of libFileNameList) {
+    const libInput: DG.InputBase<boolean | null> = ui.boolInput(libFileName, librariesUserSettingsSet.has(libFileName),
+      () => {
+        userStoragePromise = userStoragePromise.then(async () => {
+          if (libInput.value == true) {
+            // Save checked library to user settings 'Libraries'
+            await grok.dapi.userDataStorage.postValue(LIB_STORAGE_NAME, libFileName, libFileName, true);
+            await MonomerLibHelper.instance.loadLibraries(); // from libraryPanel()
+          } else {
+            // Remove unchecked library from user settings 'Libraries'
+            await grok.dapi.userDataStorage.remove(LIB_STORAGE_NAME, libFileName, true);
+            await MonomerLibHelper.instance.loadLibraries(true); // from libraryPanel()
+          }
+          grok.shell.info('Monomer library user settings saved.');
+        });
+      });
+    divInputs.append(libInput.root);
   }
+
   return new DG.Widget(ui.splitV([
     divInputs,
     ui.divV([filesButton])
@@ -198,11 +213,10 @@ export function macromoleculeDifferenceCellRenderer(): MacromoleculeDifferenceCe
 }
 
 
-function checkInputColumnUi(
-  col: DG.Column, name: string, allowedNotations: string[] = [], allowedAlphabets: string[] = []
-): boolean {
+function checkInputColumnUi(col: DG.Column, name: string, allowedNotations: string[] = [],
+  allowedAlphabets: string[] = [], notify: boolean = true): boolean {
   const [res, msg]: [boolean, string] = checkInputColumn(col, name, allowedNotations, allowedAlphabets);
-  if (!res)
+  if (notify && !res)
     grok.shell.warning(msg);
   return res;
 }
@@ -259,9 +273,10 @@ export function sequenceAlignment(alignType: string, alignTable: string, gap: nu
 }
 
 //name: WebLogo
-//description: WebLogo viewer
+//description: WebLogo
 //tags: viewer, panel
 //output: viewer result
+//meta.icon: files/icons/weblogo-viewer.svg
 export function webLogoViewer() {
   return new WebLogoViewer();
 }
@@ -269,32 +284,47 @@ export function webLogoViewer() {
 //name: VdRegions
 //description: V-Domain regions viewer
 //tags: viewer, panel
+//meta.icon: files/icons/vdregions-viewer.svg
 //output: viewer result
 export function vdRegionViewer() {
   return new VdRegionsViewer();
 }
 
+//name: SeqActivityCliffsEditor
+//tags: editor
+//input: funccall call
+export function SeqActivityCliffsEditor(call: DG.FuncCall) {
+  const funcEditor = new ActivityCliffsFunctionEditor(DG.SEMTYPE.MACROMOLECULE);
+  ui.dialog({title: 'Activity Cliffs'})
+    .add(funcEditor.paramsUI)
+    .onOK(async () => {
+      call.func.prepare(funcEditor.funcParams).call(true);
+    })
+    .show();
+}
+
 //top-menu: Bio | Sequence Activity Cliffs...
 //name: Sequence Activity Cliffs
 //description: detect activity cliffs
 //input: dataframe table [Input data table]
-//input: column macroMolecule {semType: Macromolecule}
+//input: column molecules {semType: Macromolecule}
 //input: column activities
 //input: double similarity = 80 [Similarity cutoff]
-//input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
+//input: string methodName { choices:["UMAP", "t-SNE"] }
+//input: object options {optional: true}
+//output: viewer result
+//editor: Bio:SeqActivityCliffsEditor
 export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column, activities: DG.Column,
-  similarity: number, methodName: string): Promise<DG.Viewer | undefined> {
+  similarity: number, methodName: string, options?: IUMAPOptions | ITSNEOptions
+): Promise<DG.Viewer | undefined> {
   if (!checkInputColumnUi(macroMolecule, 'Activity Cliffs'))
     return;
   const axesNames = getEmbeddingColsNames(df);
-  const options = {
-    'SPE': {cycles: 2000, lambda: 1.0, dlambda: 0.0005},
-  };
   const tags = {
     'units': macroMolecule.getTag(DG.TAGS.UNITS),
-    'aligned': macroMolecule.getTag(bio_TAGS.aligned),
-    'separator': macroMolecule.getTag(bio_TAGS.separator),
-    'alphabet': macroMolecule.getTag(bio_TAGS.alphabet),
+    'aligned': macroMolecule.getTag(bioTAGS.aligned),
+    'separator': macroMolecule.getTag(bioTAGS.separator),
+    'alphabet': macroMolecule.getTag(bioTAGS.alphabet),
   };
   const sp = await getActivityCliffs(
     df,
@@ -309,24 +339,40 @@ export async function activityCliffs(df: DG.DataFrame, macroMolecule: DG.Column,
     DG.SEMTYPE.MACROMOLECULE,
     tags,
     sequenceSpaceByFingerprints,
-    getChemSimilaritiesMarix,
+    getChemSimilaritiesMatrix,
     createTooltipElement,
     createPropPanelElement,
     createLinesGrid,
-    (options as any)[methodName]);
+    options);
   return sp;
 }
 
+//name: SequenceSpaceEditor
+//tags: editor
+//input: funccall call
+export function SequenceSpaceEditor(call: DG.FuncCall) {
+  const funcEditor = new SequenceSpaceFunctionEditor(DG.SEMTYPE.MACROMOLECULE);
+  ui.dialog({title: 'Sequence Space'})
+    .add(funcEditor.paramsUI)
+    .onOK(async () => {
+      call.func.prepare(funcEditor.funcParams).call(true);
+    })
+    .show();
+}
+
 //top-menu: Bio | Sequence Space...
 //name: Sequence Space
 //input: dataframe table
-//input: column macroMolecule { semType: Macromolecule }
-//input: string methodName { choices:["UMAP", "t-SNE", "SPE"] }
+//input: column molecules { semType: Macromolecule }
+//input: string methodName { choices:["UMAP", "t-SNE"] }
 //input: string similarityMetric { choices:["Tanimoto", "Asymmetric", "Cosine", "Sokal"] }
 //input: bool plotEmbeddings = true
+//input: object options {optional: true}
+//editor: Bio:SequenceSpaceEditor
 export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: DG.Column, methodName: string,
-  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean): Promise<DG.Viewer | undefined> {
-  //delay is required for initial function dialog to close before starting invalidating of molfiles. Otherwise dialog is freezing
+  similarityMetric: string = 'Tanimoto', plotEmbeddings: boolean, options?: IUMAPOptions | ITSNEOptions): Promise<DG.Viewer | undefined> {
+  // Delay is required for initial function dialog to close before starting invalidating of molfiles.
+  // Otherwise, dialog is freezing
   await delay(10);
   if (!checkInputColumnUi(macroMolecule, 'Sequence space'))
     return;
@@ -339,21 +385,21 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, macroMolecule: D
     seqCol: withoutEmptyValues.col(macroMolecule.name)!,
     methodName: methodName,
     similarityMetric: similarityMetric,
-    embedAxesNames: embedColsNames
+    embedAxesNames: embedColsNames,
+    options: options
   };
   const sequenceSpaceRes = await sequenceSpaceByFingerprints(chemSpaceParams);
   const embeddings = sequenceSpaceRes.coordinates;
   for (const col of embeddings) {
     const listValues = col.toList();
     emptyValsIdxs.forEach((ind: number) => listValues.splice(ind, 0, null));
-    table.columns.add(DG.Column.fromList('double', col.name, listValues));
+    table.columns.add(DG.Column.float(col.name, table.rowCount).init((i) => listValues[i]));
   }
   if (plotEmbeddings) {
     return grok.shell
       .tableView(table.name)
       .scatterPlot({x: embedColsNames[0], y: embedColsNames[1], title: 'Sequence space'});
   }
-  ;
 
   /*   const encodedCol = encodeMonomers(macroMolecule);
   if (!encodedCol)
@@ -402,38 +448,76 @@ export async function toAtomicLevel(df: DG.DataFrame, macroMolecule: DG.Column):
 }
 
 //top-menu: Bio | MSA...
-//name: MSA
-//input: dataframe table
-//input: column sequence { semType: Macromolecule, units: ['fasta'], alphabet: ['DNA', 'RNA', 'PT'] }
-//output: column result
-export async function multipleSequenceAlignmentAny(table: DG.DataFrame, sequence: DG.Column): Promise<DG.Column | null> {
-  const func: DG.Func = DG.Func.find({package: 'Bio', name: 'multipleSequenceAlignmentAny'})[0];
-
-  if (!checkInputColumnUi(sequence, 'MSA', ['fasta'], ['DNA', 'RNA', 'PT']))
-    return null;
-
-  const unUsedName = table.columns.getUnusedName(`msa(${sequence.name})`);
-  const msaCol = await runKalign(sequence, false, unUsedName);
-  table.columns.add(msaCol);
-
-  // This call is required to enable cell renderer activation
-  await grok.data.detectSemanticTypes(table);
-
-  // const tv: DG.TableView = grok.shell.tv;
-  // tv.grid.invalidate();
-  return msaCol;
-}
-
-//name: Bio | MSA
+//name: MSA...
 //tags: bio, panel
-//input: column sequence { semType: Macromolecule }
-//output: column result
-export async function panelMSA(sequence: DG.Column): Promise<DG.Column | null> {
-  return multipleSequenceAlignmentAny(sequence.dataFrame, sequence);
+export function multipleSequenceAlignmentAny(col: DG.Column<string> | null = null): void {
+  const table = col?.dataFrame ?? grok.shell.t;
+  const seqCol = col ?? table.columns.bySemType(DG.SEMTYPE.MACROMOLECULE);
+  if (seqCol == null) {
+    grok.shell.warning(`MSAError: dataset doesn't conain any Macromolecule column`);
+    return;
+  }
+
+  let performAlignment: () => Promise<DG.Column<string> | null> = async () => null;
+  const methodInput = ui.choiceInput('Method', pepseaMethods[0], pepseaMethods);
+  methodInput.setTooltip('Alignment method');
+  const gapOpenInput = ui.floatInput('Gap open', 1.53);
+  gapOpenInput.setTooltip('Gap opening penalty at group-to-group alignment');
+  const gapExtendInput = ui.floatInput('Gap extend', 0);
+  gapExtendInput.setTooltip('Gap extension penalty to skip the alignment');
+  const inputRootStyles = [methodInput.root.style, gapOpenInput.root.style, gapExtendInput.root.style];
+
+  const colInput = ui.columnInput('Sequence', table, seqCol, () => {
+    const potentialCol = colInput.value;
+    const unusedName = table.columns.getUnusedName(`msa(${potentialCol.name})`);
+
+    if (checkInputColumnUi(
+      potentialCol, potentialCol.name, [NOTATION.FASTA], [ALPHABET.DNA, ALPHABET.RNA, ALPHABET.PT], false)) {
+      for (const inputRootStyle of inputRootStyles)
+        inputRootStyle.display = 'none';
+
+      performAlignment = () => runKalign(potentialCol, false, unusedName, clustersColInput.value);
+    } else if (checkInputColumnUi(potentialCol, potentialCol.name, [NOTATION.HELM], [], false)) {
+      for (const inputRootStyle of inputRootStyles)
+        inputRootStyle.display = 'initial';
+
+      performAlignment = () => runPepsea(potentialCol, unusedName, methodInput.value!, gapOpenInput.value!,
+        gapExtendInput.value!, clustersColInput.value);
+    } else {
+      for (const inputRootStyle of inputRootStyles)
+        inputRootStyle.display = 'none';
+
+      performAlignment = async () => null;
+    }
+  }) as DG.InputBase<DG.Column<string>>;
+  colInput.setTooltip('Sequences column to use for alignment');
+  colInput.fireChanged();
+
+  const clustersColInput = ui.columnInput('Clusters', table, null);
+  clustersColInput.nullable = true;
+
+  let msaCol: DG.Column<string> | null = null;
+  ui.dialog('MSA')
+    .add(colInput)
+    .add(clustersColInput)
+    .add(methodInput)
+    .add(gapOpenInput)
+    .add(gapExtendInput)
+    .onOK(async () => {
+      colInput.fireChanged();
+      msaCol = await performAlignment();
+      if (msaCol == null)
+        return grok.shell.warning('Wrong column format');
+
+      table.columns.add(msaCol);
+      await grok.data.detectSemanticTypes(table);
+    })
+    .show();
 }
 
 //name: Composition Analysis
 //top-menu: Bio | Composition Analysis
+//meta.icon: files/icons/composition-analysis.svg
 //output: viewer result
 export async function compositionAnalysis(): Promise<void> {
   // Higher priority for columns with MSA data to show with WebLogo.
@@ -490,8 +574,8 @@ export async function compositionAnalysis(): Promise<void> {
   await handler(col);
 }
 
-//top-menu: Bio | Sdf to Json lib...
-//name: sdfToJsonLib
+//top-menu: Bio | SDF to JSON lib...
+//name: SDF to JSON Lib
 //input: dataframe table
 export async function sdfToJsonLib(table: DG.DataFrame) {
   const jsonMonomerLibrary = createJsonMonomerLibFromSdf(table);
@@ -519,11 +603,10 @@ export function importFasta(fileContent: string): DG.DataFrame [] {
   return ffh.importFasta();
 }
 
-//name: Bio | Convert ...
-//friendly-name: Bio | Convert
-//tags: panel, bio
-//input: column col {semType: Macromolecule}
-export function convertPanel(col: DG.Column): void {
+//top-menu: Bio | Convert...
+//name: convertDialog
+export function convertDialog() {
+  const col = getMacromoleculeColumn();
   convert(col);
 }
 
@@ -586,17 +669,17 @@ export async function testDetectMacromolecule(path: string): Promise<DG.DataFram
   return resDf;
 }
 
-//name: Bio | Split to monomers
-//tags: panel, bio
-//input: column col {semType: Macromolecule}
-export function splitToMonomers(col: DG.Column<string>): void {
+//top-menu: Bio | Split to monomers
+//name: splitToMonomers
+export function splitToMonomers(): void {
+  const col = getMacromoleculeColumn();
   const tempDf = splitAlignedSequences(col);
   const originalDf = col.dataFrame;
   for (const tempCol of tempDf.columns) {
     const newCol = originalDf.columns.add(tempCol);
     newCol.semType = C.SEM_TYPES.MONOMER;
     newCol.setTag(DG.TAGS.CELL_RENDERER, C.SEM_TYPES.MONOMER);
-    newCol.setTag(C.TAGS.ALPHABET, col.getTag(C.TAGS.ALPHABET));
+    newCol.setTag(bioTAGS.alphabet, col.getTag(bioTAGS.alphabet));
   }
   grok.shell.tv.grid.invalidate();
 }
@@ -609,44 +692,46 @@ export function getHelmMonomers(sequence: DG.Column<string>): string[] {
 }
 
 
-//name: SequenceSimilaritySearchViewer
+//name: Sequence Similarity Search
 //tags: viewer
+//meta.icon: files/icons/sequence-similarity-viewer.svg
 //output: viewer result
 export function similaritySearchViewer(): SequenceSimilarityViewer {
   return new SequenceSimilarityViewer();
 }
 
-//top-menu: Bio | Similarity Search...
+//top-menu: Bio | Search | Similarity Search
 //name: similaritySearch
 //description: finds the most similar sequence
 //output: viewer result
 export function similaritySearchTopMenu(): void {
   const view = (grok.shell.v as DG.TableView);
-  const viewer = view.addViewer('SequenceSimilaritySearchViewer');
+  const viewer = view.addViewer('Sequence Similarity Search');
   view.dockManager.dock(viewer, 'down');
 }
 
-//name: SequenceDiversitySearchViewer
+//name: Sequence Diversity Search
 //tags: viewer
+//meta.icon: files/icons/sequence-diversity-viewer.svg
 //output: viewer result
 export function diversitySearchViewer(): SequenceDiversityViewer {
   return new SequenceDiversityViewer();
 }
 
-//top-menu: Bio | Diversity Search...
+//top-menu: Bio | Search | Diversity Search
 //name: diversitySearch
 //description: finds the most diverse molecules
 //output: viewer result
 export function diversitySearchTopMenu() {
   const view = (grok.shell.v as DG.TableView);
-  const viewer = view.addViewer('SequenceDiversitySearchViewer');
+  const viewer = view.addViewer('Sequence Diversity Search');
   view.dockManager.dock(viewer, 'down');
 }
 
-//name: Bio | Substructure search ...
-//tags: panel, bio
-//input: column col {semType: Macromolecule}
-export function bioSubstructureSearch(col: DG.Column): void {
+//top-menu: Bio | Substructure Search ...
+//name: bioSubstructureSearch
+export function bioSubstructureSearch(): void {
+  const col = getMacromoleculeColumn();
   substructureSearchDialog(col);
 }