nmr-processing 9.7.8 → 9.8.0

package/src/datum/FiltersManager.ts

@@ -43,7 +43,7 @@ function updateData(datum: Entry1D | Entry2D) {
 
 interface ApplyFilterOptions {
   forceReapply?: boolean;
-  filterIndex?: number | -1;
+  filterIndex?: number;
 }
 
 interface FilterOption {
@@ -62,7 +62,7 @@ export function applyFilter(
 ) {
   const { forceReapply = false, filterIndex } = options;
   let isReduced = false;
-  for (let filter of filters) {
+  for (const filter of filters) {
     const filterOption = {
       name: filter.name,
       label: Filters[filter.name].name,
@@ -99,7 +99,7 @@ export function applyFilter(
       reapplyFilters(datum);
     }
   } else {
-    for (let filter of filters) {
+    for (const filter of filters) {
       Filters[filter.name].apply(datum, filter.value);
     }
   }

package/src/datum/MatrixOptions.ts

@@ -7,7 +7,7 @@ export interface MatrixOptions {
    * @default []
    *
    */
-  filters: (MatrixFilter & { options: object })[];
+  filters: Array<MatrixFilter & { options: object }>;
   /**
    * Exclusion zones
    * @default []

package/src/datum/data1d/Entry1D.ts

@@ -15,5 +15,5 @@ export interface Entry1D {
   ranges: Ranges;
   info: Info1D;
   originalInfo?: Info1D;
-  filters: Array<Filter>;
+  filters: Filter[];
 }

package/src/datum/data1d/filter1d/baselineCorrection.ts

@@ -40,7 +40,7 @@ export function apply(datum1D: Entry1D, options: BaselineCorrectionOptions) {
     throw new Error('baselineCorrection not applicable on this data');
   }
   const { algorithm } = options;
-  let { x, re } = datum1D.data;
+  const { x, re } = datum1D.data;
 
   let corrected;
   switch (algorithm) {
@@ -50,14 +50,14 @@ export function apply(datum1D: Entry1D, options: BaselineCorrectionOptions) {
     case 'polynomial':
       {
         const { degree, zones } = options;
-        let reduced = xyEquallySpaced(
+        const reduced = xyEquallySpaced(
           { x, y: re },
           { numberOfPoints: 4096, zones },
         );
-        let result = baselineRegression(reduced.x, reduced.y, {
+        const result = baselineRegression(reduced.x, reduced.y, {
           regressionOptions: degree,
         });
-        let { regression } = result;
+        const { regression } = result;
         corrected = new Float64Array(x.length);
         for (let i = 0; i < re.length; i++) {
           corrected[i] = re[i] - regression.predict(x[i]);

package/src/datum/data1d/filter1d/digitalFilter.ts

@@ -33,8 +33,8 @@ export function apply(spectrum: Entry1DDigitalFilter, options: any = {}) {
     }
   }
 
-  let re = new Float64Array(spectrum.data.re);
-  let im = new Float64Array(spectrum.data.im);
+  const re = new Float64Array(spectrum.data.re);
+  const im = new Float64Array(spectrum.data.im);
 
   let pointsToShift = Math.floor(digitalFilterValue);
 

package/src/datum/data1d/filter1d/fft.ts

@@ -29,7 +29,7 @@ export function apply(datum1D: Entry1DFt) {
 
   checkSameLength(datum1D);
 
-  let digitalFilterApplied = datum1D.filters.some(
+  const digitalFilterApplied = datum1D.filters.some(
     (e) => e.name === 'digitalFilter' && e.flag,
   );
 
@@ -58,8 +58,8 @@ export function apply(datum1D: Entry1DFt) {
   );
 
   if (digitalFilterApplied) {
-    let { digitalFilter = 0 } = info;
-    let ph1 = (digitalFilter - Math.floor(digitalFilter)) * Math.PI * 2;
+    const { digitalFilter = 0 } = info;
+    const ph1 = (digitalFilter - Math.floor(digitalFilter)) * Math.PI * 2;
     Object.assign(
       data,
       reimPhaseCorrection(data as DataReIm, 0, -ph1, { reverse: true }),
@@ -90,10 +90,10 @@ function generateXAxis(datum1D: Entry1DFt) {
   const frequencyOffset = Number(info.frequencyOffset);
   const spectralWidth = Number(info.spectralWidth);
   const offset = frequencyOffset / baseFrequency;
-  let spectralHalfWidth = 0.5 * spectralWidth;
-  let nbPoints = datum1D.data.x.length;
+  const spectralHalfWidth = 0.5 * spectralWidth;
+  const nbPoints = datum1D.data.x.length;
   let firstPoint = offset - spectralHalfWidth;
-  let dx = spectralWidth / (nbPoints - 1);
+  const dx = spectralWidth / (nbPoints - 1);
   const xAxis = new Float64Array(nbPoints);
   for (let i = 0; i < nbPoints; i++) {
     xAxis[i] = firstPoint;
@@ -110,7 +110,7 @@ function removeDCOffset(
   spectrum: Partial<Entry1DFt> & { data: Required<NmrData1D> },
   digitalFilterApplied: boolean,
 ) {
-  let { digitalFilter = 0 } =
+  const { digitalFilter = 0 } =
     digitalFilterApplied && spectrum.info ? spectrum.info : {};
   const data = spectrum.data;
   const nbPoints = data.re.length;

package/src/datum/data1d/filter1d/phaseCorrection.ts

@@ -45,13 +45,13 @@ export function apply(datum1D: Entry1D, options: any = {}) {
       filter.value = { ...filter.value, ph0: 0, ph1: 0, absolute };
     }
   } else if ('ph0' in options && 'ph1' in options) {
-    let { ph0, ph1 } = options;
+    const { ph0, ph1 } = options;
     phaseCorrection(datum1D, { ph0, ph1 });
     if (filter) {
       filter.value = { ...filter.value, absolute };
     }
   } else {
-    let { ph0, ph1 } = autoPhaseCorrection(datum1D);
+    const { ph0, ph1 } = autoPhaseCorrection(datum1D);
     phaseCorrection(datum1D, { ph0, ph1 });
     if (filter) {
       filter.value = { ...filter.value, absolute, ph0, ph1 };
@@ -63,7 +63,7 @@ function phaseCorrection(
   spectrum: Entry1D & { data: Required<NmrData1D> },
   phaseValues: { ph0: number; ph1: number },
 ) {
-  let { ph0, ph1 } = phaseValues;
+  const { ph0, ph1 } = phaseValues;
   const { re, im } = spectrum.data;
   const phased = reimPhaseCorrection(
     { re, im },

package/src/datum/data1d/filter1d/signalProcessing.ts

@@ -33,7 +33,7 @@ export function reduce(previousValue: any, newValue: any) {
 
 export function filterXY(spectrum: Entry1D, options: MatrixOptions) {
   let x = spectrum.data.x.slice(0);
-  let cloneX = spectrum.data.x.slice(0);
+  const cloneX = spectrum.data.x.slice(0);
   let re = spectrum.data.re.slice(0);
   let im = spectrum.data.im?.slice(0);
 

package/src/datum/data1d/filter1d/utils/padDataToNextPowerOfTwo.ts

@@ -14,8 +14,8 @@ export function padDataToNextPowerOfTwo(
   const { x, re, im } = datum1D.data;
   const size = nextPowerOfTwo(x.length);
 
-  let newRE = new Float64Array(size);
-  let newIM = new Float64Array(size);
+  const newRE = new Float64Array(size);
+  const newIM = new Float64Array(size);
 
   const grpdly = datum1D.info?.digitalFilter || 0;
   const pointsToShift = grpdly > 0 ? Math.floor(grpdly) : 0;

package/src/datum/data1d/filter1d/zeroFilling.ts

@@ -27,17 +27,18 @@ export function apply(
     throw new Error('zeroFilling not applicable on this data');
   }
 
-  let { nbPoints, factor = 2 } = options;
-
-  if (!nbPoints) {
-    nbPoints = 2 ** Math.round(Math.log2(datum1D.data.x.length * factor));
+  const { factor = 2 } = options;
+  const {
+    nbPoints = 2 ** Math.round(Math.log2(datum1D.data.x.length * factor)),
+  } = options;
+  if (!options.nbPoints) {
     const filter = datum1D.filters.find((filter) => filter.name === id);
     if (filter) {
       filter.value = { nbPoints };
     }
   }
 
-  let digitalFilterApplied = datum1D.filters.some(
+  const digitalFilterApplied = datum1D.filters.some(
     (e) => e.name === 'digitalFilter' && e.flag,
   );
 
@@ -47,9 +48,9 @@ export function apply(
 
   const { re, im, x } = datum1D.data;
 
-  let newRE = new Float64Array(nbPoints);
-  let newIM = new Float64Array(nbPoints);
-  let newX = new Float64Array(nbPoints);
+  const newRE = new Float64Array(nbPoints);
+  const newIM = new Float64Array(nbPoints);
+  const newX = new Float64Array(nbPoints);
 
   const length = Math.min(nbPoints, re.length);
 
@@ -57,7 +58,7 @@ export function apply(
   newIM.set(im.slice(0, length - pointsToShift));
   newX.set(x.slice(0, length - pointsToShift));
 
-  let diff = x[1] - x[0];
+  const diff = x[1] - x[0];
   let currentX = x[length - pointsToShift - 1];
   for (let i = length - pointsToShift; i < nbPoints; i++) {
     currentX += diff;

package/src/datum/data1d/utils/mapPeaks.ts

@@ -41,7 +41,7 @@ export function mapPeaks(
   const shiftX = getShiftX(spectrum);
   const error = getSpectrumErrorValue(spectrum);
 
-  let newPeaks: Peak1D[] = [];
+  const newPeaks: Peak1D[] = [];
 
   for (const peak of peaks) {
     const peakDelta = getPeakDelta(peak, shiftTarget, shiftX);

package/src/datum/data2d/Entry2D.ts

@@ -10,5 +10,5 @@ export interface Entry2D {
   originalInfo?: Record<string, any>;
   data: NmrData2D;
   originalData?: NmrData2D;
-  filters: Array<Filter>;
+  filters: Filter[];
 }

package/src/datum/data2d/filter2d/fftDimension1.ts

@@ -0,0 +1,93 @@
+import { DoubleArray, NmrData2DFid } from 'cheminfo-types';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry2D } from '../Entry2D';
+import {
+  DirectDimensionOptions,
+  fftDirectDimension,
+} from '../../../xyz/util/fft2d/fftDirectDimension';
+import {
+  xAdd,
+  xEnsureFloat64,
+  xMultiply,
+  xSubtract,
+} from 'ml-spectra-processing';
+import { Data2DFidComplete } from '../../../utilities/checkData2DFid';
+
+export const id = 'fftDimension1';
+export const name = 'FFT Dimension 1';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: true,
+};
+
+export function apply(datum2D: Entry2D, options: DirectDimensionOptions) {
+  if (!isApplicable(datum2D)) {
+    throw new Error('fft dimension 1 not applicable on this data');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { data, info } = datum2D;
+  const { digitalFilter: digitalFilterValue = 0 } = info;
+
+  const fnMode = info.fnMode[1].toLowerCase();
+  const orderedData =
+    fnMode === 'echo-antiecho'
+      ? echoQuadrature(data)
+      : {
+          re: data.re.z,
+          im: data.im.z,
+        };
+
+  const { zeroFilling = {} } = options;
+
+  const nbColumns = orderedData.re[0].length;
+
+  const { factor = 1 } = zeroFilling;
+  const nbPoints =
+    zeroFilling?.nbPoints || 2 ** Math.round(Math.log2(nbColumns * factor));
+  const transformed = fftDirectDimension(orderedData, {
+    fnMode,
+    ...options,
+    digitalFilterValue,
+    zeroFilling: { nbPoints },
+  });
+  datum2D.data.re.z = transformed.re.to2DArray().map(xEnsureFloat64);
+  datum2D.data.im.z = transformed.im.to2DArray().map(xEnsureFloat64);
+}
+
+export function isApplicable(
+  datum2D: Entry2D,
+): datum2D is Entry2D & { data: Required<NmrData2DFid> } {
+  if (datum2D.info.isComplex && datum2D.info.isFid) return true;
+  return false;
+}
+
+export function reduce() {
+  return {
+    once: true,
+    reduce: undefined,
+  };
+}
+
+function echoQuadrature(data: Data2DFidComplete) {
+  const {
+    re: { z: reMatrix },
+    im: { z: imMatrix },
+  } = data;
+  const newRe: DoubleArray[] = [];
+  const newIm: DoubleArray[] = [];
+  for (let i = 0; i < reMatrix.length; i += 2) {
+    const reCosine = reMatrix[i];
+    const imCosine = imMatrix[i];
+    const reSine = reMatrix[i + 1];
+    const imSine = imMatrix[i + 1];
+
+    newRe.push(xSubtract(xMultiply(imSine, -1), imCosine));
+    newRe.push(xSubtract(reSine, reCosine));
+    newIm.push(xAdd(reSine, reCosine));
+    newIm.push(xSubtract(imSine, imCosine));
+  }
+
+  return { re: newRe, im: newIm };
+}

package/src/datum/data2d/filter2d/fftDimension2.ts

@@ -0,0 +1,94 @@
+import { NmrData2DFid, NmrData2DFt } from 'cheminfo-types';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry2D } from '../Entry2D';
+import {
+  IndirectDimensionOptions,
+  fftIndirectDimension,
+} from '../../../xyz/util/fft2d/fftIndirectDimension';
+import { xEnsureFloat64 } from 'ml-spectra-processing';
+import { getMinMaxXY } from '../../../xyz/util/getMinMaxXY';
+import Matrix from 'ml-matrix';
+
+export const id = 'fftDimension2';
+export const name = 'FFT Dimension 2';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: true,
+};
+
+export function apply(datum2D: Entry2D, options: IndirectDimensionOptions) {
+  if (!isApplicable(datum2D)) {
+    throw new Error('fft dimension 2 not applicable on this data');
+  }
+  const { data, info } = datum2D;
+  const fnMode = info.fnMode[1];
+
+  const orderedData = {
+    re: data.re.z,
+    im: data.im.z,
+  };
+
+  const { zeroFilling = {} } = options;
+  const nbRows = orderedData.re.length;
+  const { factor = 2 } = zeroFilling;
+  const nbPoints =
+    zeroFilling?.nbPoints || 2 ** Math.round(Math.log2(nbRows * factor));
+  const transformed = fftIndirectDimension(
+    {
+      re: orderedData.re,
+      im: orderedData.im,
+    },
+    {
+      fnMode,
+      ...options,
+      zeroFilling: { nbPoints },
+    },
+  );
+  (datum2D.data as NmrData2DFt) = {
+    ...getQuadrants(transformed, info),
+  };
+  const { isFid, isComplex, ...resInfo } = info;
+  datum2D.info = {
+    ...resInfo,
+    isFt: true,
+  };
+}
+function getQuadrants(
+  transformed: Record<string, Matrix>,
+  info: Record<string, any>,
+): NmrData2DFt {
+  const quadrants: Partial<NmrData2DFt> = {};
+  const { fnMode } = info;
+  const minMaxXY = getMinMaxXY(info);
+  const buildQuandrants = (keys: Array<'rr' | 'ir' | 'ri' | 'ii'>) => {
+    for (const key of keys) {
+      quadrants[key] = {
+        z: transformed[key].to2DArray().map(xEnsureFloat64),
+        maxZ: transformed[key].max(),
+        minZ: transformed[key].min(),
+        ...minMaxXY,
+      };
+    }
+    return quadrants as NmrData2DFt;
+  };
+
+  if (fnMode === 'QF') {
+    return buildQuandrants(['rr', 'ir']);
+  }
+
+  return buildQuandrants(['rr', 'ir', 'ri', 'ii']);
+}
+export function isApplicable(
+  datum2D: Entry2D,
+): datum2D is Entry2D & { data: Required<NmrData2DFid> } {
+  if (datum2D.info.isComplex && datum2D.info.isFid) return true;
+  return false;
+}
+
+export function reduce() {
+  return {
+    once: true,
+    reduce: undefined,
+  };
+}

package/src/datum/data2d/utils/getShift.ts

@@ -7,7 +7,7 @@ export interface Shift2D {
 }
 
 export function getShift(spectrum: Entry2D): Shift2D {
-  let shift = { x: 0, y: 0 };
+  const shift = { x: 0, y: 0 };
   if (spectrum?.filters) {
     for (const filter of spectrum.filters) {
       if (filter.name === Filters.shift2DX.id) {

package/src/ml-tree-set.d.ts

@@ -3,7 +3,7 @@ declare module 'ml-tree-set' {
   type Elements = any;
   export default class TreeSet {
     public length: number;
-    public elements: Array<w>;
+    public elements: w[];
 
     public constructor(comparator: Comparator);
 

package/src/multiplicity/splitPatterns.ts

@@ -15,7 +15,7 @@ possiblePatterns = possiblePatterns.sort((a, b) => b.length - a.length);
 export function splitPatterns(multiplet: string) {
   if (/^\s*$/.exec(multiplet)) return [];
   const regexp = new RegExp(possiblePatterns.join('|'), 'g');
-  let result = multiplet.match(regexp);
+  const result = multiplet.match(regexp);
   if (result) return result.map((entry) => entry.trim());
   return [multiplet];
 }

package/src/peaks/peaksFilterImpurities.ts

@@ -38,14 +38,15 @@ export function peaksFilterImpurities<T extends NMRPeak1D>(
   peakList: T[],
   options: OptionsPeaksFilterImpurities = {},
 ) {
-  let { solvent, error = 0.025, remove = false } = options;
+  const { error = 0.025, remove = false } = options;
 
-  if (solvent) {
+  if (options.solvent) {
+    let { solvent } = options;
     if (solvent === '(cd3)2so') solvent = 'dmso';
     if (solvent === 'meod') solvent = 'cd3od';
-    let solventImpurities = impurities[solvent];
-    for (let impurity of toCheck) {
-      let impurityShifts = solventImpurities[impurity];
+    const solventImpurities = impurities[solvent];
+    for (const impurity of toCheck) {
+      const impurityShifts = solventImpurities[impurity];
       checkImpurity(peakList, impurityShifts, {
         error,
         remove,
@@ -61,7 +62,7 @@ function checkImpurity<T extends NMRPeak1D>(
   impurity: ImpuritySignal[],
   options: OptionsCheckImpurity,
 ) {
-  let { name, error, remove } = options;
+  const { name, error, remove } = options;
   let j, tolerance, difference;
   let i = impurity.length;
   while (i--) {

package/src/peaks/peaksToRanges.ts

@@ -122,7 +122,7 @@ export function peaksToRanges(
   peakList: NMRPeak1DIntern[],
   options: OptionsPeaksToRanges = {},
 ): NMRRange[] {
-  let {
+  const {
     integrationSum = 100,
     joinOverlapRanges = true,
     clean = 0.4,
@@ -134,7 +134,7 @@ export function peaksToRanges(
     nucleus = '1H',
   } = options;
 
-  let signalOptions = {
+  const signalOptions = {
     integrationSum,
     integralType,
     frequencyCluster,
@@ -149,7 +149,7 @@ export function peaksToRanges(
     data.y = data.y.reverse();
   }
 
-  let signals = detectSignals(data, peakList, signalOptions);
+  const signals = detectSignals(data, peakList, signalOptions);
   if (clean) {
     for (let i = 0; i < signals.length; i++) {
       if (Math.abs(signals[i].integralData.value) < clean) {
@@ -162,7 +162,7 @@ export function peaksToRanges(
     let nHi, sum;
     for (let i = 0; i < signals.length; i++) {
       signals[i] = jAnalyzer.compilePattern(signals[i]);
-      let signal = signals[i];
+      const signal = signals[i];
       if (
         signal.maskPattern &&
         signal.multiplicity !== 'm' &&
@@ -172,11 +172,11 @@ export function peaksToRanges(
         // Create a new signal with the removed peaks
         nHi = 0;
         sum = 0;
-        let peaksO = [];
+        const peaksO = [];
         for (let j = signal.maskPattern.length - 1; j >= 0; j--) {
           sum += computeArea(signal.peaks[j], frequency);
           if (!signal.maskPattern[j]) {
-            let peakR = signal.peaks.splice(j, 1)[0];
+            const peakR = signal.peaks.splice(j, 1)[0];
             peaksO.push({
               x: peakR.x,
               y: peakR.intensity,
@@ -192,12 +192,12 @@ export function peaksToRanges(
         if (peaksO.length > 0) {
           nHi = (nHi * signal.integralData.value) / sum;
           signal.integralData.value -= nHi;
-          let peaks1 = [];
+          const peaks1 = [];
           for (let j = peaksO.length - 1; j >= 0; j--) {
             peaks1.push(peaksO[j]);
           }
           signalOptions.integrationSum = Math.abs(nHi);
-          let ranges = detectSignals(data, peaks1, signalOptions);
+          const ranges = detectSignals(data, peaks1, signalOptions);
 
           for (const range of ranges) {
             signals.push(range);
@@ -223,7 +223,7 @@ export function peaksToRanges(
 
   let ranges: NMRRange[] = [];
   for (let i = 0; i < signals.length; i++) {
-    let signal = signals[i];
+    const signal = signals[i];
     const range: NMRRange = {
       id: generateID(),
       from: signal.integralData.from,
@@ -277,27 +277,28 @@ export function detectSignals(
   peakList: NMRPeak1DIntern[],
   options: OptionsDetectSignals = {},
 ): SignalIntern[] {
-  let {
+  const {
+    frequencyCluster = 16,
     integrationSum = 100,
     integralType = 'sum',
-    frequencyCluster = 16,
     frequency = 400,
     nucleus = '1H',
   } = options;
 
   let signal1D: SignalIntern = assignSignal(peakList[0], frequency, nucleus);
   let peaks;
-  let signals = [];
+  const signals = [];
   let prevPeak = { x: Number.MIN_SAFE_INTEGER };
 
-  frequencyCluster /= frequency;
+  const distantToClustering = frequencyCluster / frequency;
+
   for (const peak of peakList) {
-    if (Math.abs(peak.x - prevPeak.x) > frequencyCluster) {
+    if (Math.abs(peak.x - prevPeak.x) > distantToClustering) {
       signal1D = assignSignal(peak, frequency, nucleus);
       if (peak.kind) signal1D.kind = peak.kind;
       signals.push(signal1D);
     } else {
-      let tmp = peak.x + peak.width / frequency;
+      const tmp = peak.x + peak.width / frequency;
       signal1D.stopX = Math.max(signal1D.stopX, tmp);
       signal1D.startX = Math.min(signal1D.startX, tmp);
       signal1D.nbPeaks++;
@@ -318,14 +319,14 @@ export function detectSignals(
     }
     prevPeak = peak;
   }
-  for (let signal of signals) {
+  for (const signal of signals) {
     peaks = signal.peaks;
-    let integration = signal.integralData;
+    const integration = signal.integralData;
     let chemicalShift = 0;
     let integralPeaks = 0;
 
     for (const peak of peaks) {
-      let area = computeArea(peak, frequency);
+      const area = computeArea(peak, frequency);
       chemicalShift += peak.x * area;
       integralPeaks += area;
     }