@datagrok/peptides 0.6.1 → 0.8.6

package/.eslintrc.json

@@ -23,7 +23,17 @@
       "error",
       120
     ],
+    "require-jsdoc": "off",
     "spaced-comment": "off",
-    "require-jsdoc": "off"
+    "linebreak-style": "off",
+    "curly": [
+      "error",
+      "multi-or-nest"
+    ],
+    "brace-style": [
+      "error",
+      "1tbs",
+      { "allowSingleLine": true }
+    ]
   }
-}
+}

package/detectors.js

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

package/files/aligned_2.csv

@@ -10272,4 +10272,4 @@ ID,AlignedSequence,Measured,Value
 1357,HOC18gEPEG2PEG2-k(Me3)-Aib-K(PEG2PEG2PgEC18OH)-Hyp-7(4OCF3Ph)W-K(Me)3-S5H(4)-mTyr-6OH2Nal  6OH2Nal-aMeK-S5H-3Pya-H-4diFPro-PEG2PEG2eKC16OH-ON(Me)2A,SGF (No protein present) % Remaining 24 hr,86.31581627936768
 1359,HOC18gEPEG2PEG2-k(Me3)-Aib-K(PEG2PEG2PgEC18OH)-Hyp-7(4OCF3Ph)W-K(Me)3-S5H(4)-mTyr-6OH2Nal  6OH2Nal-aMeK-S5H-3Pya-homobAla-4diFPro-PEG2PEG2eKC16OH-ON(Me)2A,SGF (No protein present) % Remaining 24 hr,93.44441627936769
 1360,HOC18gEPEG2PEG2-k(Me3)-Aib-K(PEG2PEG2PgEC18OH)-Hyp-7(4OCF3Ph)W-K(Me)3-S5H(4)-mTyr-6OH2Nal  6OH2Nal-aMeK-S5H-3Pya-D(NPyr)-4diFPro-PEG2PEG2eKC16OH-ON(Me)2A,SGF (No protein present) % Remaining 24 hr,88.34951627936769
-1361,HOC18gEPEG2PEG2-k(Me3)-Aib-K(PEG2PEG2PgEC18OH)-Hyp-7(4OCF3Ph)W-K(Me)3-S5H(4)-mTyr-6OH2Nal  6OH2Nal-aMeK-S5H-3Pya-3OHPhe-4diFPro-PEG2PEG2eKC16OH-ON(Me)2A,SGF (No protein present) % Remaining 24 hr,98.38061627936769
+1361,HOC18gEPEG2PEG2-k(Me3)-Aib-K(PEG2PEG2PgEC18OH)-Hyp-7(4OCF3Ph)W-K(Me)3-S5H(4)-mTyr-6OH2Nal  6OH2Nal-aMeK-S5H-3Pya-3OHPhe-4diFPro-PEG2PEG2eKC16OH-ON(Me)2A,SGF (No protein present) % Remaining 24 hr,98.38061627936769

package/package.json

@@ -1,32 +1,33 @@
 {
 	"name": "@datagrok/peptides",
-	"version": "0.6.1",
+	"version": "0.8.6",
 	"description": "",
 	"dependencies": {
-		"@keckelt/tsne": "^1.0.2",
+		"@biowasm/aioli": ">=2.4.0",
+		"@datagrok-libraries/bio": ">=0.0.4",
+		"@datagrok-libraries/ml": ">=0.0.10",
+		"@datagrok-libraries/statistics": ">=0.1.5",
+		"@datagrok-libraries/utils": ">=0.0.18",
+		"@types/d3": "^7.0.0",
+		"@types/jquery": "^3.5.6",
 		"cash-dom": "latest",
 		"d3": "latest",
-		"datagrok-api": ">=0.104.0",
+		"datagrok-api": ">=0.115.0",
 		"dayjs": "latest",
-		"jaro-winkler-typescript": "^1.0.1",
+		"file-loader": "^6.2.0",
 		"jstat": "^1.9.5",
 		"logojs-react": "^2.1.1",
-		"rxjs": "^6.5.5",
-		"umap-js": "^1.3.3",
-		"@datagrok-libraries/utils": ">=0.0.13",
-		"@datagrok-libraries/statistics": ">=0.1.5",
-		"@types/d3": "^7.0.0",
-		"@types/jquery": "^3.5.6"
+		"rxjs": "^6.5.5"
 	},
 	"devDependencies": {
-		"typescript": "^4.4.4",
-		"ts-loader": "^9.2.5",
-		"css-loader": "^5.2.4",
-		"style-loader": "^2.0.0",
 		"@typescript-eslint/eslint-plugin": "^4.29.1",
 		"@typescript-eslint/parser": "^4.29.1",
+		"css-loader": "^5.2.4",
 		"eslint": "^7.32.0",
 		"eslint-config-google": "^0.14.0",
+		"style-loader": "^2.0.0",
+		"ts-loader": "^9.2.5",
+		"typescript": "^4.4.4",
 		"webpack": "latest",
 		"webpack-cli": "latest"
 	},
@@ -36,10 +37,12 @@
 		"common/ngl_viewer/ngl.js"
 	],
 	"scripts": {
+		"link-api": "npm link datagrok-api",
 		"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",
+		"link-ml": "npm link @datagrok-libraries/ml",
+		"link-bio": "npm link @datagrok-libraries/bio",
+		"link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/statistics link @datagrok-libraries/ml @datagrok-libraries/bio",
 		"install-dependencies": "npm install",
 		"debug-peptides": "grok publish --rebuild",
 		"release-peptides": "grok publish --rebuild --release",
@@ -53,5 +56,11 @@
 		"release-peptides-local": "grok publish local --rebuild --release",
 		"lint": "eslint \"./src/**/*.ts\"",
 		"lint-fix": "eslint \"./src/**/*.ts\" --fix"
-	}
-}
+	},
+	"canEdit": [
+		"Developers"
+	],
+	"canView": [
+		"All users"
+	]
+}

package/setup.sh

@@ -0,0 +1,15 @@
+npm unlink datagrok-api
+npm unlink @datagrok-libraries/utils
+npm unlink @datagrok-libraries/ml
+cd ../../js-api
+npm install
+npm link
+cd ../libraries/utils
+npm install
+npm link
+cd ../../libraries/ml
+npm install
+npm link datagrok-api @datagrok-libraries/utils
+cd ../../packages/Peptides
+npm install
+npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/ml 

package/src/describe.ts

@@ -53,71 +53,56 @@ const groupDescription: {[key: string]: {'description': string, 'aminoAcids': st
   }
 }*/
 
-//TODO: decomposition!
-export async function describe(
+function joinDataFrames(
+  activityColumnScaled: string,
   df: DG.DataFrame,
+  positionColumns: string[],
+  splitSeqDf: DG.DataFrame,
   activityColumn: string,
-  activityScaling: string,
-  sourceGrid: DG.Grid,
-  twoColorMode: boolean,
-  initialBitset: DG.BitSet | 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');
-  [splitSeqDf, invalidIndexes] = splitAlignedPeptides(col);
-  splitSeqDf.name = 'Split sequence';
+) {
+  if (df.col(activityColumnScaled))
+  (df.columns as DG.ColumnList).remove(activityColumnScaled);
 
-  const positionColumns = splitSeqDf.columns.names();
-  const activityColumnScaled = `${activityColumn}Scaled`;
-  const renderColNames: string[] = splitSeqDf.columns.names();
-
-  splitSeqDf.columns.add(df.getCol(activityColumn));
-
-  if (df.col(activityColumnScaled)) {
-    df.columns.remove(activityColumnScaled);
-  }
 
   //FIXME: this column usually duplicates, so remove it then
-  if (df.col(`${activityColumnScaled} (2)`)) {
-    df.columns.remove(`${activityColumnScaled} (2)`);
-  }
+  if (df.col(`${activityColumnScaled} (2)`))
+    (df.columns as DG.ColumnList).remove(`${activityColumnScaled} (2)`);
+
 
   // append splitSeqDf columns to source table and make sure columns are not added more than once
   const dfColsSet = new Set(df.columns.names());
-  if (!positionColumns.every((col: string) => dfColsSet.has(col))) {
+  if (!positionColumns.every((col: string) => dfColsSet.has(col)))
     df.join(splitSeqDf, [activityColumn], [activityColumn], df.columns.names(), positionColumns, 'inner', true);
-  }
-
-  for (const col of df.columns) {
-    if (splitSeqDf.col(col.name) && col.name != activityColumn) {
-      setAARRenderer(col, sourceGrid);
-    }
-  }
+}
 
+function sortSourceGrid(sourceGrid: DG.Grid) {
   if (sourceGrid) {
-    const colNames:string[] = [];
-    for (let i = 0; i < sourceGrid.columns.length; i++) {
-      colNames.push(sourceGrid.columns.byIndex(i)!.name);
-    }
+    const colNames: DG.GridColumn[] = [];
+    for (let i = 1; i < sourceGrid.columns.length; i++)
+      colNames.push(sourceGrid.columns.byIndex(i)!);
+
     colNames.sort((a, b)=>{
-      if (sourceGrid.columns.byName(a)?.column?.semType == 'aminoAcids') {
-        if (sourceGrid.columns.byName(b)?.column?.semType == 'aminoAcids') {
+      if (a.column!.semType == 'aminoAcids') {
+        if (b.column!.semType == 'aminoAcids')
           return 0;
-        }
         return -1;
       }
-      if (sourceGrid.columns.byName(b)?.column?.semType == 'aminoAcids') {
+      if (b.column!.semType == 'aminoAcids')
         return 1;
-      }
       return 0;
     });
-    sourceGrid?.columns.setOrder(colNames);
+    sourceGrid.columns.setOrder(colNames.map((v) => v.name));
   }
+}
 
-  // scale activity
+async function scaleActivity(
+  activityScaling: string,
+  activityColumn: string,
+  activityColumnScaled: string,
+  sourceGrid: DG.Grid,
+  splitSeqDf: DG.DataFrame,
+) {
+  const df = sourceGrid.dataFrame!;
   switch (activityScaling) {
   case 'lg':
     await df.columns.addNewCalculated(activityColumnScaled, 'Log10(${' + activityColumn + '})');
@@ -138,32 +123,17 @@ export async function describe(
     sourceGrid.columns.setOrder([`${activityColumn}`]);
     break;
   }
-  splitSeqDf = splitSeqDf.clone(initialBitset);
-
-  const positionColName = 'Position';
-  const aminoAcidResidue = 'AAR';
-
-  //unpivot a table and handle duplicates
-  splitSeqDf = splitSeqDf.groupBy(positionColumns)
-    .add('med', activityColumnScaled, activityColumnScaled)
-    .aggregate();
-
-  const peptidesCount = splitSeqDf.getCol(activityColumnScaled).length;
-
-  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
+async function calculateStatistics(
+  matrixDf: DG.DataFrame,
+  positionColName: string,
+  aminoAcidResidue: string,
+  activityColumnScaled: string,
+  peptidesCount: number,
+  splitSeqDf: DG.DataFrame,
+  groupMapping: {[key: string]: string},
+) {
   matrixDf = matrixDf.groupBy([positionColName, aminoAcidResidue])
     .add('count', activityColumnScaled, 'Count')
     .aggregate();
@@ -177,67 +147,54 @@ export async function describe(
   await matrixDf.columns.addNewCalculated('Ratio', '${count}/'.concat(`${peptidesCount}`));
 
   //calculate p-values based on t-test
-  let position: string;
-  let aar: string;
-  let currentActivity: number[];
-  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');
   for (let i = 0; i < matrixDf.rowCount; i++) {
-    position = matrixDf.get(positionColName, i);
-    aar = matrixDf.get(aminoAcidResidue, i);
+    const position = matrixDf.get(positionColName, i);
+    const aar = matrixDf.get(aminoAcidResidue, i);
 
     //@ts-ignore
     splitSeqDf.rows.select((row) => groupMapping[row[position]] === aar);
-    currentActivity = splitSeqDf
+    const currentActivity: number[] = splitSeqDf
       .clone(splitSeqDf.selection, [activityColumnScaled])
       .getCol(activityColumnScaled)
       .toList();
 
     //@ts-ignore
     splitSeqDf.rows.select((row) => groupMapping[row[position]] !== aar);
-    otherActivity = splitSeqDf
+    const otherActivity: number[] = splitSeqDf
       .clone(splitSeqDf.selection, [activityColumnScaled])
       .getCol(activityColumnScaled)
       .toList();
 
-    testResult = tTest(currentActivity, otherActivity);
+    const testResult = tTest(currentActivity, otherActivity);
     // testResult = uTest(currentActivity, otherActivity);
-    currentMeanDiff = testResult['Mean difference']!;
-    pvalue = testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'];
+    const currentMeanDiff = testResult['Mean difference']!;
+    const pvalue = testResult[currentMeanDiff >= 0 ? 'p-value more' : 'p-value less'];
 
     mdCol.set(i, currentMeanDiff);
     pvalues[i] = pvalue;
   }
 
-  if (true) {
+  if (true)
     pvalues = fdrcorrection(pvalues)[1];
-  }
 
-  for (let i = 0; i < pvalues.length; ++i) {
+
+  for (let i = 0; i < pvalues.length; ++i)
     pValCol.set(i, pvalues[i]);
-  }
 
-  const statsDf = matrixDf.clone();
 
-  // SAR matrix table
-  //pivot a table to make it matrix-like
-  matrixDf = matrixDf.groupBy([aminoAcidResidue])
-    .pivot(positionColName)
-    .add('first', 'Mean difference', '')
-    .aggregate();
-  matrixDf.name = 'SAR';
+  return matrixDf.clone();
+}
 
-  // Setting category order
+async function setCategoryOrder(
+  twoColorMode: boolean, statsDf: DG.DataFrame, aminoAcidResidue: string, matrixDf: DG.DataFrame,
+) {
   const sortArgument = twoColorMode ? 'Absolute Mean difference' : 'Mean difference';
-  if (twoColorMode) {
+  if (twoColorMode)
     await statsDf.columns.addNewCalculated('Absolute Mean difference', 'Abs(${Mean difference})');
-  }
+
   const aarWeightsDf = statsDf.groupBy([aminoAcidResidue]).sum(sortArgument, 'weight').aggregate();
   const aarList = aarWeightsDf.getCol(aminoAcidResidue).toList();
   const getWeight = (aar: string) => aarWeightsDf
@@ -248,8 +205,14 @@ export async function describe(
   aarList.sort((first, second) => getWeight(second) - getWeight(first));
 
   matrixDf.getCol(aminoAcidResidue).setCategoryOrder(aarList);
+}
 
-  // SAR vertical table (naive, choose best Mean difference from pVals <= 0.01)
+function createVerticalTable(
+  statsDf: DG.DataFrame,
+  aminoAcidResidue: string,
+  positionColName: string,
+  twoColorMode: boolean,
+) {
   // TODO: aquire ALL of the positions
   let sequenceDf = statsDf.groupBy(['Mean difference', aminoAcidResidue, positionColName, 'Count', 'Ratio', 'pValue'])
     .where('pValue <= 0.1')
@@ -268,9 +231,18 @@ export async function describe(
   sequenceDf = sequenceDf.clone(DG.BitSet.create(sequenceDf.rowCount, (i) => {
     return sequenceDf.get('Mean difference', i) === maxAtPos[sequenceDf.get(positionColName, i)];
   }));
-  renderColNames.push('Mean difference');
 
-  // !!! DRAWING PHASE !!!
+  return sequenceDf;
+}
+
+function createGrids(
+  matrixDf: DG.DataFrame,
+  aminoAcidResidue: string,
+  positionColumns: string[],
+  sequenceDf: DG.DataFrame,
+  positionColName: string,
+  grouping: boolean,
+) {
   const sarGrid = matrixDf.plot.grid();
   sarGrid.sort([aminoAcidResidue]);
   sarGrid.columns.setOrder([aminoAcidResidue].concat(positionColumns));
@@ -282,16 +254,27 @@ export async function describe(
 
   if (!grouping) {
     let tempCol = matrixDf.columns.byName(aminoAcidResidue);
-    if (tempCol) {
+    if (tempCol)
       setAARRenderer(tempCol, sarGrid);
-    }
+
     tempCol = sequenceDf.columns.byName(aminoAcidResidue);
-    if (tempCol) {
+    if (tempCol)
       setAARRenderer(tempCol, sarGrid);
-    }
   }
 
-  //render column headers and AAR symbols centered
+  return [sarGrid, sarVGrid];
+}
+
+function setCellRendererFunc(
+  renderColNames: string[],
+  positionColName: string,
+  aminoAcidResidue: string,
+  statsDf: DG.DataFrame,
+  twoColorMode: boolean,
+  sarGrid: DG.Grid,
+  sarVGrid: DG.Grid,
+) {
+  const mdCol = statsDf.getCol('Mean difference');
   const cellRendererFunc = function(args: DG.GridCellRenderArgs) {
     args.g.save();
     args.g.beginPath();
@@ -321,15 +304,15 @@ export async function describe(
 
         let coef;
         const variant = args.cell.cell.value < 0;
-        if (pVal < 0.01) {
+        if (pVal < 0.01)
           coef = variant && twoColorMode ? '#FF7900' : '#299617';
-        } else if (pVal < 0.05) {
+        else if (pVal < 0.05)
           coef = variant && twoColorMode ? '#FFA500' : '#32CD32';
-        } else if (pVal < 0.1) {
+        else if (pVal < 0.1)
           coef = variant && twoColorMode ? '#FBCEB1' : '#98FF98';
-        } else {
+        else
           coef = DG.Color.toHtml(DG.Color.lightLightGray);
-        }
+
 
         const chooseMin = () => twoColorMode ? 0 : mdCol.min;
         const chooseMax = () => twoColorMode ? Math.max(Math.abs(mdCol.min), mdCol.max) : mdCol.max;
@@ -360,8 +343,18 @@ export async function describe(
   };
   sarGrid.onCellRender.subscribe(cellRendererFunc);
   sarVGrid.onCellRender.subscribe(cellRendererFunc);
+}
 
-  // show all the statistics in a tooltip over cell
+function setTooltipFunc(
+  renderColNames: string[],
+  statsDf: DG.DataFrame,
+  aminoAcidResidue: string,
+  positionColName: string,
+  peptidesCount: number,
+  grouping: boolean,
+  sarGrid: DG.Grid,
+  sarVGrid: DG.Grid,
+) {
   const onCellTooltipFunc = function(cell: DG.GridCell, x: number, y: number) {
     if (
       !cell.isRowHeader &&
@@ -383,11 +376,11 @@ export async function describe(
           const textNum = statsDf.groupBy([col]).where(query).aggregate().get(col, 0);
           let text = `${col === 'Count' ? textNum : textNum.toFixed(5)}`;
 
-          if (col === 'Count') {
+          if (col === 'Count')
             text += ` / ${peptidesCount}`;
-          } else if (col === 'pValue') {
+          else if (col === 'pValue')
             text = parseFloat(text) !== 0 ? text : '<0.01';
-          }
+
 
           tooltipMap[col === 'pValue' ? 'p-value' : col] = text;
         }
@@ -406,25 +399,33 @@ export async function describe(
         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 {
+      } else
         cp.showTooltip(cell, x, y);
-      }
     }
     return true;
   };
   sarGrid.onCellTooltip(onCellTooltipFunc);
   sarVGrid.onCellTooltip(onCellTooltipFunc);
+}
 
+function postProcessGrids(
+  sourceGrid: DG.Grid,
+  invalidIndexes: number[],
+  matrixDf: DG.DataFrame,
+  grouping: boolean,
+  aminoAcidResidue: string,
+  sarGrid: DG.Grid,
+  sarVGrid: DG.Grid,
+) {
   sourceGrid.onCellPrepare((cell: DG.GridCell) => {
     const currentRowIndex = cell.tableRowIndex;
-    if (currentRowIndex && invalidIndexes.includes(currentRowIndex) && !cell.isRowHeader) {
+    if (currentRowIndex && invalidIndexes.includes(currentRowIndex) && !cell.isRowHeader)
       cell.style.backColor = DG.Color.lightLightGray;
-    }
   });
 
-  for (const col of matrixDf.columns.names()) {
+  for (const col of matrixDf.columns.names())
     sarGrid.col(col)!.width = sarGrid.props.rowHeight;
-  }
+
 
   if (grouping) {
     sarGrid.col(aminoAcidResidue)!.name = 'Groups';
@@ -434,5 +435,100 @@ export async function describe(
   sarGrid.props.allowEdit = false;
   sarVGrid.props.allowEdit = false;
 
+  sarVGrid.col('Mean difference')!.name = 'Diff';
+}
+
+export async function describe(
+  df: DG.DataFrame,
+  activityColumn: string,
+  activityScaling: string,
+  sourceGrid: DG.Grid,
+  twoColorMode: boolean,
+  initialBitset: DG.BitSet | 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');
+  [splitSeqDf, invalidIndexes] = splitAlignedPeptides(col);
+  splitSeqDf.name = 'Split sequence';
+
+  const positionColumns = splitSeqDf.columns.names();
+  const activityColumnScaled = `${activityColumn}Scaled`;
+  const renderColNames: string[] = splitSeqDf.columns.names();
+  const positionColName = 'Position';
+  const aminoAcidResidue = 'AAR';
+
+  splitSeqDf.columns.add(df.getCol(activityColumn));
+
+  joinDataFrames(activityColumnScaled, df, positionColumns, splitSeqDf, activityColumn);
+
+  for (const col of df.columns) {
+    if (splitSeqDf.col(col.name) && col.name != activityColumn)
+      setAARRenderer(col, sourceGrid);
+  }
+
+  sortSourceGrid(sourceGrid);
+
+  await scaleActivity(activityScaling, activityColumn, activityColumnScaled, sourceGrid, splitSeqDf);
+  splitSeqDf = splitSeqDf.clone(initialBitset);
+
+  //unpivot a table and handle duplicates
+  splitSeqDf = splitSeqDf.groupBy(positionColumns)
+    .add('med', activityColumnScaled, activityColumnScaled)
+    .aggregate();
+
+  const peptidesCount = splitSeqDf.getCol(activityColumnScaled).length;
+
+  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
+  const statsDf = await calculateStatistics(
+    matrixDf, positionColName, aminoAcidResidue, activityColumnScaled, peptidesCount, splitSeqDf, groupMapping,
+  );
+
+  // SAR matrix table
+  //pivot a table to make it matrix-like
+  matrixDf = statsDf.groupBy([aminoAcidResidue])
+    .pivot(positionColName)
+    .add('first', 'Mean difference', '')
+    .aggregate();
+  matrixDf.name = 'SAR';
+
+  // Setting category order
+  await setCategoryOrder(twoColorMode, statsDf, aminoAcidResidue, matrixDf);
+
+  // SAR vertical table (naive, choose best Mean difference from pVals <= 0.01)
+  const sequenceDf = createVerticalTable(statsDf, aminoAcidResidue, positionColName, twoColorMode);
+  renderColNames.push('Mean difference');
+
+  const [sarGrid, sarVGrid] = createGrids(
+    matrixDf, aminoAcidResidue, positionColumns, sequenceDf, positionColName, grouping,
+  );
+
+  setCellRendererFunc(
+    renderColNames, positionColName, aminoAcidResidue, statsDf, twoColorMode, sarGrid, sarVGrid,
+  );
+
+  // show all the statistics in a tooltip over cell
+  setTooltipFunc(
+    renderColNames, statsDf, aminoAcidResidue, positionColName, peptidesCount, grouping, sarGrid, sarVGrid,
+  );
+
+  postProcessGrids(sourceGrid, invalidIndexes, matrixDf, grouping, aminoAcidResidue, sarGrid, sarVGrid);
+
+  //TODO: return class instead
   return [sarGrid, sarVGrid, statsDf, groupMapping];
 }

package/src/{viewers/model.ts → model.ts}

@@ -1,6 +1,6 @@
 import * as DG from 'datagrok-api/dg';
 
-import {describe} from '../describe';
+import {describe} from './describe';
 import {Subject} from 'rxjs';
 
 /**