nmr-processing 9.7.8 → 9.8.0

package/src/xyz/util/fft2d/fftIndirectDimension.ts

@@ -1,10 +1,11 @@
 import { DoubleArray } from 'cheminfo-types';
 import Matrix from 'ml-matrix';
 import {
+  DataReIm,
   reimAbsolute,
-  reimAutoPhaseCorrection,
   reimFFT,
   reimPhaseCorrection,
+  xMultiply,
 } from 'ml-spectra-processing';
 
 import {
@@ -22,6 +23,7 @@ interface PhaseCorrection {
 
 export interface IndirectDimensionOptions {
   fnMode?: string;
+  reverse?: boolean;
   zeroFilling?: ZeroFillingOptions;
   apodization?: ApodizationFilterOptions;
   phaseCorrection?: PhaseCorrection;
@@ -31,93 +33,141 @@ export function fftIndirectDimension(
   data: { re: DoubleArray[] | Matrix; im: DoubleArray[] | Matrix },
   options: IndirectDimensionOptions,
 ) {
-  const reData = Matrix.checkMatrix(data.re);
-  const imData = Matrix.checkMatrix(data.im);
+  const newData: Record<string, Matrix> = {
+    re: Matrix.checkMatrix(data.re),
+    im: Matrix.checkMatrix(data.im),
+  };
 
-  const nbRows = reData.rows;
-  const nbColumns = reData.columns;
+  const nbRows = newData.re.rows;
+  const nbColumns = newData.re.columns;
 
-  const { zeroFilling: zeroFillingF1 } = options;
+  const { zeroFilling: zeroFillingF1, reverse } = options;
   const { factor: f1Factor = 2 } = zeroFillingF1 || {};
-  const nbPointsF1 =
+
+  const nbPoints =
     zeroFillingF1?.nbPoints || 2 ** Math.round(Math.log2(nbRows * f1Factor));
-  const { apodization: apodizationF1 } = options;
-  let {
-    ph0: ph0F1,
-    ph1: ph1F1,
-    mode: pcModeF1,
-  } = options.phaseCorrection || {};
-
-  const reResult = new Matrix(nbPointsF1, nbColumns);
-  const imResult = new Matrix(nbPointsF1, nbColumns);
-  for (let i = 0; i < nbColumns; i++) {
-    const { re: aRe, im: aIm } = apodization(
-      {
-        re: reData.getColumn(i),
-        im: imData.getColumn(i),
-      },
-      apodizationF1,
-    );
+  const { fnMode } = options;
 
-    const newRe = [];
-    const newIm = [];
-    if (options.fnMode === 'echo') {
-      for (let j = 0; j < aRe.length; j += 2) {
-        newRe.push(aRe[j]);
-        newIm.push(aRe[j + 1]);
+  const newOptions: IndirectDimensionOptions = {
+    ...options,
+    zeroFilling: { ...zeroFillingF1, nbPoints },
+  };
+  const quadrants: Record<string, Matrix> = {};
+  if (fnMode === 'QF') {
+    const reResult = new Matrix(nbPoints, nbColumns);
+    const imResult = new Matrix(nbPoints, nbColumns);
+    for (let i = 0; i < nbColumns; i++) {
+      const data = {
+        re: newData.re.getColumn(i),
+        im: reverse
+          ? newData.im.getColumn(i)
+          : xMultiply(newData.im.getColumn(i), -1),
+      };
+      const { re, im } = applyFFT(data, newOptions);
+      reResult.setColumn(i, re);
+      imResult.setColumn(i, im);
+    }
+    quadrants.rr = reResult;
+    quadrants.ir = imResult;
+  } else {
+    // four quadrant processing
+    for (const current in newData) {
+      const reResult = new Matrix(nbPoints, nbColumns);
+      const imResult = new Matrix(nbPoints, nbColumns);
+      for (let i = 0; i < nbColumns; i++) {
+        const data = getColumnFrom(newData[current], { fnMode, index: i });
+        const { re, im } = applyFFT(data, newOptions);
+        reResult.setColumn(i, re);
+        imResult.setColumn(i, im);
       }
-    } else {
-      for (let j = 0; j < aRe.length; j++) {
-        newRe.push(aRe[j]);
-        newIm.push(-aIm[j]);
+      if (current === 're') {
+        quadrants.rr = reResult;
+        quadrants.ir = imResult;
+      } else {
+        quadrants.ri = reResult;
+        quadrants.ii = imResult;
       }
     }
+  }
+  return quadrants;
+}
+
+function applyFFT(data: DataReIm, options: IndirectDimensionOptions) {
+  const {
+    fnMode,
+    apodization: apodizationF1,
+    zeroFilling: zeroFillingF1 = {},
+    phaseCorrection = {},
+  } = options;
+
+  const { re, im } = apodization(data, apodizationF1);
 
-    let transformed = reimFFT(
-      zeroFilling(
-        {
-          re: newRe,
-          im: newIm,
-        },
-        { digitalFilterValue: 0, nbPoints: nbPointsF1 },
+  const { nbPoints = 0 } = zeroFillingF1;
+  const transformed = reimFFT(zeroFilling({ re, im }, { nbPoints }), {
+    applyZeroShift: !['SEQ', 'TPPI'].some((k) => fnMode === k),
+  });
+
+  if (options.phaseCorrection?.mode === 'mc') {
+    Object.assign(transformed, {
+      re: reimAbsolute(transformed),
+      im: new Float64Array(nbPoints),
+    });
+  }
+
+  const { mode: pcModeF1, ph0: ph0F1, ph1: ph1F1 } = phaseCorrection;
+  if (pcModeF1 === 'pk' && ph0F1 !== undefined && ph1F1 !== undefined) {
+    Object.assign(
+      transformed,
+      reimPhaseCorrection(
+        transformed,
+        (ph0F1 * Math.PI) / 180,
+        (ph1F1 * Math.PI) / 180,
       ),
-      { applyZeroShift: true },
     );
-    let { re, im } = transformed;
+  }
+  return transformed;
+}
 
-    if (options.phaseCorrection?.mode === 'mc') {
-      re = reimAbsolute({ re, im });
-      im = new Float64Array(im.length);
-    }
+function getColumnFrom(
+  data: Matrix,
+  info: { fnMode?: string; reverse?: boolean; index: number },
+) {
+  const { fnMode, index } = info;
+  const reverse = info.reverse || fnMode === 'QF';
+  const nbPoints = data.rows / 2;
+  const re = new Float64Array(nbPoints);
+  const im = new Float64Array(nbPoints);
 
-    if (pcModeF1 === 'pk') {
-      if (i === 0 && ph0F1 === undefined && ph1F1 === undefined) {
-        //here we can improve it by checking if the experiment is phase sensitive.
-        const phased = reimAutoPhaseCorrection(
-          { re, im },
-          { magnitudeMode: false },
-        );
-        ph0F1 = phased.ph0;
-        ph1F1 = phased.ph1;
+  switch (fnMode?.toLocaleLowerCase()) {
+    // case 'states':
+    // case 'echo-antiecho':
+    case 'seq':
+    case 'tppi':
+      return {
+        re: data.getColumn(index),
+        im: new Float64Array(data.rows),
+      };
+    default:
+      if (reverse) {
+        for (let i = 0; i < nbPoints; i++) {
+          re[i] = data.get(2 * i, index);
+          im[i] = -data.get(2 * i + 1, index);
+        }
+      } else {
+        for (let i = 0; i < nbPoints; i++) {
+          re[i] = data.get(2 * i, index);
+          im[i] = data.get(2 * i + 1, index);
+        }
       }
-      if (ph0F1 !== undefined && ph1F1 !== undefined) {
-        Object.assign(
-          transformed,
-          reimPhaseCorrection(
-            transformed,
-            (ph0F1 * Math.PI) / 180,
-            (ph1F1 * Math.PI) / 180,
-          ),
-        );
-      }
-    }
+  }
 
-    reResult.setColumn(i, re);
-    imResult.setColumn(i, im);
+  if (fnMode === 'states-ttpi') {
+    //it is to convert to the equivalent of states
+    for (let i = 0; i < nbPoints; i += 2) {
+      re[i] *= -1;
+      im[i] *= -1;
+    }
   }
 
-  return {
-    re: reResult,
-    im: imResult,
-  };
+  return { re, im };
 }

package/src/xyz/util/fft2d/removeDCOffset.ts

@@ -1,7 +1,7 @@
 import { DataReIm, xMean } from 'ml-spectra-processing';
 
 export function removeDCOffset(data: DataReIm, options: any) {
-  let { digitalFilterValue = 0 } = options;
+  const { digitalFilterValue = 0 } = options;
   const nbPoints = data.re.length;
   const newRe = new Float64Array(data.re);
   const newIm = new Float64Array(data.im);

package/src/xyz/util/fft2d/zeroFilling.ts

@@ -7,11 +7,10 @@ export interface ZeroFillingOptions {
 }
 
 export function zeroFilling(data: DataReIm, options: ZeroFillingOptions) {
-  let { nbPoints, factor = 2, digitalFilterValue: grpdly = 0 } = options;
+  const { factor = 2, digitalFilterValue: grpdly = 0 } = options;
 
-  if (!nbPoints) {
-    nbPoints = 2 ** Math.round(Math.log2(data.re.length * factor));
-  }
+  const nbPoints =
+    options.nbPoints || 2 ** Math.round(Math.log2(data.re.length * factor));
 
   let pointsToShift;
   if (grpdly > 0) {
@@ -22,8 +21,8 @@ export function zeroFilling(data: DataReIm, options: ZeroFillingOptions) {
 
   const { re, im } = data;
 
-  let newRE = new Float64Array(nbPoints);
-  let newIM = new Float64Array(nbPoints);
+  const newRE = new Float64Array(nbPoints);
+  const newIM = new Float64Array(nbPoints);
 
   const length = Math.min(nbPoints, re.length);
 

package/src/xyz/util/formatZone.ts

@@ -4,10 +4,10 @@ import { NMRSignal2DWithID } from '../xyzAutoSignalsPicking';
 import { NMRZoneWithID } from '../xyzAutoZonesPicking';
 
 export function formatZones(signals: NMRSignal2DWithID[]) {
-  let zones: NMRZoneWithID[] = [];
+  const zones: NMRZoneWithID[] = [];
   for (const signal of signals) {
-    let minMax1 = [Number.MAX_VALUE, 0];
-    let minMax2 = [Number.MAX_VALUE, 0];
+    const minMax1 = [Number.MAX_VALUE, 0];
+    const minMax2 = [Number.MAX_VALUE, 0];
     for (const peak of signal.peaks || []) {
       if (peak.minX < minMax1[0]) {
         minMax1[0] = peak.minX;

package/src/xyz/util/getMinMaxXY.ts

@@ -0,0 +1,19 @@
+export function getMinMaxXY(info: Record<string, any>) {
+  const min: number[] = [];
+  const max: number[] = [];
+  for (let i = 0; i < info.baseFrequency.length; i++) {
+    const baseFrequency = info.baseFrequency[i];
+    const frequencyOffset = info.frequencyOffset[i];
+    const spectralWidth = info.spectralWidth[i];
+    const offset = frequencyOffset / baseFrequency;
+    min.push(offset - spectralWidth * 0.5);
+    max.push(offset + spectralWidth * 0.5);
+  }
+
+  return {
+    minX: min[0],
+    maxX: max[0],
+    minY: min[1],
+    maxY: max[1],
+  };
+}

package/src/xyz/util/padData.ts

@@ -4,23 +4,23 @@ export function padData(
   spectraData: NmrData2DContent,
   options: { width: number },
 ) {
-  let { minX, maxX, minY, maxY } = spectraData;
+  const { minX, maxX, minY, maxY } = spectraData;
 
   const width = options.width;
 
-  let nbPoints = spectraData.z[0].length;
-  let nbSubSpectra = spectraData.z.length;
+  const nbPoints = spectraData.z[0].length;
+  const nbSubSpectra = spectraData.z.length;
 
-  let yInterval = (maxY - minY) / (nbSubSpectra - 1);
-  let xInterval = (maxX - minX) / (nbPoints - 1);
+  const yInterval = (maxY - minY) / (nbSubSpectra - 1);
+  const xInterval = (maxX - minX) / (nbPoints - 1);
 
   let yDiff = width - nbSubSpectra;
   let xDiff = Math.max(width - nbPoints, 0);
   if (xDiff % 2) xDiff++;
   if (yDiff % 2) yDiff++;
 
-  let xOffset = xDiff / 2;
-  let yOffset = yDiff / 2;
+  const xOffset = xDiff / 2;
+  const yOffset = yDiff / 2;
 
   const newMatrix: Float64Array[] = [];
   for (let i = 0; i < nbSubSpectra + yDiff; i++) {

package/src/xyz/util/phaseCorrection/applyOverImag.ts

@@ -0,0 +1,29 @@
+import { NmrData2DFt } from 'cheminfo-types';
+import { PhaseCorrectionOptions } from '../../xyzPhaseCorrectionDirectDimension';
+import { getZMinMax } from './getZMinMax';
+import Matrix from 'ml-matrix';
+import { checkNmrData2DFourQuad } from './checkNmrData2DFourQuad';
+
+export function applyOverImag<T extends NmrData2DFt>(
+  data: T,
+  options: PhaseCorrectionOptions,
+) {
+  checkNmrData2DFourQuad(data);
+  const { applyPhaseCorrection } = options;
+  const { re, im } = applyPhaseCorrection(
+    { re: Matrix.checkMatrix(data.ri.z), im: Matrix.checkMatrix(data.ii.z) },
+    options,
+  );
+
+  return {
+    ...data,
+    ri: {
+      ...data.ri,
+      ...getZMinMax(re),
+    },
+    ii: {
+      ...data.ii,
+      ...getZMinMax(im),
+    },
+  };
+}

package/src/xyz/util/phaseCorrection/applyOverReal.ts

@@ -0,0 +1,29 @@
+import { NmrData2DFt } from 'cheminfo-types';
+import { checkNmrData2DTwoQuad } from './checkNmrData2DTwoQuad';
+import Matrix from 'ml-matrix';
+import { getZMinMax } from './getZMinMax';
+import { PhaseCorrectionOptions } from '../../xyzPhaseCorrectionDirectDimension';
+
+export function applyOverReal<T extends NmrData2DFt>(
+  data: T,
+  options: PhaseCorrectionOptions,
+) {
+  const { applyPhaseCorrection } = options;
+  checkNmrData2DTwoQuad(data);
+  const { re, im } = applyPhaseCorrection(
+    { re: Matrix.checkMatrix(data.rr.z), im: Matrix.checkMatrix(data.ir.z) },
+    options,
+  );
+
+  return {
+    ...data,
+    rr: {
+      ...data.rr,
+      ...getZMinMax(re),
+    },
+    ir: {
+      ...data.ir,
+      ...getZMinMax(im),
+    },
+  };
+}

package/src/xyz/util/phaseCorrection/checkNmrData2DFourQuad.ts

@@ -0,0 +1,12 @@
+import { NmrData2DFt } from 'cheminfo-types';
+
+export type NmrData2DFourQuadrant = Required<
+  Pick<NmrData2DFt, 'rr' | 'ir' | 'ri' | 'ii'>
+>;
+export function checkNmrData2DFourQuad(
+  data: NmrData2DFt,
+): asserts data is NmrData2DFourQuadrant {
+  if (!('ir' in data)) {
+    throw new Error('four quadrants should has ir, ri and ii quadrants');
+  }
+}

package/src/xyz/util/phaseCorrection/checkNmrData2DTwoQuad.ts

@@ -0,0 +1,11 @@
+import { NmrData2DFt } from 'cheminfo-types';
+
+export type NmrData2DTwoQuadrant = Required<Pick<NmrData2DFt, 'rr' | 'ir'>>;
+
+export function checkNmrData2DTwoQuad(
+  data: NmrData2DFt,
+): asserts data is NmrData2DTwoQuadrant {
+  if (!('ir' in data)) {
+    throw new Error('Two quadrants should has ir quadrant');
+  }
+}

package/src/xyz/util/phaseCorrection/getZMinMax.ts

@@ -0,0 +1,10 @@
+import Matrix from 'ml-matrix';
+import { xEnsureFloat64 } from 'ml-spectra-processing';
+
+export function getZMinMax(data: Matrix) {
+  return {
+    z: data.to2DArray().map(xEnsureFloat64),
+    maxZ: data.max(),
+    minZ: data.min(),
+  };
+}

package/src/xyz/xyzAutoSignalsPicking.ts

@@ -92,10 +92,9 @@ export function xyzAutoSignalsPicking(
   spectraData: NmrData2DContent,
   options: XYZAutoSignalsPickingOptions,
 ) {
-  let {
+  const {
     sizeToPad = 14,
     realTopDetection = true,
-    thresholdFactor = 0.5,
     nuclei = ['1H', '1H'],
     observedFrequencies,
     enhanceSymmetry = false,
@@ -106,6 +105,8 @@ export function xyzAutoSignalsPicking(
     kernel: kernelOptions,
   } = options;
 
+  let { thresholdFactor = 0.5 } = options;
+
   if (
     !Array.isArray(observedFrequencies) &&
     !ArrayBuffer.isView(observedFrequencies)
@@ -124,13 +125,13 @@ export function xyzAutoSignalsPicking(
     nbSubSpectra = spectraData.z.length;
   }
 
-  let absoluteData = new Float64Array(nbPoints * nbSubSpectra);
-  let originalData = new Float64Array(nbPoints * nbSubSpectra);
+  const absoluteData = new Float64Array(nbPoints * nbSubSpectra);
+  const originalData = new Float64Array(nbPoints * nbSubSpectra);
 
   for (let iSubSpectra = 0; iSubSpectra < nbSubSpectra; iSubSpectra++) {
-    let spectrum = spectraData.z[iSubSpectra];
+    const spectrum = spectraData.z[iSubSpectra];
     for (let iCol = 0; iCol < nbPoints; iCol++) {
-      let index = iSubSpectra * nbPoints + iCol;
+      const index = iSubSpectra * nbPoints + iCol;
       absoluteData[index] = Math.abs(spectrum[iCol]);
       originalData[index] = spectrum[iCol]; //@todo pensar si se puede evitar originalData
     }
@@ -138,7 +139,7 @@ export function xyzAutoSignalsPicking(
 
   const kernel = kernelOptions ? getKernel(kernelOptions) : smallFilter;
 
-  let convolutedSpectrum = convolutionByFFT
+  const convolutedSpectrum = convolutionByFFT
     ? convolution.fft(absoluteData, kernel, {
         rows: nbSubSpectra,
         cols: nbPoints,
@@ -208,7 +209,7 @@ function createSignals2D<T extends Peak2D>(
   peaks: T[],
   options: CreateSignals2DOptions,
 ) {
-  let {
+  const {
     nCols,
     nRows,
     absoluteData,
@@ -223,12 +224,12 @@ function createSignals2D<T extends Peak2D>(
     maxX,
   } = options;
 
-  let [nucleusX, nucleusY] = nuclei;
-  let [toleranceX, toleranceY] = tolerances;
-  let [observeFrequencyX, observeFrequencyY] = observedFrequencies;
+  const [nucleusX, nucleusY] = nuclei;
+  const [toleranceX, toleranceY] = tolerances;
+  const [observeFrequencyX, observeFrequencyY] = observedFrequencies;
 
-  let dy = (maxY - minY) / (nRows - 1);
-  let dx = (maxX - minX) / (nCols - 1);
+  const dy = (maxY - minY) / (nRows - 1);
+  const dx = (maxX - minX) / (nCols - 1);
 
   if (realTopDetection) {
     peaks = determineRealTop(peaks, {
@@ -243,7 +244,7 @@ function createSignals2D<T extends Peak2D>(
   }
 
   for (let i = peaks.length - 1; i >= 0; i--) {
-    let { x, y } = peaks[i];
+    const { x, y } = peaks[i];
     peaks[i].x = minX + dx * x;
     peaks[i].y = minY + dy * y;
     peaks[i].minX = minX + dx * peaks[i].minX;
@@ -255,7 +256,7 @@ function createSignals2D<T extends Peak2D>(
   }
   // The connectivity matrix is an square and symmetric matrix, so we'll only store the upper diagonal in an
   // array like form
-  let connectivity = [];
+  const connectivity = [];
   for (let i = 0; i < peaks.length; i++) {
     for (let j = i; j < peaks.length; j++) {
       if (
@@ -269,12 +270,12 @@ function createSignals2D<T extends Peak2D>(
       }
     }
   }
-  let clusters = simpleClustering(connectivity);
+  const clusters = simpleClustering(connectivity);
 
-  let signals: NMRSignal2DWithID<T>[] = [];
+  const signals: Array<NMRSignal2DWithID<T>> = [];
   if (clusters) {
     for (const cluster of clusters) {
-      let signal: any = {
+      const signal: any = {
         id: generateID(),
         x: {
           delta: 0,
@@ -287,7 +288,7 @@ function createSignals2D<T extends Peak2D>(
           resolution: dy,
         },
       };
-      let peaks2D: T[] = [];
+      const peaks2D: T[] = [];
       let sumZ = 0;
 
       for (let jPeak = 0; jPeak < cluster.length; jPeak++) {

package/src/xyz/xyzBidimensionalFFT.ts

@@ -13,6 +13,7 @@ import {
   IndirectDimensionOptions,
 } from './util/fft2d/fftIndirectDimension';
 import { ZeroFillingOptions } from './util/fft2d/zeroFilling';
+import { getMinMaxXY } from './util/getMinMaxXY';
 
 type Info2D = any;
 
@@ -100,23 +101,3 @@ function convertToDoubleArray(data: Matrix) {
   }
   return result;
 }
-
-function getMinMaxXY(info: Info2D) {
-  const min: number[] = [];
-  const max: number[] = [];
-  for (let i = 0; i < info.baseFrequency.length; i++) {
-    const baseFrequency = Number.parseFloat(info.baseFrequency[i]);
-    const frequencyOffset = Number.parseFloat(info.frequencyOffset[i]);
-    const spectralWidth = Number.parseFloat(info.spectralWidth[i]);
-    const offset = frequencyOffset / baseFrequency;
-    min.push(offset - spectralWidth * 0.5);
-    max.push(offset + spectralWidth * 0.5);
-  }
-
-  return {
-    minX: min[0],
-    maxX: max[0],
-    minY: min[1],
-    maxY: max[1],
-  };
-}