nmr-processing 8.1.0 → 8.3.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;
 }

package/src/signals/signalsJoin.ts

@@ -62,7 +62,7 @@ export function signalsJoin(
     JSON.stringify(signals),
   );
 
-  const groupedSignals: { [index: string]: Signal1DWidthJsAndDiaID[] } = {};
+  const groupedSignals: Record<string, Signal1DWidthJsAndDiaID[]> = {};
 
   for (let signal of copySignals) {
     signal.js = signal.js.sort(localeCompareJcouplingKeys);
@@ -117,12 +117,10 @@ export function signalsJoin(
         ignoreDiaIDs,
       }) as Signal1DWidthJsAndDiaID;
       if (newSignal.js) {
-        newSignal.multiplicity = newSignal.js.reduce(
-          (multiplicity, jCoupling) => {
-            return `${multiplicity}${jCoupling.multiplicity}`;
-          },
-          '',
-        );
+        newSignal.multiplicity =
+          newSignal.js.length > 0
+            ? newSignal.js.map((j) => j.multiplicity).join('')
+            : 's';
       }
       return newSignal;
     })

package/src/signals/simulation/getPauliMatrix.ts

@@ -2,7 +2,7 @@ import { SparseMatrix } from 'ml-sparse-matrix';
 
 function createPauli(mult: number) {
   const spin = (mult - 1) / 2;
-  const prjs = new Array(mult);
+  const prjs: number[] = new Array(mult);
   const temp = new Array(mult);
   for (let i = 0; i < mult; i++) {
     prjs[i] = mult - 1 - i - spin;

package/src/signals/simulation/splitSpinSystem.ts

@@ -80,19 +80,17 @@ function splitCluster(
         }
         if (count <= maxClusterSize) {
           clusterList.push(members);
+        } else if (child.index < 0) {
+          splitCluster(child, clusterList, {
+            maxClusterSize,
+            force: true,
+            nSpins,
+            connectivity,
+          });
         } else {
-          if (child.index < 0) {
-            splitCluster(child, clusterList, {
-              maxClusterSize,
-              force: true,
-              nSpins,
-              connectivity,
-            });
-          } else {
-            // We have to threat this spin alone and use the resurrection algorithm instead of the simulation
-            members[child.index] = 2;
-            clusterList.push(members);
-          }
+          // We have to threat this spin alone and use the resurrection algorithm instead of the simulation
+          members[child.index] = 2;
+          clusterList.push(members);
         }
       } else {
         splitCluster(child, clusterList, {

package/src/utilities/rangeFromSignal.ts

@@ -6,24 +6,32 @@ export interface RangeFromSignalOptions {
    * nucleus
    * @default '1h'
    */
-  nucleus: string;
+  nucleus?: string;
   /**
-   * frequency observed
+   * frequency observedhttps://www.wiley.com/en-us/NMR+Data+Processing-p-9780471039006#content-section
    * @default 400
    */
-  frequency: number;
+  frequency?: number;
+  /**
+   * tolerance to the halfWidth, default depends of the nucleus
+   */
+  tolerance?: number;
 }
 
-export function rangeFromSignal(signal: NMRSignal1D, options: any = {}) {
+export function rangeFromSignal(
+  signal: NMRSignal1D,
+  options: RangeFromSignalOptions,
+) {
   const { nucleus = '1h', frequency = 400 } = options;
   const { tolerance = getTolerance(nucleus) / frequency } = options;
-  let halfWidth =
-    (signal.js || []).reduce((total, j) => {
-      const { coupling, multiplicity = 'd' } = j;
-      return total + (couplingValues[multiplicity] * coupling) / frequency;
-    }, 0) /
-      2 +
-    tolerance;
+
+  let halfWidth = 0;
+  for (const js of signal.js || []) {
+    const { coupling, multiplicity = 'd' } = js;
+    halfWidth += (couplingValues[multiplicity] * coupling) / frequency;
+  }
+
+  halfWidth = tolerance + halfWidth / 2;
   return {
     from: signal.delta - halfWidth,
     to: signal.delta + halfWidth,

package/src/utilities/resurrectRange.ts

@@ -46,13 +46,10 @@ export function resurrectRange(part: string, options: any = {}) {
         signal.delta = from;
         signal.multiplicity = multiplicity;
       }
-    } else {
-      // looks like a real multiplicity, s, d, dd, etc..
-      if (!isARange) {
-        // a complex signal
-        signal.delta = from;
-        signal.multiplicity = multiplicity;
-      }
+    } else if (!isARange) {
+      // a complex signal
+      signal.delta = from;
+      signal.multiplicity = multiplicity;
     }
   }
 

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);
         }
       }
     }