nmr-processing 8.0.0 → 8.3.0

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from './constants/gyromagneticRatio';
+export * from 'gyromagnetic-ratio';
 export * from './constants/impurities';
 export * from './constants/couplingPatterns';
 
@@ -37,6 +37,12 @@ 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 * from './apodization/compose';
+
 export type { NMRSignal1D } from './signals/NMRSignal1D';
 export type { NMRSignal2D, Signal2DProjection } from './xyz/NMRSignal2D';
 export type { NMRRange } from './xy/NMRRange';

package/src/peaks/NMRPeak1D.ts

@@ -3,6 +3,5 @@ import type { Shape1D } from 'ml-peak-shape-generator';
 
 export interface NMRPeak1D extends PeakXYWidth {
   kind?: string;
-  fwhm?: number;
   shape?: Shape1D;
 }

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

@@ -0,0 +1,214 @@
+import { PointXY } from 'cheminfo-types';
+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';
+
+import { NMRSignal1D } from '../signals/NMRSignal1D';
+import { addDummySignals } from '../signals/addDummySignals';
+import { signalsToSpinSystem } from '../signals/simulation/signalsToSpinSystem';
+import { simulateXYPeaks } from '../signals/simulation/simulateXYPeaks';
+import { splitSpinSystem } from '../signals/simulation/splitSpinSystem';
+
+import { NMRPeak1D } from './NMRPeak1D';
+
+export function solventSuppression<T extends NMRPeak1D>(
+  peakList: T[],
+  solvent: NMRSignal1D[],
+  options: { markSolventPeaks?: boolean; solventZoneExtension?: number } = {},
+) {
+  const peaks = [...peakList].sort((a, b) => a.x - b.x);
+
+  const xValues = peaks.map((peak) => peak.x);
+
+  const { markSolventPeaks = false, solventZoneExtension = 1.2 } = options;
+
+  for (const solventSignal of solvent) {
+    let solventXYPeaks = solventSignal.peaks
+      ? solventSignal.peaks
+      : getSolventPeaks(solventSignal);
+    solventXYPeaks.sort((a, b) => a.x - b.x);
+
+    let upIndex = xFindClosestIndex(
+      xValues,
+      solventXYPeaks[solventXYPeaks.length - 1].x + solventZoneExtension,
+    );
+    let lowIndex = xFindClosestIndex(
+      xValues,
+      solventXYPeaks[0].x - solventZoneExtension,
+    );
+
+    const nearPeaks = peaks.filter(
+      (peak, index) => index >= lowIndex && index <= upIndex,
+    );
+    const amplitudeResiduals = [];
+    const deltaResiduals = [];
+    const positionResiduals = [];
+    for (let peak of nearPeaks) {
+      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,
+        );
+        deltaResidual += Math.abs(shiftedSolventPeaks[i].x - closestPeaks[i].x);
+      }
+
+      if (closestPeaks.length === 0) {
+        deltaResidual = Number.MAX_SAFE_INTEGER;
+        amplitudeResidual = Number.MAX_SAFE_INTEGER;
+        positionResidual = Number.MAX_SAFE_INTEGER;
+      } else {
+        positionResidual = gaussianFct(
+          Math.abs(solventSignal.delta - currentDelta),
+          0.5,
+        );
+      }
+
+      amplitudeResiduals.push(amplitudeResidual);
+      deltaResiduals.push(deltaResidual);
+      positionResiduals.push(positionResidual);
+    }
+
+    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) /
+        3;
+
+      score.push(value);
+      if (minScore > value) {
+        minIndex = i;
+        minScore = value;
+      }
+    }
+
+    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,
+    );
+    const diff = getDiffMatrix(shiftedSolventPeaks, nearPeaks);
+    const { rowAssignments, gain } = linearSumAssignment(diff, {
+      maximaze: false,
+    });
+
+    if (gain < 0) {
+      new Error('The gain is below to zero');
+      return peaks;
+    }
+
+    if (markSolventPeaks) {
+      for (let index of rowAssignments) {
+        peaks[index + lowIndex].kind = 'solvent';
+      }
+    } else {
+      rowAssignments.sort((a, b) => b - a);
+      for (let index of rowAssignments) {
+        peaks.splice(index + lowIndex, 1);
+      }
+    }
+  }
+
+  return peaks;
+}
+
+function getSolventPeaks(
+  signal: NMRSignal1D,
+  options: { frequency?: number; maxClusterSize?: number } = {},
+) {
+  let signals = addDummySignals([signal]);
+  let spinSystem = signalsToSpinSystem(signals);
+
+  const { frequency = 400, maxClusterSize = 8 } = options;
+
+  spinSystem.clusters = splitSpinSystem(spinSystem, {
+    frequency,
+    maxClusterSize,
+  });
+
+  const peaks = simulateXYPeaks(spinSystem);
+  return peaks.filter((peak) => peak.x < 1000);
+}
+
+function getShiftedSolventPeaks<T extends PointXY>(
+  peak: T,
+  solventSignal: any,
+  solventXYPeaks: T[],
+) {
+  const shiftedSolventPeaks: PointXY[] = JSON.parse(
+    JSON.stringify(solventXYPeaks),
+  );
+  // shift x values of solventPeaks to center it to the current peak.
+  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 {
+    peaks: shiftedSolventPeaks,
+    delta: currentDelta / shiftedSolventPeaks.length,
+  };
+}
+function getClosestPeaks(shiftedSolventPeaks: PointXY[], nearPeaks: PointXY[]) {
+  const diff = getDiffMatrix(shiftedSolventPeaks, nearPeaks);
+  const { rowAssignments, gain } = linearSumAssignment(diff, {
+    maximaze: false,
+  });
+  if (gain === -1) return [];
+
+  const assignmentPeaks = [];
+  let maxValue = Number.MIN_SAFE_INTEGER;
+  for (let index of rowAssignments) {
+    if (maxValue < nearPeaks[index].y) maxValue = nearPeaks[index].y;
+    assignmentPeaks.push({ ...nearPeaks[index] });
+  }
+  assignmentPeaks.forEach((peak, i, arr) => (arr[i].y /= maxValue));
+  return assignmentPeaks;
+}
+
+function getDiffMatrix<T extends PointXY>(rows: T[], columns: T[]) {
+  const nbColumns = columns.length;
+  const nbRows = rows.length;
+  const diff = new Matrix(nbRows, nbColumns);
+  for (let r = 0; r < nbRows; r++) {
+    for (let c = 0; c < nbColumns; c++) {
+      diff.set(r, c, Math.abs(rows[r].x - columns[c].x));
+    }
+  }
+  return diff;
+}

package/src/peaks/util/jAnalyzer.ts

@@ -29,7 +29,7 @@ interface IntergralData {
   to: number;
 }
 
-export type Peak1DIntern = Omit<NMRPeak1D, 'y' | 'shape' | 'fwhm'> & {
+export type Peak1DIntern = Omit<NMRPeak1D, 'y' | 'shape'> & {
   intensity: number;
 };
 
@@ -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
             ? {

package/src/ranges/markSolventSignal.ts

@@ -0,0 +1,121 @@
+import { NMRRangeWithIds, NMRSignal1DWithId } from '../assignment/nmrAssigment';
+import generateID from '../assignment/utils/generateID';
+import { addIDs } from '../assignment/utils/getAssignment/checkIDs';
+import { NMRPeak1D } from '../peaks/NMRPeak1D';
+import { detectSignals } from '../peaks/peaksToRanges';
+import { solventSuppression } from '../peaks/solventSuppression';
+import { SignalIntern } from '../peaks/util/jAnalyzer';
+import { NMRSignal1D } from '../signals/NMRSignal1D';
+import { NMRRange } from '../xy/NMRRange';
+
+interface NMRPeak1DWithSignalID extends NMRPeak1D {
+  signalID: string;
+  rangeID: string;
+}
+
+export function markSolventPeaks<T extends NMRRange>(
+  input: T[],
+  solventSignals: NMRSignal1D[],
+  options: any = {},
+) {
+  const { frequency = 400 } = options;
+  const ranges = addIDs([...input]) as NMRRangeWithIds[];
+
+  let peakList: NMRPeak1DWithSignalID[] = [];
+  for (const range of ranges) {
+    const rangeID = range.id;
+    for (const signal of range.signals || []) {
+      const signalID = signal.id;
+      for (let peak of signal.peaks || []) {
+        peakList.push({
+          ...peak,
+          rangeID,
+          signalID,
+        });
+      }
+    }
+  }
+
+  const peaks = solventSuppression(peakList, solventSignals, {
+    markSolventPeaks: true,
+  });
+
+  const signalsWithSolvent = getSignalIDsWithSolvent(peaks);
+  for (let range of ranges) {
+    if (!range.signals) continue;
+    for (let signal of range.signals) {
+      if (!signalsWithSolvent.includes(signal.id)) continue;
+      const signalPeaks = [];
+      const solventSignalPeaks = [];
+      for (let peak of peaks) {
+        if (peak.signalID === signal.id) {
+          const { signalID, rangeID, ...newPeak } = peak;
+          if (peak.kind === 'solvent') {
+            solventSignalPeaks.push(newPeak);
+          } else {
+            signalPeaks.push(newPeak);
+          }
+        }
+      }
+      const newSignals =
+        signalPeaks.length > 0
+          ? detectSignals({ x: [], y: [] }, signalPeaks, {
+              integralType: 'peak',
+              frequency,
+            })
+          : [];
+      solventSignalPeaks.sort((a, b) => a.x - b.x);
+      const lowPPMValue = solventSignalPeaks[0].x;
+      const highPPMValue = solventSignalPeaks[solventSignalPeaks.length - 1].x;
+      const newSolventSignals = detectSignals(
+        { x: [], y: [] },
+        solventSignalPeaks,
+        {
+          integralType: 'peak',
+          frequencyCluster: (highPPMValue - lowPPMValue) * frequency,
+          frequency,
+        },
+      );
+
+      range.signals = [
+        ...adaptSignals(newSignals),
+        ...adaptSignals(newSolventSignals),
+        ...range.signals.filter((currSignal) => currSignal.id !== signal.id),
+      ];
+    }
+  }
+  return ranges as T[];
+}
+
+function getSignalIDsWithSolvent(solventPeaks: NMRPeak1DWithSignalID[]) {
+  const uniqueSignalID = new Set();
+  for (let peak of solventPeaks) {
+    if (peak.kind !== 'solvent') continue;
+    uniqueSignalID.add(peak.signalID);
+  }
+  return Array.from(uniqueSignalID);
+}
+
+function adaptSignals(signals: SignalIntern[]) {
+  const newSignals = [];
+  for (let signal of signals) {
+    const signalResult: NMRSignal1DWithId = {
+      id: generateID(),
+      delta: signal.delta,
+      kind: signal.kind || 'signal',
+      multiplicity: signal.multiplicity,
+      integration: signal.integralData.value,
+    };
+    signalResult.peaks = signal.peaks.map((peak) => {
+      const newResult: any = {
+        y: peak.intensity,
+        ...peak,
+      };
+      delete newResult.intensity;
+      return newResult as NMRPeak1D;
+    });
+    signalResult.js = signal.nmrJs || [];
+    newSignals.push(signalResult);
+  }
+  return newSignals;
+}

package/src/ranges/rangesToACS.ts

@@ -72,12 +72,12 @@ export function rangesToACS(
   if (!options.nucleus) options.nucleus = '1H';
   const nucleus = options.nucleus.toLowerCase().replace(/[0-9]/g, '');
   const defaultOptions = globalOptions[nucleus];
-  options = Object.assign(
-    {},
-    defaultOptions,
-    { ascending: false, format: 'IMJA' },
-    options,
-  );
+  options = {
+    ...defaultOptions,
+    ascending: false,
+    format: 'IMJA',
+    ...options,
+  };
 
   ranges = JSON.parse(JSON.stringify(ranges));
   if (options.ascending === true) {
@@ -188,14 +188,13 @@ function pushDelta(range: NMRRange, acsRanges: string[], options: any) {
   acsRanges.push(strings);
 }
 
-function getIntegral(range: NMRRange, options: any) {
+function getIntegral(range: NMRRange, options: { nucleus: string[] }) {
   let integration = '';
   if (range.pubIntegral) {
     integration = String(range.pubIntegral);
   } else if (range.integration) {
-    integration =
-      range.integration.toFixed(0) +
-      options.nucleus[options.nucleus.length - 1];
+    const { nucleus } = options;
+    integration = range.integration.toFixed(0) + nucleus[nucleus.length - 1];
   }
   return integration;
 }