nmr-processing 8.1.0 → 8.2.0

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/xyz/util/formatZone.ts

@@ -0,0 +1,36 @@
+import { NMRSignal2D } from '../NMRSignal2D';
+import { NMRZone } from '../NMRZone';
+
+export function formatZones(signals: NMRSignal2D[]) {
+  let zones: NMRZone[] = [];
+  for (const signal of signals) {
+    let minMax1 = [Number.MAX_VALUE, 0];
+    let minMax2 = [Number.MAX_VALUE, 0];
+    for (const peak of signal.peaks || []) {
+      if (peak.minX < minMax1[0]) {
+        minMax1[0] = peak.minX;
+      }
+      if (peak.maxX > minMax1[1]) {
+        minMax1[1] = peak.maxX;
+      }
+      if (peak.minY < minMax2[0]) {
+        minMax2[0] = peak.minY;
+      }
+      if (peak.maxY > minMax2[1]) {
+        minMax2[1] = peak.maxY;
+      }
+    }
+    zones.push({
+      x: {
+        from: minMax1[0],
+        to: minMax1[1],
+      },
+      y: {
+        from: minMax2[0],
+        to: minMax2[1],
+      },
+      signals: [signal],
+    });
+  }
+  return zones;
+}

package/src/xyz/xyzAutoZonesPicking.ts

@@ -4,13 +4,13 @@ import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
 import type { Peak2D } from 'ml-matrix-peaks-finder';
 import simpleClustering from 'ml-simple-clustering';
 
-import { NMRZone } from '..';
 import { determineRealTop } from '../peaks/util/determineRealTop';
 import { getKernel } from '../peaks/util/getKernel';
 import type { GetKernelOptions } from '../peaks/util/getKernel';
 import * as PeakOptimizer from '../peaks/util/peakOptimizer';
 
 import type { NMRSignal2D } from './NMRSignal2D';
+import { formatZones } from './util/formatZone';
 
 const smallFilter = [
   [0, 0, 1, 2, 2, 2, 1, 0, 0],
@@ -183,40 +183,6 @@ export function xyzAutoZonesPicking(
   return formatZones(signals);
 }
 
-function formatZones(signals: NMRSignal2D[]) {
-  let zones: NMRZone[] = [];
-  for (const signal of signals) {
-    let minMax1 = [Number.MAX_VALUE, 0];
-    let minMax2 = [Number.MAX_VALUE, 0];
-    for (const peak of signal.peaks || []) {
-      if (peak.minX < minMax1[0]) {
-        minMax1[0] = peak.minX;
-      }
-      if (peak.maxX > minMax1[1]) {
-        minMax1[1] = peak.maxX;
-      }
-      if (peak.minY < minMax2[0]) {
-        minMax2[0] = peak.minY;
-      }
-      if (peak.maxY > minMax2[1]) {
-        minMax2[1] = peak.maxY;
-      }
-    }
-    zones.push({
-      x: {
-        from: minMax1[0],
-        to: minMax1[1],
-      },
-      y: {
-        from: minMax2[0],
-        to: minMax2[1],
-      },
-      signals: [signal],
-    });
-  }
-  return zones;
-}
-
 /**
  * This function converts a set of 2D-peaks in 2D-signals. Each signal could be composed
  * of many 2D-peaks, and it has some additional information related to the NMR spectrum.

package/src/xyz/xyzJResAnalyzer.ts

@@ -6,6 +6,7 @@ import jAnalyzer from '../peaks/util/jAnalyzer';
 import type { MakeMandatory } from '../utilities/MakeMandatory';
 
 import type { NMRSignal2D } from './NMRSignal2D';
+import { formatZones } from './util/formatZone';
 
 interface CompilePatternOptions {
   observedFrequencies?: number[] | Float64Array;
@@ -25,6 +26,11 @@ interface XYZJResAnalyzerOptions extends CompilePatternOptions {
    * @default 0
    */
   reference?: number;
+  /**
+   * if it is true returns zones instead of signals 2D
+   * @default false
+   */
+  getZones?: boolean;
 }
 
 type CompilePatternOptionsMandatory = MakeMandatory<
@@ -38,6 +44,7 @@ export function xyzJResAnalyzer(
 ) {
   let {
     reference = 0,
+    getZones = false,
     referenceMaxShiftError = 0.08,
     tolerances = [10, 100],
     nuclei = ['1H', '1H'],
@@ -46,20 +53,20 @@ export function xyzJResAnalyzer(
       jAxisKey: { jAxis: 'y', intensity: 'z' },
     },
   } = options;
-  let temporalSignals = compilePattern(signals, {
+  let temporalSignals = compilePattern([...signals], {
     observedFrequencies,
     tolerances,
     nuclei,
     jAnalyzer,
   });
   //check if the signal are symmetric around the reference
-  let result = [];
+  let signals2D = [];
   for (const tempSignal of temporalSignals) {
     let delta = tempSignal.y.delta;
     if (Math.abs(delta - reference) > referenceMaxShiftError) continue;
-    result.push(tempSignal);
+    signals2D.push(tempSignal);
   }
-  return result;
+  return getZones ? formatZones(signals2D) : signals2D;
 }
 
 function compilePattern(
@@ -122,10 +129,10 @@ function compilePattern(
       }
       if (peaksO.length > 0) {
         peaksO.reverse();
-        let ranges = createSignals2D(peaksO, signalOptions);
+        let signals2D = createSignals2D(peaksO, signalOptions);
 
-        for (const range of ranges) {
-          newSignals.push(range);
+        for (const signal of signals2D) {
+          newSignals.push(signal);
         }
       }
     }