nmr-processing 8.1.0 → 8.3.1

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/assignment/utils/getAssignment/checkIDs.ts

@@ -42,7 +42,7 @@ export function hasIDs(
   }
 }
 
-export function addIDs(data: NMRRange[] | NMRZone[]) {
+export function addIDs<T extends NMRRange[] | NMRZone[]>(data: T) {
   for (const element of data) {
     if (!element.id) element.id = generateID();
     for (let signal of element.signals || []) {

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

@@ -37,6 +37,11 @@ export * from './databases/getDatabase';
 export * from './databases/carbonImpurities';
 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,
@@ -281,7 +281,7 @@ export function peaksToRanges(
  * @private
  */
 
-function detectSignals(
+export function detectSignals(
   data: DataXY,
   peakList: NMRPeak1DIntern[],
   options: OptionsDetectSignals = {},

package/src/peaks/solventSuppression.ts

@@ -1,5 +1,5 @@
 import { PointXY } from 'cheminfo-types';
-import linearSumAssignment from 'linear-sum-assignment';
+import { linearSumAssignment } from 'linear-sum-assignment';
 import { Matrix } from 'ml-matrix';
 import { gaussianFct } from 'ml-peak-shape-generator';
 import { xFindClosestIndex, xMaxValue } from 'ml-spectra-processing';
@@ -12,45 +12,47 @@ import { splitSpinSystem } from '../signals/simulation/splitSpinSystem';
 
 import { NMRPeak1D } from './NMRPeak1D';
 
-export function solventSuppression(
-  peakList: NMRPeak1D[],
+export function solventSuppression<T extends NMRPeak1D>(
+  peakList: T[],
   solvent: NMRSignal1D[],
-  options: any = {},
+  options: { markSolventPeaks?: boolean; solventZoneExtension?: number } = {},
 ) {
-  const peaks = [...peakList];
-  sortAscending(peaks);
-  const xValues = peaks.map((peak) => peak.x);
+  const peaks = [...peakList].sort((a, b) => a.x - b.x);
 
-  const { markSolventPeaks = false } = options;
+  const xValues = peaks.map((peak) => peak.x);
 
-  let solventSignals = solvent; //addDummySignals(solvent);
-  // solventSignals = solventSignals.slice(0, solventSignals.findIndex((signal) => signal.delta > 400));
+  const { markSolventPeaks = false, solventZoneExtension = 1.2 } = options;
 
-  for (const solventSignal of solventSignals) {
-    const solventXYPeaks = solventSignal.peaks
+  for (const solventSignal of solvent) {
+    let solventXYPeaks = solventSignal.peaks
       ? solventSignal.peaks
       : getSolventPeaks(solventSignal);
-    sortAscending(solventXYPeaks);
+    solventXYPeaks.sort((a, b) => a.x - b.x);
+
     let upIndex = xFindClosestIndex(
       xValues,
-      solventXYPeaks[solventXYPeaks.length - 1].x + 1,
+      solventXYPeaks[solventXYPeaks.length - 1].x + solventZoneExtension,
+    );
+    let lowIndex = xFindClosestIndex(
+      xValues,
+      solventXYPeaks[0].x - solventZoneExtension,
+    );
+
+    const nearPeaks = peaks.filter(
+      (peak, index) => index >= lowIndex && index <= upIndex,
     );
-    let lowIndex = xFindClosestIndex(xValues, solventXYPeaks[0].x - 1);
-    if (upIndex === lowIndex) continue;
-    const nearPeaks = peaks.slice(lowIndex, upIndex + 1);
     const amplitudeResiduals = [];
     const deltaResiduals = [];
     const positionResiduals = [];
     for (let peak of nearPeaks) {
-      const shiftedSolventPeaks = getShiftedSolventPeaks(
-        peak,
-        solventSignal,
-        solventXYPeaks,
-      );
+      const { peaks: shiftedSolventPeaks, delta: currentDelta } =
+        getShiftedSolventPeaks(peak, solventSignal, solventXYPeaks);
+
       const closestPeaks = getClosestPeaks(shiftedSolventPeaks, nearPeaks);
       let deltaResidual = 0;
       let amplitudeResidual = 0;
       let positionResidual = 0;
+
       for (let i = 0; i < closestPeaks.length; i++) {
         amplitudeResidual += Math.abs(
           shiftedSolventPeaks[i].y - closestPeaks[i].y,
@@ -63,31 +65,50 @@ export function solventSuppression(
         amplitudeResidual = Number.MAX_SAFE_INTEGER;
         positionResidual = Number.MAX_SAFE_INTEGER;
       } else {
-        positionResidual = gaussianFct(solventSignal.delta - peak.x, 0.5);
+        positionResidual = gaussianFct(
+          Math.abs(solventSignal.delta - currentDelta),
+          0.5,
+        );
       }
+
       amplitudeResiduals.push(amplitudeResidual);
       deltaResiduals.push(deltaResidual);
       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;
+    let score = [];
     for (let i = 0; i < deltaResiduals.length; i++) {
       const value =
         (amplitudeResiduals[i] / maxAmplitude +
           deltaResiduals[i] / maxDelta +
-          (1 - positionResiduals[i]) / maxPosition) /
+          1 -
+          positionResiduals[i] / maxPosition) /
         3;
+
+      score.push(value);
       if (minScore > value) {
         minIndex = i;
         minScore = value;
       }
     }
-    const shiftedSolventPeaks = getShiftedSolventPeaks(
+
+    if (minScore < 0 || minIndex < 0) {
+      new Error('There is not a correct match with the pattern');
+      return peaks;
+    }
+
+    const { peaks: shiftedSolventPeaks } = getShiftedSolventPeaks(
       nearPeaks[minIndex],
       solventSignal,
       solventXYPeaks,
@@ -96,7 +117,11 @@ export function solventSuppression(
     const { rowAssignments, gain } = linearSumAssignment(diff, {
       maximaze: false,
     });
-    if (gain === -1) return peaks;
+
+    if (gain < 0) {
+      new Error('The gain is below to zero');
+      return peaks;
+    }
 
     if (markSolventPeaks) {
       for (let index of rowAssignments) {
@@ -131,27 +156,34 @@ function getSolventPeaks(
   return peaks.filter((peak) => peak.x < 1000);
 }
 
-function getShiftedSolventPeaks(
-  peak: PointXY,
+function getShiftedSolventPeaks<T extends PointXY>(
+  peak: T,
   solventSignal: any,
-  solventXYPeaks: PointXY[],
+  solventXYPeaks: T[],
 ) {
   const shiftedSolventPeaks: PointXY[] = JSON.parse(
     JSON.stringify(solventXYPeaks),
   );
   // shift x values of solventPeaks to center it to the current peak.
-  const deltaPPM = peak.x - solventSignal.delta;
+  let deltaPPM = peak.x - solventSignal.delta;
+  if (solventXYPeaks.length > 1 && solventXYPeaks.length % 2 === 0) {
+    deltaPPM += solventXYPeaks[0].x;
+  }
   const maxIntensity = shiftedSolventPeaks.reduce(
     (max, current) => (current.y > max ? current.y : max),
     shiftedSolventPeaks[0].y,
   );
+  let currentDelta = 0;
   for (let shiftedSolventPeak of shiftedSolventPeaks) {
     shiftedSolventPeak.x += deltaPPM;
     shiftedSolventPeak.y /= maxIntensity;
+    currentDelta += shiftedSolventPeak.x;
   }
-  return shiftedSolventPeaks;
+  return {
+    peaks: shiftedSolventPeaks,
+    delta: currentDelta / shiftedSolventPeaks.length,
+  };
 }
-
 function getClosestPeaks(shiftedSolventPeaks: PointXY[], nearPeaks: PointXY[]) {
   const diff = getDiffMatrix(shiftedSolventPeaks, nearPeaks);
   const { rowAssignments, gain } = linearSumAssignment(diff, {
@@ -169,11 +201,7 @@ function getClosestPeaks(shiftedSolventPeaks: PointXY[], nearPeaks: PointXY[]) {
   return assignmentPeaks;
 }
 
-function sortAscending(peaks: PointXY[]) {
-  return peaks[0].x > peaks[1].x ? peaks.sort((a, b) => a.x - b.x) : peaks;
-}
-
-function getDiffMatrix(rows: PointXY[], columns: PointXY[]) {
+function getDiffMatrix<T extends PointXY>(rows: T[], columns: T[]) {
   const nbColumns = columns.length;
   const nbRows = rows.length;
   const diff = new Matrix(nbRows, nbColumns);

package/src/peaks/util/jAnalyzer.ts

@@ -62,10 +62,12 @@ type SignalInternMandatory = MakeMandatory<
 function checkSignalForCompilePattern(
   signal: SignalIntern,
 ): asserts signal is SignalInternMandatory {
-  if (!signal.symRank) {
+  if (!('symRank' in signal)) {
     throw new Error('Internal error, symRank was not calculated');
   }
-  if (!signal.mask) throw new Error('Internal Error, mask was not added');
+  if (!('mask' in signal)) {
+    throw new Error('Internal Error, mask was not added');
+  }
 }
 
 export interface OpitonsCompilePatter {
@@ -118,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);
@@ -397,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.
@@ -531,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++;
         }
       }
     }
@@ -593,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) {
@@ -606,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;
@@ -658,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) {
@@ -689,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
             ? {