nmr-processing 8.2.0 → 8.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nmr-processing",
-  "version": "8.2.0",
+  "version": "8.4.0",
   "description": "Pure functions allowing to process NMR spectra.",
   "main": "./lib/index.js",
   "module": "./lib-esm/index.js",
@@ -38,21 +38,21 @@
   },
   "homepage": "https://github.com/cheminfo/nmr-processing#readme",
   "devDependencies": {
-    "@types/jest": "^27.5.0",
+    "@types/jest": "^28.1.4",
     "cheminfo-build": "^1.1.11",
-    "cheminfo-types": "^1.1.0",
-    "eslint": "^8.14.0",
-    "eslint-config-cheminfo-typescript": "^10.4.0",
-    "jest": "^28.0.3",
+    "cheminfo-types": "^1.2.0",
+    "eslint": "^8.19.0",
+    "eslint-config-cheminfo-typescript": "^11.0.1",
+    "jest": "^28.1.2",
     "jest-matcher-deep-close-to": "^3.0.2",
     "md5": "^2.3.0",
     "ml-array-median": "^1.1.6",
     "nmr-xy-testdata": "^0.5.1",
     "openchemlib": "^7.4.3",
-    "prettier": "^2.6.2",
+    "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-jest": "^28.0.1",
-    "typescript": "^4.6.4"
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.7.4"
   },
   "dependencies": {
     "binary-search": "^1.3.6",
@@ -65,18 +65,18 @@
     "ml-array-rescale": "^1.3.7",
     "ml-array-sequential-fill": "^1.1.8",
     "ml-array-sum": "^1.1.6",
-    "ml-gsd": "^11.2.0",
+    "ml-gsd": "^11.2.1",
     "ml-hclust": "^3.1.0",
     "ml-levenberg-marquardt": "^4.1.0",
-    "ml-matrix": "^6.10.0",
+    "ml-matrix": "^6.10.2",
     "ml-matrix-convolution": "^1.0.0",
     "ml-matrix-peaks-finder": "^1.0.0",
     "ml-peak-shape-generator": "^4.1.1",
     "ml-simple-clustering": "^0.1.0",
     "ml-sparse-matrix": "^2.1.0",
-    "ml-spectra-processing": "^11.5.0",
+    "ml-spectra-processing": "^11.7.0",
     "ml-tree-set": "^0.1.1",
-    "nmr-correlation": "^2.2.5",
+    "nmr-correlation": "^2.3.2",
     "openchemlib-utils": "^1.11.0",
     "spectrum-generator": "^8.0.2"
   }

package/src/apodization/apodization.ts

@@ -0,0 +1,34 @@
+import { DoubleArray } from 'cheminfo-types';
+
+import { applyWindow } from './applyWindow';
+import { compose, ShapeOptions } from './compose';
+
+export interface DataReIm {
+  /** Array of re values */
+  re: DoubleArray;
+  /** Array of im values */
+  im: DoubleArray;
+}
+
+interface ApodizationOptions {
+  /**
+   * number of points at the end of the shape to apply the window function inverted
+   * @default 0
+   */
+  pointsToShift?: number;
+  compose: ShapeOptions;
+}
+export function apodization(data: DataReIm, options: ApodizationOptions) {
+  const { compose: composeOptions, pointsToShift } = options;
+  const windowData = compose(composeOptions);
+
+  const applyWindowOptions = {
+    windowData,
+    pointsToShift,
+  };
+
+  const re = applyWindow(data.re, applyWindowOptions);
+  const im = applyWindow(data.im, applyWindowOptions);
+
+  return { re, im, windowData };
+}

package/src/apodization/applyWindow.ts

@@ -0,0 +1,51 @@
+import { DoubleArray } from 'cheminfo-types';
+
+export interface ApplyWindowOptions {
+  /**
+   * data of a window function it should be scaled to max = 1 to ensure compatibility with new apodizations.
+   */
+  windowData: DoubleArray;
+  /**
+   * Start Location for Applying Apodize Window
+   */
+  start?: number;
+  /**
+   * length of the window function
+   */
+  length?: number;
+  /**
+   * number of points at the end of the shape to apply the window function inverted
+   * @default 0
+   */
+  pointsToShift?: number;
+  /**
+   * output array
+   */
+  output?: DoubleArray;
+}
+
+/**
+ * pure function that applies a window function to the input data.
+ */
+export function applyWindow(data: DoubleArray, options: ApplyWindowOptions) {
+  const dataLength = data.length;
+
+  const {
+    windowData,
+    start = 0,
+    length = dataLength,
+    pointsToShift = 0,
+    output = new Float64Array(data),
+  } = options;
+
+  const firstEndPoint = Math.min(start + length, dataLength - pointsToShift);
+  for (let i = start, j = 0; i < firstEndPoint; i++) {
+    output[i] *= windowData[j++];
+  }
+
+  for (let i = dataLength - 1, j = 0; i > dataLength - pointsToShift - 1; i--) {
+    output[i] *= windowData[j++];
+  }
+
+  return output;
+}

package/src/apodization/compose.ts

@@ -0,0 +1,47 @@
+import { applyWindow } from './applyWindow';
+import { getFunction } from './getFunction';
+import type { WindowFunctions } from './shapes/WindowFunctions';
+import { getData } from './utils/getData';
+
+interface ShapeToAdd {
+  /**
+   * Start Location for Applying Apodize Window
+   */
+  start?: number;
+  /**
+   * parameters of the shape plus the kind of shape to identify
+   */
+  shape: WindowFunctions;
+}
+
+export interface ShapeOptions {
+  /**
+   * length of the window shape
+   */
+  length: number;
+
+  /**
+   * parameters of the shape plus the kind of shape to identify
+   */
+  shapes?: ShapeToAdd[];
+}
+
+export function compose(shapeOptions: ShapeOptions) {
+  const { length: dataLength, shapes = [] } = shapeOptions;
+  let data = new Float64Array(dataLength).fill(1);
+  shapes.forEach((options) => {
+    const { shape, start = 0 } = options;
+    const { options: shapeOptions } = shape;
+    const length =
+      'length' in shapeOptions ? shapeOptions.length : dataLength - start;
+
+    const windowData = getData(getFunction(shape), length);
+    applyWindow(data, {
+      windowData,
+      length,
+      start,
+      output: data,
+    });
+  });
+  return data;
+}

package/src/apodization/getFunction.ts

@@ -0,0 +1,15 @@
+import type { WindowFunctions } from './shapes/WindowFunctions';
+import { exponential } from './shapes/exponential';
+import { lorentzToGauss } from './shapes/lorentzToGauss';
+
+export function getFunction(shape: WindowFunctions) {
+  const { kind, options } = shape;
+  switch (kind) {
+    case 'exponential':
+      return exponential(options);
+    case 'lorentzToGauss':
+      return lorentzToGauss(options);
+    default:
+      throw Error(`Unknown distribution ${kind as string}`);
+  }
+}

package/src/apodization/shapes/WindowFunctions.ts

@@ -0,0 +1,14 @@
+import type { ExponentialOptions } from './exponential';
+import type { LorentzToGaussOptions } from './lorentzToGauss';
+
+interface Exponential {
+  kind: 'exponential';
+  options: ExponentialOptions;
+}
+
+interface LorentToGauss {
+  kind: 'lorentzToGauss';
+  options: LorentzToGaussOptions;
+}
+
+export type WindowFunctions = Exponential | LorentToGauss;

package/src/apodization/shapes/exponential.ts

@@ -0,0 +1,16 @@
+export interface ExponentialOptions {
+  /**
+   * line broadening value in Hz, a negative value will invert the shape
+   */
+  lb: number;
+  /**
+   * increment value in time or the independent value
+   */
+  dw: number;
+}
+
+export function exponential(options: ExponentialOptions) {
+  const { lb, dw } = options;
+  const coefExp = -lb * Math.PI * dw;
+  return (i: number) => Math.exp(coefExp * i);
+}

package/src/apodization/shapes/lorentzToGauss.ts

@@ -0,0 +1,41 @@
+export interface LorentzToGaussOptions {
+  /**
+   * size of the shape function
+   */
+  length: number;
+  /**
+   * increment value in time or the independent value
+   */
+  dw: number;
+  /**
+   * Gaussian Broaden Width, Hz
+   * @default 0
+   */
+  gaussianHz?: number;
+  /**
+   * Inverse Exponential Width, Hz
+   * @default 0
+   */
+  exponentialHz?: number;
+  /**
+   * Location of Gauss Maximum, this value should be between 0 to 1
+   * @default 0
+   */
+  center?: number;
+}
+
+export function lorentzToGauss(options: LorentzToGaussOptions) {
+  const { dw, length, gaussianHz = 0, exponentialHz = 0, center = 0 } = options;
+
+  if (center > 1 || center < 0) {
+    throw new Error(
+      'The center of gaussian shape should be inside of the window function: 0 - 1',
+    );
+  }
+
+  const C5 = Math.pow(0.6 * Math.PI * gaussianHz * dw, 2);
+  const C2 = center * (length - 1);
+  const C6 = Math.PI * dw * exponentialHz;
+
+  return (i: number) => Math.exp(i * C6 - Math.pow(C2 - i, 2) * C5);
+}

package/src/apodization/utils/getData.ts

@@ -0,0 +1,15 @@
+/**
+ * generate and scale the data of a window function
+ */
+export function getData(func: (i: number) => number, length: number) {
+  const data = new Float64Array(length);
+  let max = Number.MIN_SAFE_INTEGER;
+  for (let i = 0; i < length; i++) {
+    const value = func(i);
+    data[i] = value;
+    if (value > max) max = value;
+  }
+
+  for (let i = 0; i < length; i++) data[i] /= max;
+  return data;
+}

package/src/assignment/utils/buildAssignments.ts

@@ -1,4 +1,4 @@
-import treeSet from 'ml-tree-set';
+import TreeSet from 'ml-tree-set';
 
 import { Targets, NMRSignal1DWithAtomsAndDiaIDs } from '../get1HAssignments';
 
@@ -38,7 +38,7 @@ export interface Predictions1Dassignments {
 }
 
 export interface StoreAssignments {
-  solutions: treeSet;
+  solutions: TreeSet;
   nSolutions: number;
 }
 
@@ -64,7 +64,7 @@ export async function buildAssignments(props: BuildAssignmentsProps) {
   let timeStart = date.getTime();
 
   let store: StoreAssignments = {
-    solutions: new treeSet(comparator),
+    solutions: new TreeSet(comparator),
     nSolutions: 0,
   };
 
@@ -97,7 +97,7 @@ export async function buildAssignments(props: BuildAssignmentsProps) {
   let partial = fillPartial(nSources);
 
   store = {
-    solutions: new treeSet(comparator),
+    solutions: new TreeSet(comparator),
     nSolutions: 0,
   };
 

package/src/assignment/utils/exploreTreeRec.ts

@@ -113,7 +113,7 @@ function addSolution(store: StoreAssignments, props: AddSolutionProps) {
   store.nSolutions++;
   let solution: SolutionAssignment = {
     assignment: JSON.parse(JSON.stringify(partial)),
-    score: score,
+    score,
   };
 
   if (store.nSolutions >= maxSolutions) {

package/src/assignment/utils/getAssignment/buildAssignments.ts

@@ -1,4 +1,4 @@
-import treeSet from 'ml-tree-set';
+import TreeSet from 'ml-tree-set';
 import { Values } from 'nmr-correlation';
 import { Molecule } from 'openchemlib';
 import { getConnectivityMatrix } from 'openchemlib-utils';
@@ -135,7 +135,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
   let lowerBoundScore = minScore;
 
   let store: StoreAssignments = {
-    solutions: new treeSet(comparator),
+    solutions: new TreeSet(comparator),
     nSolutions: 0,
   };
 
@@ -204,7 +204,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
     );
 
     store = {
-      solutions: new treeSet(comparator),
+      solutions: new TreeSet(comparator),
       nSolutions: 0,
     };
 

package/src/databases/DatabaseNMREntry.ts

@@ -1,6 +1,9 @@
+import { OCLMolecule } from 'cheminfo-types';
+
 import { NMRRange } from '../xy/NMRRange';
 
 export interface DatabaseNMREntry {
+  ocl?: OCLMolecule;
   smiles?: string;
   solvent: string;
   nucleus: string;

package/src/index.ts

@@ -40,6 +40,8 @@ export * from './databases/protonImpurities';
 export * from './peaks/solventSuppression';
 export * from './ranges/markSolventSignal';
 
+export * from './apodization/apodization';
+
 export type { NMRSignal1D } from './signals/NMRSignal1D';
 export type { NMRSignal2D, Signal2DProjection } from './xyz/NMRSignal2D';
 export type { NMRRange } from './xy/NMRRange';

package/src/peaks/peaksToRanges.ts

@@ -174,7 +174,7 @@ export function peaksToRanges(
         let peaksO = [];
         for (let j = signal.maskPattern.length - 1; j >= 0; j--) {
           sum += computeArea(signal.peaks[j]);
-          if (signal.maskPattern[j] === false) {
+          if (!signal.maskPattern[j]) {
             let peakR = signal.peaks.splice(j, 1)[0];
             peaksO.push({
               x: peakR.x,

package/src/peaks/solventSuppression.ts

@@ -15,7 +15,7 @@ import { NMRPeak1D } from './NMRPeak1D';
 export function solventSuppression<T extends NMRPeak1D>(
   peakList: T[],
   solvent: NMRSignal1D[],
-  options: any = {},
+  options: { markSolventPeaks?: boolean; solventZoneExtension?: number } = {},
 ) {
   const peaks = [...peakList].sort((a, b) => a.x - b.x);
 
@@ -38,9 +38,9 @@ export function solventSuppression<T extends NMRPeak1D>(
       solventXYPeaks[0].x - solventZoneExtension,
     );
 
-    if (upIndex === lowIndex) continue;
-    const nearPeaks = peaks.slice(lowIndex, upIndex + 1);
-
+    const nearPeaks = peaks.filter(
+      (peak, index) => index >= lowIndex && index <= upIndex,
+    );
     const amplitudeResiduals = [];
     const deltaResiduals = [];
     const positionResiduals = [];
@@ -76,9 +76,14 @@ export function solventSuppression<T extends NMRPeak1D>(
       positionResiduals.push(positionResidual);
     }
 
-    const maxAmplitude = xMaxValue(amplitudeResiduals);
-    const maxDelta = xMaxValue(deltaResiduals);
-    const maxPosition = xMaxValue(positionResiduals);
+    const [maxAmplitude, maxDelta, maxPosition] = [
+      amplitudeResiduals,
+      deltaResiduals,
+      positionResiduals,
+    ].map((data) => {
+      const max = xMaxValue(data);
+      return max === 0 ? 1 : max;
+    });
 
     let minIndex = -1;
     let minScore = Number.MAX_SAFE_INTEGER;
@@ -98,7 +103,7 @@ export function solventSuppression<T extends NMRPeak1D>(
       }
     }
 
-    if (minScore < 0) {
+    if (minScore < 0 || minIndex < 0) {
       new Error('There is not a correct match with the pattern');
       return peaks;
     }

package/src/peaks/util/jAnalyzer.ts

@@ -120,10 +120,8 @@ export default {
         // Lets check if the signal could be a singulet.
         if (peaks.length === 1 && n === 0) {
           validPattern = true;
-        } else {
-          if (peaks.length <= 1) {
-            continue;
-          }
+        } else if (peaks.length <= 1) {
+          continue;
         }
         // 1.3 Establish a range for the Heights Hi [peaks.intensity*0.85,peaks.intensity*1.15];
         let ranges = getRanges(peaks);
@@ -399,7 +397,7 @@ function getRanges(peaks: Peak1DIntern[]): GetRanges {
     }
     currentIndex[i] = 0;
   }
-  return { values: ranges, currentIndex: currentIndex, active: 0 };
+  return { values: ranges, currentIndex, active: 0 };
 }
 /**
  * Performs a symmetrization of the signal by using different aproximations to the center.
@@ -533,20 +531,20 @@ function symmetrize(
         if (Math.abs(diffL - diffR) < maxError) {
           avg = Math.min(peaks[left].intensity, peaks[right].intensity);
           avgWidth = Math.min(peaks[left].width, peaks[right].width);
-          peaks[left].intensity = peaks[right].intensity = avg;
-          peaks[left].width = peaks[right].width = avgWidth;
+          peaks[left].intensity = avg;
+          peaks[right].intensity = avg;
+          peaks[left].width = avgWidth;
+          peaks[right].width = avgWidth;
           middle = [
             middle[0] + (peaks[right].x + peaks[left].x) / 2,
             middle[1] + 1,
           ];
+        } else if (Math.max(diffL, diffR) === diffR) {
+          mask[right] = false;
+          left--;
         } else {
-          if (Math.max(diffL, diffR) === diffR) {
-            mask[right] = false;
-            left--;
-          } else {
-            mask[left] = false;
-            right++;
-          }
+          mask[left] = false;
+          right++;
         }
       }
     }
@@ -595,10 +593,8 @@ function symmetrize(
       weight += peaks[i].intensity;
     }
     symFactor /= weight;
-  } else {
-    if (peaks.length === 1) {
-      symFactor = 1;
-    }
+  } else if (peaks.length === 1) {
+    symFactor = 1;
   }
   let newSumHeights = 0;
   for (const peak of peaks) {
@@ -608,15 +604,13 @@ function symmetrize(
   // Sometimes we need a second opinion after the first symmetrization.
   if (symFactor > 0.8 && symFactor < 0.97 && iteration < 2) {
     return symmetrize(newSignal, maxErrorIter2, 2, key);
-  } else {
+  } else if (peaks.length > 1) {
     // Center the given pattern at cs and symmetrize x
-    if (peaks.length > 1) {
-      let dxi;
-      for (let i = Math.ceil(peaks.length / 2) - 1; i >= 0; i--) {
-        dxi = (peaks[i].x - peaks[peaks.length - 1 - i].x) / 2.0;
-        peaks[i].x = cs + dxi;
-        peaks[peaks.length - 1 - i].x = cs - dxi;
-      }
+    let dxi;
+    for (let i = Math.ceil(peaks.length / 2) - 1; i >= 0; i--) {
+      dxi = (peaks[i].x - peaks[peaks.length - 1 - i].x) / 2.0;
+      peaks[i].x = cs + dxi;
+      peaks[peaks.length - 1 - i].x = cs - dxi;
     }
   }
   newSignal.symRank = symFactor;
@@ -660,7 +654,7 @@ function normalize(signal: SignalInternMandatory, n: number) {
   let index = signal.mask2.length - 1;
   for (let i = peaks.length - 1; i >= 0; i--) {
     peaks[i].intensity *= norm;
-    while (index >= 0 && signal.mask2[index] === false) {
+    while (index >= 0 && !signal.mask2[index]) {
       index--;
     }
     if (peaks[i].intensity < 0.75) {
@@ -691,7 +685,7 @@ function chemicalShift(peaks: Peak1DIntern[], mask: boolean[] = []) {
   let area;
   if (mask.length > 0) {
     for (let i = 0; i < peaks.length; i++) {
-      if (mask[i] === true) {
+      if (mask[i]) {
         area = getArea(peaks[i]);
         sum += area;
         cs += area * peaks[i].x;

package/src/peaks/util/peakOptimizer.ts

@@ -138,7 +138,7 @@ function completeMissingIfNeeded(
       }
     }
   }
-  if (diagX === false) {
+  if (!diagX) {
     newSignal = {
       x: {
         delta: thisSignal.y.delta,
@@ -158,7 +158,7 @@ function completeMissingIfNeeded(
     properties.push(tmpProp);
     addedPeaks++;
   }
-  if (diagY === false) {
+  if (!diagY) {
     newSignal = {
       x: {
         delta: thisSignal.y.delta,
@@ -202,15 +202,13 @@ function checkCrossPeaks(
         }
         crossPeaksX.push(i);
         shift += cross.x.delta;
-      } else {
-        if (Math.abs(cross.y.delta - signal.y.delta) < diagonalError) {
-          hits++;
-          if (updateProperties) {
-            properties[i][1]++;
-          }
-          crossPeaksY.push(i);
-          shift += cross.y.delta;
+      } else if (Math.abs(cross.y.delta - signal.y.delta) < diagonalError) {
+        hits++;
+        if (updateProperties) {
+          properties[i][1]++;
         }
+        crossPeaksY.push(i);
+        shift += cross.y.delta;
       }
     }
   }
@@ -278,12 +276,10 @@ function initializeProperties(signals: NMRSignal2D[]) {
       let shift = (signals[i].x.delta * 2 + signals[i].y.delta) / 3.0;
       signals[i].x.delta = shift;
       signals[i].y.delta = shift;
+    } else if (signals[i].x.delta - signals[i].y.delta > 0) {
+      signalsProperties[i][0] = 1;
     } else {
-      if (signals[i].x.delta - signals[i].y.delta > 0) {
-        signalsProperties[i][0] = 1;
-      } else {
-        signalsProperties[i][0] = -1;
-      }
+      signalsProperties[i][0] = -1;
     }
   }
   return signalsProperties;

package/src/prediction/predictAllSpectra.ts

@@ -172,14 +172,12 @@ function calculateFrequency(
 ): number | string {
   if (typeof nucleus === 'string') {
     return getFrequency(nucleus, { nucleus: '1H', frequency });
+  } else if (nucleus[0] === nucleus[1]) {
+    return `${frequency},${frequency}`;
   } else {
-    if (nucleus[0] === nucleus[1]) {
-      return `${frequency},${frequency}`;
-    } else {
-      return `${frequency},${getFrequency(nucleus[1], {
-        nucleus: nucleus[0],
-        frequency,
-      })}`;
-    }
+    return `${frequency},${getFrequency(nucleus[1], {
+      nucleus: nucleus[0],
+      frequency,
+    })}`;
   }
 }

package/src/prediction/predictCarbon.ts

@@ -119,7 +119,7 @@ function formatSignals(predictions: Prediction[]) {
     const signal = {
       delta: delta || NaN,
       atoms,
-      diaIDs: diaIDs,
+      diaIDs,
       multiplicity: 's',
       nbAtoms,
       statistic,

package/src/prediction/utils/queryByHOSE.ts

@@ -40,7 +40,7 @@ export function queryByHose(
         delta: res ? res[0] : null,
         atoms: [atomNumber],
         nbAtoms: 1,
-        level: level,
+        level,
         statistic:
           res && res.length > 1
             ? {