@datagrok/proteomics 1.0.1 → 1.2.0

package/src/viewers/pca-plot.ts

@@ -0,0 +1,169 @@
+import * as DG from 'datagrok-api/dg';
+import {GroupAssignment} from '../analysis/experiment-setup';
+import {computePCA} from '../analysis/pca';
+
+/** Local interface for area annotation region (may not be in installed datagrok-api types). */
+interface AreaAnnotationRegionDef {
+  type: string;
+  area: [number, number][];
+  fillColor: string;
+  opacity: number;
+  outlineColor: string;
+  outlineWidth: number;
+  x: string;
+  y: string;
+}
+
+/** Group colors for PCA plot ellipses and styling. */
+const GROUP_COLORS: string[] = ['#2196F3', '#FF5722'];
+
+/** Compute 95% confidence ellipse polygon points for a set of 2D points.
+ *  Returns an array of [x, y] pairs approximating the ellipse. */
+function confidenceEllipse(
+  xVals: number[],
+  yVals: number[],
+  nPoints: number = 64,
+): [number, number][] | null {
+  const n = xVals.length;
+  if (n < 3)
+    return null;
+
+  // Compute means
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < n; i++) {
+    cx += xVals[i];
+    cy += yVals[i];
+  }
+  cx /= n;
+  cy /= n;
+
+  // Compute 2x2 covariance matrix
+  let sxx = 0;
+  let sxy = 0;
+  let syy = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = xVals[i] - cx;
+    const dy = yVals[i] - cy;
+    sxx += dx * dx;
+    sxy += dx * dy;
+    syy += dy * dy;
+  }
+  sxx /= (n - 1);
+  sxy /= (n - 1);
+  syy /= (n - 1);
+
+  // Eigendecompose 2x2 matrix analytically
+  const trace = sxx + syy;
+  const det = sxx * syy - sxy * sxy;
+  const disc = Math.sqrt(Math.max(trace * trace / 4 - det, 0));
+  const lambda1 = trace / 2 + disc;
+  const lambda2 = trace / 2 - disc;
+
+  if (lambda1 <= 0 || lambda2 <= 0)
+    return null;
+
+  // Eigenvector for lambda1
+  let angle: number;
+  if (Math.abs(sxy) > 1e-12)
+    angle = Math.atan2(lambda1 - sxx, sxy);
+  else
+    angle = sxx >= syy ? 0 : Math.PI / 2;
+
+  // Chi-squared critical value for 2 DOF at 95% confidence
+  const chiSq95 = 5.991;
+
+  // Semi-axes scaled by chi-squared
+  const a = Math.sqrt(lambda1 * chiSq95);
+  const b = Math.sqrt(lambda2 * chiSq95);
+
+  // Generate ellipse polygon
+  const points: [number, number][] = [];
+  const cosA = Math.cos(angle);
+  const sinA = Math.sin(angle);
+  for (let i = 0; i < nPoints; i++) {
+    const t = (2 * Math.PI * i) / nPoints;
+    const ex = a * Math.cos(t);
+    const ey = b * Math.sin(t);
+    const x = cx + cosA * ex - sinA * ey;
+    const y = cy + sinA * ex + cosA * ey;
+    points.push([x, y]);
+  }
+
+  return points;
+}
+
+/** Creates a PCA plot (ScatterPlotViewer) on a sample-level DataFrame.
+ *  Computes PCA from intensity columns and colors points by experimental group.
+ *  Returns the viewer; the caller is responsible for adding the pcaDf to a view. */
+export function createPcaPlot(
+  df: DG.DataFrame,
+  intensityCols: string[],
+  groupAssignment: GroupAssignment,
+  title?: string,
+): {viewer: DG.ScatterPlotViewer; pcaDf: DG.DataFrame} {
+  const {pcaDf, varianceExplained} = computePCA(df, intensityCols, groupAssignment);
+
+  // Find PC column names (they include variance in the name).
+  const pc1ColName = pcaDf.columns.toList().find((c) => c.name.startsWith('PC1'))?.name;
+  const pc2ColName = pcaDf.columns.toList().find((c) => c.name.startsWith('PC2'))?.name;
+  if (!pc1ColName || !pc2ColName)
+    throw new Error('PCA did not produce PC1/PC2 columns — too few samples?');
+
+  const sp = pcaDf.plot.scatter({
+    x: pc1ColName,
+    y: pc2ColName,
+    color: 'Group',
+  });
+
+  // Label all sample points (typically <50 samples in proteomics)
+  sp.props.labelColumnNames = ['SampleName'];
+  sp.props.displayLabels = 'Always';
+
+  // Attempt to add 95% confidence ellipses per group
+  try {
+    const pc1Col = pcaDf.col(pc1ColName)!;
+    const pc2Col = pcaDf.col(pc2ColName)!;
+    const groupCol = pcaDf.col('Group')!;
+    const groups = [groupAssignment.group1.name, groupAssignment.group2.name];
+
+    for (let g = 0; g < groups.length; g++) {
+      const groupName = groups[g];
+      const xVals: number[] = [];
+      const yVals: number[] = [];
+      for (let i = 0; i < pcaDf.rowCount; i++) {
+        if (groupCol.get(i) === groupName) {
+          xVals.push(pc1Col.get(i) as number);
+          yVals.push(pc2Col.get(i) as number);
+        }
+      }
+
+      const ellipsePoints = confidenceEllipse(xVals, yVals);
+      if (ellipsePoints) {
+        const color = GROUP_COLORS[g % GROUP_COLORS.length];
+        const region: AreaAnnotationRegionDef = {
+          type: 'area',
+          area: ellipsePoints,
+          fillColor: color,
+          opacity: 0.15,
+          outlineColor: color,
+          outlineWidth: 1,
+          x: pc1ColName,
+          y: pc2ColName,
+        };
+        // annotationRegions API may not be available in all datagrok-api versions
+        (sp.meta as any).annotationRegions?.add(region);
+      }
+    }
+  } catch (e: any) {
+    // Ellipse rendering is best-effort — the annotationRegions API may not be
+    // exposed in the installed datagrok-api. Log the underlying error so this
+    // doesn't silently mask unrelated bugs in the ellipse math or column reads.
+    console.warn('PCA: could not add confidence ellipses:', e?.message ?? e);
+  }
+
+  if (title)
+    sp.setOptions({title});
+
+  return {viewer: sp, pcaDf};
+}

package/src/viewers/qc-computations.ts

@@ -0,0 +1,266 @@
+import * as DG from 'datagrok-api/dg';
+import {SEMTYPE} from '../utils/proteomics-types';
+import {findColumn} from '../utils/column-detection';
+import {GroupAssignment} from '../analysis/experiment-setup';
+
+/** Returns log2-prefixed intensity column names. */
+export function getIntensityColumns(df: DG.DataFrame): string[] {
+  return df.columns.toList()
+    .filter((c) => c.semType === SEMTYPE.INTENSITY && c.name.startsWith('log2('))
+    .map((c) => c.name);
+}
+
+/** Computes the mean of non-null values across columns at a given row index.
+ *  Returns NaN if all values are null. */
+function groupMean(cols: DG.Column[], rowIdx: number): number {
+  let sum = 0;
+  let count = 0;
+  for (const col of cols) {
+    if (!col.isNone(rowIdx)) {
+      sum += col.get(rowIdx) as number;
+      count++;
+    }
+  }
+  return count > 0 ? sum / count : NaN;
+}
+
+/** Ensures a column exists fresh -- removes it if present, then adds a new float column. */
+function ensureFreshFloat(df: DG.DataFrame, name: string): DG.Column {
+  if (df.columns.contains(name))
+    df.columns.remove(name);
+  return df.columns.addNewFloat(name);
+}
+
+/** Computes MA values (M = log2 ratio, A = average intensity) and adds M, A columns to df. */
+export function computeMA(df: DG.DataFrame, groups: GroupAssignment): void {
+  const g1Cols = groups.group1.columns.map((n) => df.col(n)!);
+  const g2Cols = groups.group2.columns.map((n) => df.col(n)!);
+
+  const nRows = df.rowCount;
+  const mArr = new Float32Array(nRows);
+  const aArr = new Float32Array(nRows);
+  for (let i = 0; i < nRows; i++) {
+    const g1Mean = groupMean(g1Cols, i);
+    const g2Mean = groupMean(g2Cols, i);
+    if (isNaN(g1Mean) || isNaN(g2Mean)) {
+      mArr[i] = DG.FLOAT_NULL;
+      aArr[i] = DG.FLOAT_NULL;
+    } else {
+      mArr[i] = g2Mean - g1Mean;
+      aArr[i] = (g1Mean + g2Mean) / 2;
+    }
+  }
+  ensureFreshFloat(df, 'M').init((i) => mArr[i]);
+  ensureFreshFloat(df, 'A').init((i) => aArr[i]);
+}
+
+/** Computes a moving-average trend line for the MA plot.
+ *  Approximates loess by sorting on A and averaging M within a sliding window.
+ *  Adds an MA_trend column to df. */
+export function computeLoessTrend(df: DG.DataFrame, windowFraction: number = 0.1): void {
+  const aCol = df.col('A');
+  const mCol = df.col('M');
+  if (!aCol || !mCol) {
+    ensureFreshFloat(df, 'MA_trend');
+    return;
+  }
+
+  const aRaw = aCol.getRawData() as Float32Array | Float64Array;
+  const mRaw = mCol.getRawData() as Float32Array | Float64Array;
+
+  // Collect non-null (A, M) pairs with original row indices
+  const points: {idx: number; a: number; m: number}[] = [];
+  for (let i = 0; i < df.rowCount; i++) {
+    if (aRaw[i] !== DG.FLOAT_NULL && mRaw[i] !== DG.FLOAT_NULL)
+      points.push({idx: i, a: aRaw[i], m: mRaw[i]});
+  }
+
+  const trendArr = new Float32Array(df.rowCount);
+  trendArr.fill(DG.FLOAT_NULL);
+
+  // Guard: need at least 3 non-null points
+  if (points.length < 3) {
+    ensureFreshFloat(df, 'MA_trend').init((i) => trendArr[i]);
+    return;
+  }
+
+  // Sort by A value
+  points.sort((a, b) => a.a - b.a);
+
+  const halfWindow = Math.max(Math.round(points.length * windowFraction / 2), 5);
+
+  // For each point, compute mean M in a window centered on it, writing to trendArr
+  for (let i = 0; i < points.length; i++) {
+    const lo = Math.max(0, i - halfWindow);
+    const hi = Math.min(points.length - 1, i + halfWindow);
+    let sum = 0;
+    let count = 0;
+    for (let j = lo; j <= hi; j++) {
+      sum += points[j].m;
+      count++;
+    }
+    trendArr[points[i].idx] = sum / count;
+  }
+
+  ensureFreshFloat(df, 'MA_trend').init((i) => trendArr[i]);
+}
+
+/** Computes coefficient of variation (CV = sd/mean) on raw (non-log) intensities
+ *  within a group of columns. Adds cvColName and meanColName float columns to df. */
+export function computeCV(
+  df: DG.DataFrame,
+  groupCols: string[],
+  cvColName: string,
+  meanColName: string,
+): void {
+  const rawArrays = groupCols
+    .map((n) => df.col(n))
+    .filter((c) => c != null && c.type === DG.COLUMN_TYPE.FLOAT)
+    .map((c) => c!.getRawData() as Float32Array | Float64Array);
+
+  const nRows = df.rowCount;
+  const cvArr = new Float32Array(nRows);
+  const meanArr = new Float32Array(nRows);
+
+  // Welford's online algorithm for mean + sample variance.
+  // The naive `(sumSq - sum*sum/count) / (count-1)` form suffers from
+  // catastrophic cancellation when the values are large and the spread
+  // is small — which is exactly the regime for raw intensities (often >1e6
+  // with tight biological CVs).
+  for (let i = 0; i < nRows; i++) {
+    let count = 0;
+    let mean = 0;
+    let m2 = 0;
+    for (const raw of rawArrays) {
+      const v = raw[i];
+      if (v !== DG.FLOAT_NULL) {
+        // Exponentiate log2 values back to raw intensities for CV computation
+        const val = Math.pow(2, v);
+        count++;
+        const delta = val - mean;
+        mean += delta / count;
+        m2 += delta * (val - mean);
+      }
+    }
+    if (count < 1) {
+      cvArr[i] = DG.FLOAT_NULL;
+      meanArr[i] = DG.FLOAT_NULL;
+    } else if (count < 2) {
+      cvArr[i] = DG.FLOAT_NULL;
+      meanArr[i] = mean;
+    } else {
+      const variance = m2 / (count - 1);
+      const sd = Math.sqrt(Math.max(0, variance));
+      cvArr[i] = mean > 0 ? sd / mean : DG.FLOAT_NULL;
+      meanArr[i] = mean;
+    }
+  }
+
+  ensureFreshFloat(df, cvColName).init((i) => cvArr[i]);
+  ensureFreshFloat(df, meanColName).init((i) => meanArr[i]);
+}
+
+/** Creates a binary missingness matrix DataFrame (1 = present, 0 = missing).
+ *  Includes protein ID column if available. */
+export function createMissingnessMatrix(df: DG.DataFrame, intensityCols: string[]): DG.DataFrame {
+  const columns: DG.Column[] = [];
+
+  // Include protein ID column if available
+  const labelCol = findColumn(df, SEMTYPE.PROTEIN_ID, ['protein id', 'accession']);
+  if (labelCol)
+    columns.push(labelCol.clone());
+
+  // Binary columns: 1 = present, 0 = missing.
+  // Write directly into a fresh Int32Array, then wrap as the column.
+  for (const colName of intensityCols) {
+    const srcCol = df.col(colName)!;
+    const srcRaw = srcCol.type === DG.COLUMN_TYPE.FLOAT
+      ? srcCol.getRawData() as Float32Array | Float64Array
+      : null;
+    const data = new Int32Array(df.rowCount);
+    if (srcRaw) {
+      for (let i = 0; i < df.rowCount; i++)
+        data[i] = srcRaw[i] === DG.FLOAT_NULL ? 0 : 1;
+    } else {
+      for (let i = 0; i < df.rowCount; i++)
+        data[i] = srcCol.isNone(i) ? 0 : 1;
+    }
+    columns.push(DG.Column.fromInt32Array(colName, data));
+  }
+
+  const result = DG.DataFrame.fromColumns(columns);
+  result.name = 'Missing Values';
+  return result;
+}
+
+/** Creates a long-format DataFrame with columns: ProteinId, Sample, Intensity.
+ *  Skips null intensity values to keep the DataFrame compact. */
+export function unpivotIntensities(df: DG.DataFrame, intensityCols: string[]): DG.DataFrame {
+  const proteinIdCol = findColumn(df, SEMTYPE.PROTEIN_ID, ['protein id', 'accession']);
+
+  const ids: string[] = [];
+  const samples: string[] = [];
+  const intensities: number[] = [];
+
+  for (let i = 0; i < df.rowCount; i++) {
+    const proteinId = proteinIdCol ? (proteinIdCol.get(i) as string ?? String(i)) : String(i);
+    for (const colName of intensityCols) {
+      const col = df.col(colName)!;
+      if (!col.isNone(i)) {
+        ids.push(proteinId);
+        samples.push(colName);
+        intensities.push(col.get(i) as number);
+      }
+    }
+  }
+
+  const result = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('ProteinId', ids),
+    DG.Column.fromStrings('Sample', samples),
+    DG.Column.fromFloat32Array('Intensity', new Float32Array(intensities)),
+  ]);
+  result.name = 'Intensity Distributions';
+  return result;
+}
+
+/** Creates a sample-level DataFrame with columns: Sample, MissingPct, Group.
+ *  Each row represents one intensity column with its missing value percentage. */
+export function computeMissingBarData(
+  df: DG.DataFrame,
+  intensityCols: string[],
+  groups: GroupAssignment,
+): DG.DataFrame {
+  const sampleNames: string[] = [];
+  const missingPcts: number[] = [];
+  const groupNames: string[] = [];
+
+  const g1Set = new Set(groups.group1.columns);
+  const g2Set = new Set(groups.group2.columns);
+
+  for (const colName of intensityCols) {
+    const col = df.col(colName)!;
+    let nullCount = 0;
+    for (let i = 0; i < df.rowCount; i++) {
+      if (col.isNone(i))
+        nullCount++;
+    }
+
+    sampleNames.push(colName);
+    missingPcts.push((nullCount / df.rowCount) * 100);
+
+    if (g1Set.has(colName))
+      groupNames.push(groups.group1.name);
+    else if (g2Set.has(colName))
+      groupNames.push(groups.group2.name);
+    else
+      groupNames.push('Other');
+  }
+
+  const result = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('Sample', sampleNames),
+    DG.Column.fromFloat32Array('MissingPct', new Float32Array(missingPcts)),
+    DG.Column.fromStrings('Group', groupNames),
+  ]);
+  result.name = 'Missing Values per Sample';
+  return result;
+}

package/src/viewers/qc-dashboard.ts

@@ -0,0 +1,176 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import {getGroups} from '../analysis/experiment-setup';
+import {ensureDirectionColumn} from './volcano';
+import {DEFAULT_FC_THRESHOLD, DEFAULT_P_THRESHOLD} from '../utils/proteomics-types';
+import {
+  getIntensityColumns,
+  computeMA,
+  computeLoessTrend,
+  computeCV,
+  createMissingnessMatrix,
+  unpivotIntensities,
+  computeMissingBarData,
+} from './qc-computations';
+
+/** Columns added by QC computations that should be cleaned up on re-run.
+ * `direction` is NOT included here: it is shared with the volcano plot, which
+ * updates it in-place, and ensureDirectionColumn(...) below overwrites cells
+ * rather than re-adding the column. Removing it would break any open volcano
+ * viewer bound to the column reference. */
+const QC_COLUMNS = ['M', 'A', 'MA_trend', 'CV_group1', 'meanInt_group1', 'CV_group2', 'meanInt_group2'];
+
+/** Opens a QC dashboard with all QC viewers docked in a tiled layout.
+ *  Requires group annotations (shows warning if missing). */
+export function openQcDashboard(df: DG.DataFrame): void {
+  const pi = DG.TaskBarProgressIndicator.create('Creating QC dashboard...');
+  try {
+    // 1. Prerequisite check: groups must be annotated
+    const groups = getGroups(df);
+    if (!groups) {
+      grok.shell.warning('Annotate experimental groups first (Proteomics | Annotate Experiment)');
+      return;
+    }
+
+    // 2. Clean up previous QC columns (allows re-running)
+    for (const name of QC_COLUMNS) {
+      if (df.columns.contains(name))
+        df.columns.remove(name);
+    }
+
+    // 3. Get intensity columns
+    const intensityCols = getIntensityColumns(df);
+    if (intensityCols.length === 0) {
+      grok.shell.warning('No log2 intensity columns found');
+      return;
+    }
+
+    // 4. Compute MA values
+    computeMA(df, groups);
+
+    // 5. Compute loess/moving-average trend
+    computeLoessTrend(df);
+
+    // 6. Compute CV per group
+    computeCV(df, groups.group1.columns, 'CV_group1', 'meanInt_group1');
+    computeCV(df, groups.group2.columns, 'CV_group2', 'meanInt_group2');
+
+    // Get the current table view
+    const tv = grok.shell.tv;
+    if (!tv) {
+      grok.shell.warning('No table view open');
+      return;
+    }
+
+    // 7. MA scatter plot
+    const maPlotOptions: Record<string, any> = {
+      xColumnName: 'A',
+      yColumnName: 'M',
+      title: 'MA Plot',
+      markerDefaultSize: 2,
+    };
+
+    // Conditional coloring by direction when DE is available
+    if (df.getTag('proteomics.de_complete') === 'true') {
+      try {
+        const dirColName = ensureDirectionColumn(df, DEFAULT_FC_THRESHOLD, DEFAULT_P_THRESHOLD);
+        maPlotOptions['colorColumnName'] = dirColName;
+      } catch (_e) {
+        // DE columns may not exist despite tag -- skip coloring
+      }
+    }
+
+    const maPlot = tv.addViewer(DG.VIEWER.SCATTER_PLOT, maPlotOptions);
+
+    // Add M=0 reference line for MA plot. Drop any prior M=0 lines first so
+    // repeated QC dashboard opens don't stack duplicates on the DataFrame.
+    const maFormula = '${M} = 0';
+    df.meta.formulaLines.items = df.meta.formulaLines.items.filter((line) => line.formula !== maFormula);
+    df.meta.formulaLines.addLine({
+      formula: maFormula,
+      color: '#888888',
+      width: 1,
+      visible: true,
+    });
+
+    // 7b. MA trend line as a separate scatter plot with line markers
+    const maTrend = tv.addViewer(DG.VIEWER.SCATTER_PLOT, {
+      xColumnName: 'A',
+      yColumnName: 'MA_trend',
+      title: 'MA Trend',
+      markerDefaultSize: 1,
+    });
+
+    // 8. CV scatter plot (group1 by default)
+    const cvPlot = tv.addViewer(DG.VIEWER.SCATTER_PLOT, {
+      xColumnName: 'meanInt_group1',
+      yColumnName: 'CV_group1',
+      title: 'CV Plot',
+      markerDefaultSize: 2,
+    });
+
+    // 9. Sample correlation plot
+    const corrPlot = tv.addViewer(DG.VIEWER.CORR_PLOT, {
+      xColumnNames: intensityCols,
+      yColumnNames: intensityCols,
+      title: 'Sample Correlation',
+    });
+
+    // 10. Missing values heatmap (separate DataFrame -- no addTable to avoid circular JSON)
+    const missDf = createMissingnessMatrix(df, intensityCols);
+    const missGrid = DG.Viewer.grid(missDf);
+    missGrid.props.allowColSelection = false;
+
+    // 11. Missing values bar chart (separate DataFrame -- use factory to bind correctly)
+    const barDf = computeMissingBarData(df, intensityCols, groups);
+    const missBar = DG.Viewer.barChart(barDf, {
+      splitColumnName: 'Sample',
+      valueColumnName: 'MissingPct',
+      stackColumnName: 'Group',
+    } as any);
+
+    // 12. Box plot for intensity distributions (separate DataFrame -- use factory to bind correctly)
+    const longDf = unpivotIntensities(df, intensityCols);
+    const boxPlot = DG.Viewer.boxPlot(longDf, {
+      valueColumnName: 'Intensity',
+      categoryColumnName: 'Sample',
+    } as any);
+
+    // 13. Dock layout -- two themed tab stacks so every chart stays full-size.
+    // Seven heterogeneous QC charts can't all be legible tiled at once (chaining
+    // them RIGHT squeezes the last ones to nothing), so group by QC theme and tab
+    // within each region (DOCK_TYPE.FILL): the active chart fills the whole
+    // region instead of being cramped.
+    //   * Top-right region  -- per-protein diagnostics: MA / MA trend / CV
+    //   * Bottom-right region -- per-sample QC: correlation / distributions / missingness
+    // The data grid keeps the left quarter.
+    const dm = tv.dockManager;
+
+    // Per-protein stack (top-right). RIGHT of root at 0.75 leaves the grid a quarter.
+    const protNode = dm.dock(maPlot, DG.DOCK_TYPE.RIGHT, null, 'MA Plot', 0.75);
+    dm.dock(maTrend, DG.DOCK_TYPE.FILL, protNode, 'MA Trend');
+    dm.dock(cvPlot, DG.DOCK_TYPE.FILL, protNode, 'CV Plot');
+
+    // Per-sample stack (bottom-right), splitting the right region in half vertically.
+    const sampleNode = dm.dock(corrPlot, DG.DOCK_TYPE.DOWN, protNode, 'Sample Correlation', 0.5);
+    dm.dock(boxPlot, DG.DOCK_TYPE.FILL, sampleNode, 'Intensity Distributions');
+    dm.dock(missBar, DG.DOCK_TYPE.FILL, sampleNode, 'Missing % per Sample');
+    dm.dock(missGrid, DG.DOCK_TYPE.FILL, sampleNode, 'Missing Values');
+
+    // FILL docking activates the LAST-docked tab; make each stack default to its
+    // headline chart instead (MA Plot / Sample Correlation). setActiveChild lives
+    // on the parent tab container. Best-effort — a layout that isn't tabbed (e.g.
+    // a future single-viewer variant) simply keeps its default active tab.
+    const activateTab = (v: DG.Viewer): void => {
+      try {
+        const node = dm.findNode(v.root);
+        if (node?.parent) node.parent.container.setActiveChild(node.container);
+      } catch { /* best-effort */ }
+    };
+    activateTab(maPlot);
+    activateTab(corrPlot);
+  } finally {
+    pi.close();
+  }
+}