@datagrok/peptides 0.0.1 → 0.4.2

package/.eslintrc.json

@@ -26,4 +26,4 @@
     "spaced-comment": "off",
     "require-jsdoc": "off"
   }
-}
+}

package/detectors.js

@@ -3,7 +3,7 @@ class PeptidesPackageDetectors extends DG.Package {
   //input: column col
   //output: string semType
   detectAligned(col) {
-    const regexp = new RegExp('^((.+)?-){5,49}(\\w|\\(|\\))+$');
-    return DG.Detector.sampleCategories(col, (s) => s.length < 1000 && regexp.test(s)) ? 'alignedSequence' : null;
+    const regexp = new RegExp(/^([^-^\n]*-){2,49}(\w|\(|\))+$/);
+    return DG.Detector.sampleCategories(col, (s) => regexp.test(s.trim())) ? 'alignedSequence' : null;
   }
 }

package/package.json

@@ -1,27 +1,30 @@
 {
 	"name": "@datagrok/peptides",
-	"friendlyName": "Peptides",
-	"version": "0.0.1",
+	"version": "0.4.2",
 	"description": "",
 	"dependencies": {
+		"@keckelt/tsne": "^1.0.2",
 		"cash-dom": "latest",
 		"d3": "latest",
-		"datagrok-api": "../../js-api",
+		"datagrok-api": ">=0.95.11",
 		"dayjs": "latest",
+		"jaro-winkler-typescript": "^1.0.1",
 		"jstat": "^1.9.5",
 		"logojs-react": "^2.1.1",
-		"rxjs": "^7.3.1",
-		"ts-loader": "^9.2.5"
+		"rxjs": "^6.5.5",
+		"umap-js": "^1.3.3",
+		"@datagrok-libraries/utils": ">=0.0.11",
+		"@datagrok-libraries/statistics": ">=0.1.5",
+		"@types/d3": "^7.0.0",
+		"@types/jquery": "^3.5.6"
 	},
 	"devDependencies": {
-		"@types/d3": "^7.0.0",
-		"@types/jquery": "^3.5.6",
+		"typescript": "^4.4.4",
+		"ts-loader": "^9.2.5",
 		"@typescript-eslint/eslint-plugin": "^4.29.1",
 		"@typescript-eslint/parser": "^4.29.1",
 		"eslint": "^7.32.0",
 		"eslint-config-google": "^0.14.0",
-		"ts-loader": "^9.2.5",
-		"typescript": "^4.4.3",
 		"webpack": "latest",
 		"webpack-cli": "latest"
 	},
@@ -31,6 +34,10 @@
 		"common/ngl_viewer/ngl.js"
 	],
 	"scripts": {
+		"link-utils": "npm link @datagrok-libraries/utils",
+		"link-statistics": "npm link @datagrok-libraries/statistics",
+		"link-api": "npm link datagrok-api",
+		"link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/statistics",
 		"install-dependencies": "npm install",
 		"debug-peptides": "grok publish --rebuild",
 		"release-peptides": "grok publish --rebuild --release",
@@ -42,7 +49,7 @@
 		"release-peptides-public": "grok publish public --rebuild --release",
 		"debug-peptides-local": "grok publish local --rebuild",
 		"release-peptides-local": "grok publish local --rebuild --release",
-		"lint": "eslint './src/**/*.ts'",
-		"lint-fix": "eslint ./src/*.ts --fix"
+		"lint": "eslint \"./src/**/*.ts\"",
+		"lint-fix": "eslint \"./src/**/*.ts\" --fix"
 	}
-}
+}

package/scripts/smiles-to-3D.py

@@ -0,0 +1,13 @@
+#name: smiTo3D
+#language: python
+#input: string smiles
+#output: string sdf
+
+from rdkit.Chem import AllChem
+from rdkit import Chem
+
+mol = AllChem.MolFromSmiles(smiles)
+AllChem.EmbedMolecule(mol, AllChem.ETKDG())
+#AllChem.UFFOptimizeMolecule(mol)
+#mol = Chem.RemoveHs(mol)
+sdf = Chem.MolToMolBlock(mol)

package/src/{peptide-sar-viewer/describe.ts → describe.ts}

@@ -1,13 +1,52 @@
+// eslint-disable-next-line no-unused-vars
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
-import {splitAlignedPeptides} from '../split-aligned';
-import {tTest} from '../utils/misc';
-import {ChemPalette} from '../utils/chem-palette';
-import {setAARRenderer} from '../utils/cell-renderer';
+import {splitAlignedPeptides} from './utils/split-aligned';
+import {tTest} from '@datagrok-libraries/statistics/src/tests';
+import {fdrcorrection} from '@datagrok-libraries/statistics/src/multiple-tests';
+import {ChemPalette} from './utils/chem-palette';
+import {setAARRenderer} from './utils/cell-renderer';
 
 const cp = new ChemPalette('grok');
 
+const aarGroups = {
+  'R': 'PC',
+  'H': 'PC',
+  'K': 'PC',
+  'D': 'NC',
+  'E': 'NC',
+  'S': 'U',
+  'T': 'U',
+  'N': 'U',
+  'Q': 'U',
+  'C': 'SC',
+  'U': 'SC',
+  'G': 'SC',
+  'P': 'SC',
+  'A': 'H',
+  'V': 'H',
+  'I': 'H',
+  'L': 'H',
+  'M': 'H',
+  'F': 'H',
+  'Y': 'H',
+  'W': 'H',
+  '-': '-',
+};
+
+const groupDescription: {[key: string]: {'description': string, 'aminoAcids': string[]}} = {
+  'PC': {'description': 'Positive Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['R', 'H', 'K']},
+  'NC': {'description': 'Negative Amino Acids, with Electrically Charged Side Chains', 'aminoAcids': ['D', 'E']},
+  'U': {'description': 'Amino Acids with Polar Uncharged Side Chains', 'aminoAcids': ['S', 'T', 'N', 'Q']},
+  'SC': {'description': 'Special Cases', 'aminoAcids': ['C', 'U', 'G', 'P']},
+  'H': {
+    'description': 'Amino Acids with Hydrophobic Side Chain',
+    'aminoAcids': ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W'],
+  },
+  '-': {'description': 'Unknown Amino Acid', 'aminoAcids': ['-']},
+};
+
 export async function describe(
   df: DG.DataFrame,
   activityColumn: string,
@@ -15,19 +54,14 @@ export async function describe(
   sourceGrid: DG.Grid,
   twoColorMode: boolean,
   initialBitset: DG.BitSet | null,
-): Promise<[DG.Grid, DG.Grid, DG.DataFrame] | [null, null, null]> {
+  grouping: boolean,
+): Promise<[DG.Grid, DG.Grid, DG.DataFrame, {[key: string]: string}]> {
   //Split the aligned sequence into separate AARs
   let splitSeqDf: DG.DataFrame | undefined;
+  let invalidIndexes: number[];
   const col: DG.Column = df.columns.bySemType('alignedSequence');
-  if (col) {
-    splitSeqDf = splitAlignedPeptides(col);
-    splitSeqDf.name = 'Split sequence';
-  }
-
-  if (typeof splitSeqDf === 'undefined') {
-    return [null, null, null];
-  }
-
+  [splitSeqDf, invalidIndexes] = splitAlignedPeptides(col);
+  splitSeqDf.name = 'Split sequence';
   const positionColumns = splitSeqDf.columns.names();
   const activityColumnScaled = `${activityColumn}Scaled`;
   const renderColNames: string[] = splitSeqDf.columns.names();
@@ -54,6 +88,7 @@ export async function describe(
       setAARRenderer(col, sourceGrid);
     }
   }
+
   if (sourceGrid) {
     const colNames:string[] = [];
     for (let i = 0; i < sourceGrid.columns.length; i++) {
@@ -109,6 +144,17 @@ export async function describe(
 
   let matrixDf = splitSeqDf.unpivot([activityColumnScaled], positionColumns, positionColName, aminoAcidResidue);
 
+  //TODO: move to chem palette
+  let groupMapping: {[key: string]: string} = {};
+  if (grouping) {
+    groupMapping = aarGroups;
+    const aarCol = matrixDf.getCol(aminoAcidResidue);
+    aarCol.init((index) => groupMapping[aarCol.get(index)[0]] ?? '-');
+    aarCol.compact();
+  } else {
+    Object.keys(aarGroups).forEach((value) => groupMapping[value] = value);
+  }
+
   //statistics for specific AAR at a specific position
   matrixDf = matrixDf.groupBy([positionColName, aminoAcidResidue])
     .add('count', activityColumnScaled, 'Count')
@@ -129,6 +175,8 @@ export async function describe(
   let otherActivity: number[];
   let testResult;
   let currentMeanDiff: number;
+  let pvalues: Float32Array = new Float32Array(matrixDf.rowCount).fill(1);
+  let pvalue = 1.;
 
   const mdCol: DG.Column = matrixDf.columns.addNewFloat('Mean difference');
   const pValCol: DG.Column = matrixDf.columns.addNewFloat('pValue');
@@ -137,14 +185,14 @@ export async function describe(
     AAR = matrixDf.get(aminoAcidResidue, i);
 
     //@ts-ignore
-    splitSeqDf.rows.select((row) => row[position] === AAR);
+    splitSeqDf.rows.select((row) => groupMapping[row[position]] === AAR);
     currentActivity = splitSeqDf
       .clone(splitSeqDf.selection, [activityColumnScaled])
       .getCol(activityColumnScaled)
       .toList();
 
     //@ts-ignore
-    splitSeqDf.rows.select((row) => row[position] !== AAR);
+    splitSeqDf.rows.select((row) => groupMapping[row[position]] !== AAR);
     otherActivity = splitSeqDf
       .clone(splitSeqDf.selection, [activityColumnScaled])
       .getCol(activityColumnScaled)
@@ -153,9 +201,18 @@ export async function describe(
     testResult = tTest(currentActivity, otherActivity);
     // testResult = uTest(currentActivity, otherActivity);
     currentMeanDiff = testResult['Mean difference']!;
+    pvalue = testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'];
 
     mdCol.set(i, currentMeanDiff);
-    pValCol.set(i, testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less']);
+    pvalues[i] = pvalue;
+  }
+
+  if (true) {
+    pvalues = fdrcorrection(pvalues)[1];
+  }
+
+  for (let i = 0; i < pvalues.length; ++i) {
+    pValCol.set(i, pvalues[i]);
   }
 
   const statsDf = matrixDf.clone();
@@ -217,17 +274,14 @@ export async function describe(
   SARVgrid.col('pValue')!.format = 'four digits after comma';
   SARVgrid.col('pValue')!.name = 'P-Value';
 
-  //FIXME: looks inefficient
-  for (const col of matrixDf.columns) {
-    if (col.name === aminoAcidResidue) {
-      setAARRenderer(col, SARgrid);
-      break;
+  if (!grouping) {
+    let tempCol = matrixDf.columns.byName(aminoAcidResidue);
+    if (tempCol) {
+      setAARRenderer(tempCol, SARgrid);
     }
-  }
-  for (const col of sequenceDf.columns) {
-    if (col.name === aminoAcidResidue) {
-      setAARRenderer(col, SARVgrid);
-      break;
+    tempCol = sequenceDf.columns.byName(aminoAcidResidue);
+    if (tempCol) {
+      setAARRenderer(tempCol, SARgrid);
     }
   }
 
@@ -336,7 +390,6 @@ export async function describe(
           const textNum = statsDf.groupBy([col]).where(query).aggregate().get(col, 0);
           let text = `${col === 'Count' ? textNum : textNum.toFixed(5)}`;
 
-          //@ts-ignore: I'm sure it's gonna be fine, text contains a number
           if (col === 'Count') {
             text += ` / ${peptidesCount}`;
           } else if (col === 'pValue') {
@@ -351,66 +404,39 @@ export async function describe(
     }
     if (
       !cell.isColHeader &&
-        cell.tableColumn !== null &&
-        cell.tableColumn.name == aminoAcidResidue &&
-        cell.cell.value !== null &&
-        cell.tableRowIndex !== null
+      cell.tableColumn !== null &&
+      cell.tableColumn.name == aminoAcidResidue &&
+      cell.cell.value !== null &&
+      cell.tableRowIndex !== null
     ) {
-      cp.showTooltip(cell, x, y);
+      if (grouping) {
+        const currentGroup = groupDescription[cell.cell.value];
+        const divText = ui.divText('Amino Acids in this group: ' + currentGroup['aminoAcids'].join(', '));
+        ui.tooltip.show(ui.divV([ui.h3(currentGroup['description']), divText]), x, y);
+      } else {
+        cp.showTooltip(cell, x, y);
+      }
     }
     return true;
   };
   SARgrid.onCellTooltip(onCellTooltipFunc);
   SARVgrid.onCellTooltip(onCellTooltipFunc);
 
+  sourceGrid.onCellPrepare((cell) => {
+    const currentRowIndex = cell.tableRowIndex;
+    if (currentRowIndex && invalidIndexes.includes(currentRowIndex) && !cell.isRowHeader) {
+      cell.style.backColor = DG.Color.lightLightGray;
+    }
+  });
+
   for (const col of matrixDf.columns.names()) {
     SARgrid.col(col)!.width = SARgrid.props.rowHeight;
   }
 
-  return [SARgrid, SARVgrid, statsDf];
-}
-
-//Selects best (by mean difference) amino acids in all positions in all categories(p-value)
-function segregateBestAtAllCateg(originalDf: DG.DataFrame, twoColorMode:boolean):DG.DataFrame {
-  //todo: make with group by + refactor
-  const filteredDf = originalDf.clone(DG.BitSet.create(originalDf.rowCount, (i) => {
-    return originalDf.get('Count', i) > 3;
-  }));
-  const pValueFilteredDF = filteredDf.clone(DG.BitSet.create(filteredDf.rowCount, (i) => {
-    return filteredDf.get('pValue', i) >= 0.1 && filteredDf.get('Mean difference', i) > 0;
-  }));
-  let statsDfAgr = grok.data.joinTables(pValueFilteredDF, pValueFilteredDF.groupBy(['Position'])
-    .max('Mean difference')
-    .aggregate(), ['Mean difference', 'Position'],
-  ['max(Mean difference)', 'Position'], pValueFilteredDF.columns.names(), [], 'inner', false);
-  //and 'pValue' > 0.1  'pValue' < ${coef}`
-  let lastCoef = 0.0;
-  [0.01, 0.05, 0.1].forEach((coef)=>{
-    const pValueFilteredDF = filteredDf.clone(DG.BitSet.create(filteredDf.rowCount, (i) => {
-      return filteredDf.get('pValue', i) >= lastCoef &&
-          filteredDf.get('pValue', i)< coef &&
-          (filteredDf.get('Mean difference', i) > 0 || !twoColorMode);
-    }));
-    statsDfAgr = statsDfAgr.append(grok.data.joinTables(pValueFilteredDF, pValueFilteredDF.groupBy(['Position'])
-      .max('Mean difference')
-      .aggregate(), ['Mean difference', 'Position'],
-    ['max(Mean difference)', 'Position'], pValueFilteredDF.columns.names(), [], 'inner', false));
-    lastCoef = coef;
-  });
-  if (twoColorMode) {
-    lastCoef = 0.0;
-    [0.01, 0.05, 0.1, 1.01].forEach((coef) => {
-      const pValueFilteredDF = filteredDf.clone(DG.BitSet.create(filteredDf.rowCount, (i) => {
-        return filteredDf.get('pValue', i) >= lastCoef &&
-            filteredDf.get('pValue', i) < coef &&
-            filteredDf.get('Mean difference', i) <= 0;
-      }));
-      statsDfAgr = statsDfAgr.append(grok.data.joinTables(pValueFilteredDF, pValueFilteredDF.groupBy(['Position'])
-        .min('Mean difference')
-        .aggregate(), ['Mean difference', 'position'],
-      ['min(Mean difference)', 'position'], pValueFilteredDF.columns.names(), [], 'inner', false));
-      lastCoef = coef;
-    });
+  if (grouping) {
+    SARgrid.col(aminoAcidResidue)!.name = 'Groups';
+    SARVgrid.col(aminoAcidResidue)!.name = 'Groups';
   }
-  return statsDfAgr;
+
+  return [SARgrid, SARVgrid, statsDf, groupMapping];
 }

package/src/package.ts

@@ -3,20 +3,25 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {SARViewerBase} from './peptide-sar-viewer/sar-viewer';
 import {
   AlignedSequenceCellRenderer,
   AminoAcidsCellRenderer,
-  expandColumn,
-  processSequence,
 } from './utils/cell-renderer';
-import {Logo} from './peptide-logo-viewer/logo-viewer';
-import {StackedBarChart, addViewerToHeader} from './stacked-barchart/stacked-barchart-viewer';
-import {ChemPalette} from './utils/chem-palette';
-// import { tTest, uTest } from './utils/misc';
+import {Logo} from './viewers/logo-viewer';
+import {StackedBarChart} from './viewers/stacked-barchart-viewer';
+
+import {analyzePeptidesWidget} from './widgets/analyze-peptides';
+import {PeptideSimilaritySpaceWidget} from './utils/peptide-similarity-space';
+import {manualAlignmentWidget} from './widgets/manual-alignment';
+import {SARViewer, SARViewerVertical} from './viewers/sar-viewer';
+import {peptideMoleculeWidget} from './widgets/peptide-molecule';
+import {correlationAnalysisPlots} from './utils/correlation-analysis';
 
 export const _package = new DG.Package();
 let tableGrid: DG.Grid;
+let currentDf: DG.DataFrame;
+let alignedSequenceCol: DG.Column;
+let view: DG.TableView;
 
 async function main(chosenFile: string) {
   const pi = DG.TaskBarProgressIndicator.create('Loading Peptides');
@@ -28,25 +33,24 @@ async function main(chosenFile: string) {
   peptides.setTag('dataType', 'peptides');
   const view = grok.shell.addTableView(peptides);
   tableGrid = view.grid;
-  peptides.onSemanticTypeDetecting.subscribe((_) => {
-    const regexp = new RegExp('^((.+)?-){5,49}(\\w|\\(|\\))+$');
-    for (const col of peptides.columns) {
-      col.semType = DG.Detector.sampleCategories(col, (s) => regexp.test(s)) ? 'alignedSequence' : null;
-      if (col.semType == 'alignedSequence') {
-        expandColumn(col, tableGrid, (ent)=>{
-          const subParts:string[] = ent.split('-');
-          // eslint-disable-next-line no-unused-vars
-          const [text, _] = processSequence(subParts);
-          let textSize = 0;
-          text.forEach((aar)=>{
-            textSize += aar.length;
-          });
-          return textSize;
-        });
-      }
-    }
-  },
-  );
+  // peptides.onSemanticTypeDetecting.subscribe((_: any) => {
+  //   const regexp = new RegExp(/^([^-^\n]*-){2,49}(\w|\(|\))+$/);
+  //   for (const col of peptides.columns) {
+  //     col.semType = DG.Detector.sampleCategories(col, (s: any) => regexp.test(s.trim())) ? 'alignedSequence' : null;
+  //     if (col.semType == 'alignedSequence') {
+  //       expandColumn(col, tableGrid, (ent)=>{
+  //         const subParts:string[] = ent.split('-');
+  //         // eslint-disable-next-line no-unused-vars
+  //         const [text, _] = processSequence(subParts);
+  //         let textSize = 0;
+  //         text.forEach((aar)=>{
+  //           textSize += aar.length;
+  //         });
+  //         return textSize;
+  //       });
+  //     }
+  //   }
+  // });
 
   view.name = 'PeptidesView';
 
@@ -55,7 +59,7 @@ async function main(chosenFile: string) {
   pi.close();
 }
 
-//name: Peptides
+//name: Peptides App
 //tags: app
 export function Peptides() {
   const wikiLink = ui.link('wiki', 'https://github.com/datagrok-ai/public/blob/master/help/domains/bio/peptides.md');
@@ -82,7 +86,6 @@ export function Peptides() {
     'Use and analyse peptide sequence data to support your research:',
   );
 
-
   const annotationViewerDiv = ui.div();
 
   const windows = grok.shell.windows;
@@ -94,7 +97,6 @@ export function Peptides() {
   grok.shell.newView('Peptides', [
     appDescription,
     ui.info([textLink]),
-    //ui.h2('Choose .csv file'),
     ui.div([
       ui.block25([
         ui.button('Open peptide sequences demonstration set', () => main('aligned.csv'), ''),
@@ -110,106 +112,34 @@ export function Peptides() {
 //tags: panel, widgets
 //input: column col {semType: alignedSequence}
 //output: widget result
-export async function analyzePeptides(col: DG.Column): Promise<DG.Widget> {
-  // let defaultColumn: DG.Column | null = col;
-  let tempCol = null;
-  for (const column of col.dataFrame.columns.numerical) {
-    column.type === DG.TYPE.FLOAT ? tempCol = column : null;
-  }
-  const defaultColumn: DG.Column = col.dataFrame.col('activity') || col.dataFrame.col('IC50') || tempCol;
-
-  const activityScalingMethod = ui.choiceInput('Activity scaling', 'none', ['none', 'lg', '-lg']);
-  activityScalingMethod.setTooltip('Function to apply for each value in activity column');
-
-  const activityScalingMethodState = function(_: any) {
-    activityScalingMethod.enabled =
-      activityColumnChoice.value && DG.Stats.fromColumn(activityColumnChoice.value, col.dataFrame.filter).min > 0;
-  };
-  const activityColumnChoice = ui.columnInput(
-    'Activity column',
-    col.dataFrame,
-    defaultColumn,
-    activityScalingMethodState,
-  );
-  activityColumnChoice.fireChanged();
-
-  const startBtn = ui.button('Launch SAR', async () => {
-    if (activityColumnChoice.value.type === DG.TYPE.FLOAT) {
-      const options = {
-        'activityColumnColumnName': activityColumnChoice.value.name,
-        'activityScalingMethod': activityScalingMethod.value,
-      };
-      // @ts-ignore
-      for (let i = 0; i < tableGrid.columns.length; i++) {
-        const col = tableGrid.columns.byIndex(i);
-        if (col &&
-            col.name &&
-            col.name != 'IC50'&&
-            col.column?.semType != 'aminoAcids') {
-          // @ts-ignore
-          tableGrid.columns.byIndex(i)?.visible = false;
-        }
-      }
-
-      //await describe(col.dataFrame, activityColumnChoice.value.name, activityScalingMethod.value, false, tableGrid);
-
-      // @ts-ignore
-
-
-      // const viewer = DG.Viewer.fromType('peptide-sar-viewer', tableGrid.table, options);
-      // (grok.shell.v as DG.TableView).addViewer(viewer);
-      // const refNode = (grok.shell.v as DG.TableView).dockManager.dock(viewer, 'right');
-
-      // const hist = DG.Viewer.fromType('peptide-sar-viewer-vertical', tableGrid.table, options);
-      // (grok.shell.v as DG.TableView).addViewer(hist);
-      // (grok.shell.v as DG.TableView).dockManager.dock(hist, DG.DOCK_TYPE.DOWN, refNode);
-
-      (grok.shell.v as DG.TableView).addViewer('peptide-sar-viewer', options);
-      // (grok.shell.v as DG.TableView).addViewer('peptide-sar-viewer-vertical', options);
-      // @ts-ignore
-      //view.dockManager.dock(ui.divText('bottom'), 'down');
-
-      // @ts-ignore
-      //console.error(sarViewer.view.dockNode);
-
-      const StackedBarchartProm = col.dataFrame.plot.fromType('StackedBarChartAA');
-      addViewerToHeader(tableGrid, StackedBarchartProm);
-
-      // tableGrid.dataFrame!.columns.names().forEach((name:string)=>{
-      //   col = tableGrid.dataFrame!.columns.byName(name);
-      //   if (col.semType == 'aminoAcids') {
-      //     let maxLen = 0;
-      //     col.categories.forEach( (ent:string)=>{
-      //       if ( ent.length> maxLen) {
-      //         maxLen = ent.length;
-      //       }
-      //     });
-      //     tableGrid.columns.byName(name)!.width = maxLen*10;
-      //   }
-      // });
-    } else {
-      grok.shell.error('The activity column must be of floating point number type!');
-    }
-  });
-
-  const viewer = await col.dataFrame.plot.fromType('peptide-logo-viewer');
-
-  return new DG.Widget(ui.divV([viewer.root, ui.inputs([activityColumnChoice, activityScalingMethod]), startBtn]));
+export async function peptidesPanel(col: DG.Column): Promise<DG.Widget> {
+  view = (grok.shell.v as DG.TableView);
+  tableGrid = view.grid;
+  currentDf = col.dataFrame;
+  alignedSequenceCol = col;
+  return await analyzePeptidesWidget(col, view, tableGrid, currentDf);
 }
 
 //name: peptide-sar-viewer
 //description: Peptides SAR Viewer
 //tags: viewer
 //output: viewer result
-export function sar(): SARViewerBase {
-  return new SARViewerBase();
+export function sar(): SARViewer {
+  return new SARViewer();
+}
+
+//name: peptide-sar-viewer-vertical
+//description: Peptides Vertical SAR Viewer
+//tags: viewer
+//output: viewer result
+export function sarVertical(): SARViewerVertical {
+  return new SARViewerVertical();
 }
 
 //name: StackedBarchart Widget
 //tags: panel, widgets
 //input: column col {semType: aminoAcids}
 //output: widget result
-
 export async function stackedBarchartWidget(col: DG.Column): Promise<DG.Widget> {
   const viewer = await col.dataFrame.plot.fromType('StackedBarChartAA');
   const panel = ui.divH([viewer.root]);
@@ -218,30 +148,13 @@ export async function stackedBarchartWidget(col: DG.Column): Promise<DG.Widget>
 
 //name: Peptide Molecule
 //tags: panel, widgets
-//input: string pep {semType: alignedSequence}
+//input: string peptide {semType: alignedSequence}
 //output: widget result
-export async function pepMolGraph(pep: string): Promise<DG.Widget> {
-  const split = pep.split('-');
-  const mols = [];
-  for (let i = 1; i < split.length - 1; i++) {
-    if (split[i] in ChemPalette.AASmiles) {
-      const aar = ChemPalette.AASmiles[split[i]];
-      mols[i] = aar.substr(0, aar.length - 1);
-    } else if (!split[i] || split[i] == '-') {
-      mols[i] = '';
-    } else {
-      return new DG.Widget(ui.divH([]));
-    }
-  }
-  console.error(mols);
-  console.error(mols.join('') + 'COOH');
-  const sketch = grok.chem.svgMol(mols.join('') + 'O');
-  const panel = ui.divH([sketch]);
-  return new DG.Widget(panel);
+export async function peptideMolecule(peptide: string): Promise<DG.Widget> {
+  return await peptideMoleculeWidget(peptide);
 }
 
 //name: StackedBarChartAA
-//description: Creates an awesome viewer
 //tags: viewer
 //output: viewer result
 export function stackedBarChart(): DG.JsViewer {
@@ -270,3 +183,32 @@ export function aminoAcidsCellRenderer() {
 export function logov() {
   return new Logo();
 }
+
+//name: Manual Alignment
+//tags: panel, widgets
+//input: string monomer {semType: aminoAcids}
+//output: widget result
+export function manualAlignment(monomer: string) {
+  return manualAlignmentWidget(alignedSequenceCol, currentDf);
+}
+
+//name: Peptide Space
+//tags: panel, widgets
+//input: column col {semType: alignedSequence}
+//output: widget result
+export async function peptideSpacePanel(col: DG.Column): Promise<DG.Widget> {
+  const widget = new PeptideSimilaritySpaceWidget(col, view ?? grok.shell.v);
+  return await widget.draw();
+}
+
+//name: Correllation analysis
+export async function correlationAnalysis() {
+  view = (grok.shell.v as DG.TableView);
+
+  const df = await grok.data.files.openTable('Demo:TestJobs:Files:DemoFiles/bio/peptides.csv');
+  const tview = grok.shell.addTableView(df);
+  const [cpviewer, bpviewer] = correlationAnalysisPlots(df.getCol('AlignedSequence'));
+
+  tview.dockManager.dock(cpviewer, 'right');
+  tview.dockManager.dock(bpviewer, 'down');
+}