nmr-processing 3.3.4 → 5.0.0

package/src/peaks/peaksToRanges.ts

@@ -91,22 +91,20 @@ const assignSignal = (
     delta: NaN,
     nbPeaks: 1,
     kind: 'signal',
-    startX: peak.x - peak.shape.width,
-    stopX: peak.x + peak.shape.width,
+    startX: peak.x - peak.width,
+    stopX: peak.x + peak.width,
     observe: frequency,
     nucleus,
     integralData: {
-      from: peak.x - peak.shape.width * 3,
-      to: peak.x + peak.shape.width * 3,
+      from: peak.x - peak.width * 3,
+      to: peak.x + peak.width * 3,
       value: 0,
     },
     peaks: [
       {
         x: peak.x,
         intensity: peak.y,
-        shape: {
-          width: peak.shape.width,
-        },
+        width: peak.width,
       },
     ],
   };
@@ -177,9 +175,7 @@ export function peaksToRanges(
             peaksO.push({
               x: peakR.x,
               y: peakR.intensity,
-              shape: {
-                width: peakR.shape.width,
-              },
+              width: peakR.width,
             });
             signal.mask.splice(j, 1);
             signal.mask2.splice(j, 1);
@@ -306,24 +302,22 @@ function detectSignals(
       if (peak.kind) signal1D.kind = peak.kind;
       signals.push(signal1D);
     } else {
-      let tmp = peak.x + peak.shape.width;
+      let tmp = peak.x + peak.width;
       signal1D.stopX = Math.max(signal1D.stopX, tmp);
       signal1D.startX = Math.min(signal1D.startX, tmp);
       signal1D.nbPeaks++;
       signal1D.peaks.push({
         x: peak.x,
         intensity: peak.y,
-        shape: {
-          width: peak.shape.width,
-        },
+        width: peak.width,
       });
       signal1D.integralData.from = Math.min(
         signal1D.integralData.from,
-        peak.x - peak.shape.width * 3,
+        peak.x - peak.width * 3,
       );
       signal1D.integralData.to = Math.max(
         signal1D.integralData.to,
-        peak.x + peak.shape.width * 3,
+        peak.x + peak.width * 3,
       );
       if (peak.kind) signal1D.kind = peak.kind;
     }
@@ -371,5 +365,5 @@ function detectSignals(
  * @private
  */
 function computeArea(peak: Peak1DIntern) {
-  return Math.abs(peak.intensity * peak.shape.width * 1.57); // todo add an option with this value: 1.772453851
+  return Math.abs(peak.intensity * peak.width * 1.57); // todo add an option with this value: 1.772453851
 }

package/src/peaks/util/determineRealTop.ts

@@ -1,10 +1,8 @@
 import LM from 'ml-levenberg-marquardt';
-import { gaussian2D } from 'ml-peak-shape-generator';
+import { Gaussian2D } from 'ml-peak-shape-generator';
 
 import type { MPFPeak } from '../../types/MPFPeak';
 
-const { fct: gaussian2DFct } = gaussian2D;
-
 const direction8X = [-1, -1, -1, 0, 0, 1, 1, 1];
 const direction8Y = [-1, 0, 1, -1, 1, -1, 0, 1];
 const direction16X = [-2, -2, -2, -2, -2, -1, -1, 0, 0, 1, 1, 2, 2, 2, 2, 2];
@@ -142,6 +140,7 @@ function fitGaussian(
 }
 
 function paramGaussian2D(intervalX: number, intervalY: number, nCols: number) {
+  const gaussian2D = new Gaussian2D();
   return (p: number[]) => {
     return (t: number) => {
       let nL = p.length / 5;
@@ -149,13 +148,12 @@ function paramGaussian2D(intervalX: number, intervalY: number, nCols: number) {
       let xIndex = t % nCols;
       let yIndex = (t - xIndex) / nCols;
       for (let i = 0; i < nL; i++) {
+        gaussian2D.fwhm = {x: p[i + 3 * nL], y: p[i + 4 * nL]};
         result +=
           p[i + 2 * nL] *
-          gaussian2DFct(
+          gaussian2D.fct(
             (xIndex - p[i]) * intervalX,
             (yIndex - p[i + nL]) * intervalY,
-            p[i + 3 * nL],
-            p[i + 4 * nL],
           );
       }
       return result;

package/src/peaks/util/jAnalyzer.ts

@@ -106,7 +106,7 @@ export default {
       signal.asymmetric = false;
       let P1, n2, maxFlagged;
       let k = 1;
-      let Jc = [];
+      let jCouplings = [];
 
       // Loop over the possible number of coupling contributing to the multiplet
       for (let n = 0; n < 9; n++) {
@@ -144,17 +144,17 @@ export default {
             }
           }
 
-          Jc = []; // The array to store the detected j-coupling
+          jCouplings = []; // The array to store the detected j-coupling
           // 2.2 Set j = 1; J1 = P2 - P1. Flag components 1 and 2 as accounted for.
           let j = 1;
-          Jc.push(peaks[1].x - peaks[0].x);
+          jCouplings.push(peaks[1].x - peaks[0].x);
           P1 = peaks[0].x;
           numbering[0].splice(0, 1); // Flagged
           numbering[1].splice(0, 1); // Flagged
           k = 1;
           let nFlagged = 2;
           maxFlagged = Math.pow(2, n) - 1;
-          while (Jc.length < n && nFlagged < maxFlagged && k < peaks.length) {
+          while (jCouplings.length < n && nFlagged < maxFlagged && k < peaks.length) {
             counter += 1;
             // 4.1. Increment j. Set k to the number of the first unflagged component.
             j++;
@@ -163,7 +163,7 @@ export default {
             }
             if (k < peaks.length) {
               // 4.2 Jj = Pk - P1.
-              Jc.push(peaks[k].x - peaks[0].x);
+              jCouplings.push(peaks[k].x - peaks[0].x);
               // Flag component k and, for each sum of the...
               numbering[k].splice(0, 1); // Flageed
               nFlagged++;
@@ -171,7 +171,7 @@ export default {
               for (let u = 2; u <= j; u++) {
                 let jSum = 0;
                 for (let i = 0; i < u; i++) {
-                  jSum += Jc[i];
+                  jSum += jCouplings[i];
                 }
                 for (let i = 1; i < numbering.length; i++) {
                   // Maybe 0.25 Hz is too much?
@@ -185,7 +185,7 @@ export default {
             }
           }
           // Calculate the ideal patter by using the extracted j-couplings
-          let pattern = idealPattern(Jc);
+          let pattern = idealPattern(jCouplings);
           // Compare the ideal pattern with the proposed intensities.
           // All the intensities have to match to accept the multiplet
           validPattern = true;
@@ -197,7 +197,7 @@ export default {
         }
         // If we found a valid pattern we should inform about the pattern.
         if (validPattern) {
-          updateSignal(signal, Jc);
+          updateSignal(signal, jCouplings);
         }
       }
     }
@@ -213,58 +213,58 @@ export default {
  * @private
  * update the signal
  * @param {*} signal
- * @param {*} Jc
+ * @param {*} jCouplings
  */
-function updateSignal(signal: SignalInternMandatory, Jc: number[]) {
+function updateSignal(signal: SignalInternMandatory, jCouplings: number[]) {
   // Update the limits of the signal
   let peaks = signal.peaksComp; // Always in Hz
   let nbPeaks = peaks.length;
-  signal.startX = peaks[0].x / signal.observe - peaks[0].shape.width;
+  signal.startX = peaks[0].x / signal.observe - peaks[0].width;
   signal.stopX =
-    peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].shape.width;
+    peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].width;
   signal.integralData.from =
-    peaks[0].x / signal.observe - peaks[0].shape.width * 3;
+    peaks[0].x / signal.observe - peaks[0].width * 3;
   signal.integralData.to =
-    peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].shape.width * 3;
+    peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].width * 3;
   // Compile the pattern and format the constant couplings
   signal.maskPattern = signal.mask2;
-  signal.multiplicity = abstractPattern(signal, Jc);
+  signal.multiplicity = abstractPattern(signal, jCouplings);
   signal.pattern = signal.multiplicity; // Our library depends on this parameter, but it is old
 }
 
 /**
  * Returns the multiplet in the compact format
  * @param {object} signal
- * @param {object} Jc
+ * @param {object} jCouplings
  * @return {String}
  * @private
  */
-function abstractPattern(signal: SignalInternMandatory, Jc: number[]) {
+function abstractPattern(signal: SignalInternMandatory, jCouplings: number[]) {
   let tol = 0.05;
   let pattern = '';
   let cont = 1;
   let newNmrJs = [];
 
-  if (Jc && Jc.length > 0) {
-    Jc.sort((a, b) => {
+  if (jCouplings && jCouplings.length > 0) {
+    jCouplings.sort((a, b) => {
       return b - a;
     });
 
-    for (let i = 0; i < Jc.length - 1; i++) {
-      if (Math.abs(Jc[i] - Jc[i + 1]) < tol) {
+    for (let i = 0; i < jCouplings.length - 1; i++) {
+      if (Math.abs(jCouplings[i] - jCouplings[i + 1]) < tol) {
         cont++;
       } else {
         newNmrJs.push({
-          coupling: Math.abs(Jc[i]),
+          coupling: Math.abs(jCouplings[i]),
           multiplicity: patterns[cont],
         });
         pattern += patterns[cont];
         cont = 1;
       }
     }
-    let index = Jc.length - 1;
+    let index = jCouplings.length - 1;
     newNmrJs.push({
-      coupling: Math.abs(Jc[index]),
+      coupling: Math.abs(jCouplings[index]),
       multiplicity: patterns[cont],
     });
     pattern += patterns[cont];
@@ -281,15 +281,15 @@ function abstractPattern(signal: SignalInternMandatory, Jc: number[]) {
 /**
  * This function creates an ideal pattern from the given J-couplings
  * @private
- * @param {Array} Jc
+ * @param {Array} jCouplings
  * @return {*[]}
  * @private
  */
-function idealPattern(Jc: number[]) {
-  let hsum = Math.pow(2, Jc.length);
+function idealPattern(jCouplings: number[]) {
+  let hsum = Math.pow(2, jCouplings.length);
   let pattern = [{ x: 0, intensity: hsum }];
   // To split the initial height
-  for (const jc of Jc) {
+  for (const jc of jCouplings) {
     for (let j = pattern.length - 1; j >= 0; j--) {
       pattern.push({
         x: pattern[j].x + jc / 2,
@@ -466,9 +466,7 @@ function symmetrize(
     peaks[i] = {
       x: peak[jAxis] * newSignal.observe,
       intensity: peak[intensity],
-      shape: {
-        width: peak.shape.width,
-      },
+      width: peak.width,
     };
   }
   // Join the peaks that are closer than 0.25 Hz
@@ -480,7 +478,7 @@ function symmetrize(
       peaks[i].intensity = peaks[i].intensity + peaks[i + 1].intensity;
       peaks[i].x /= peaks[i].intensity;
       peaks[i].intensity /= 2;
-      peaks[i].shape.width += peaks[i + 1].shape.width;
+      peaks[i].width += peaks[i + 1].width;
       peaks.splice(i + 1, 1);
     }
   }
@@ -528,11 +526,11 @@ function symmetrize(
         if (Math.abs(diffL - diffR) < maxError) {
           avg = Math.min(peaks[left].intensity, peaks[right].intensity);
           avgWidth = Math.min(
-            peaks[left].shape.width,
-            peaks[right].shape.width,
+            peaks[left].width,
+            peaks[right].width,
           );
           peaks[left].intensity = peaks[right].intensity = avg;
-          peaks[left].shape.width = peaks[right].shape.width = avgWidth;
+          peaks[left].width = peaks[right].width = avgWidth;
           middle = [
             middle[0] + (peaks[right].x + peaks[left].x) / 2,
             middle[1] + 1,
@@ -712,5 +710,5 @@ function chemicalShift(peaks: Peak1DIntern[], mask: boolean[] = []) {
  * @private
  */
 function getArea(peak: Peak1DIntern) {
-  return Math.abs(peak.intensity * peak.shape.width * 1.57); // 1.772453851);
+  return Math.abs(peak.intensity * peak.width * 1.57); // 1.772453851);
 }

package/src/ranges/rangesToXY.ts

@@ -1,15 +1,14 @@
 import { DoubleArray } from 'cheminfo-types';
 import arraySequentialFill from 'ml-array-sequential-fill';
+import type { Shape1D } from 'ml-peak-shape-generator';
 import { SpectrumGenerator } from 'spectrum-generator';
-import type { Shape1DOptions } from 'spectrum-generator';
 
 import { hackSignalsToXY } from '../signals/hackSignalsToXY';
 import type { MakeMandatory } from '../types/MakeMandatory';
 import type { NMRRange } from '../types/NMRRange';
 import type { NMRSignal1D } from '../types/NMRSignal1D';
 
-
-type rangeWithSignal = MakeMandatory<NMRRange, 'signals'>;
+type RangeWithSignal = MakeMandatory<NMRRange, 'signals'>;
 
 export interface RangeToXYOptions {
   /**
@@ -41,11 +40,11 @@ export interface RangeToXYOptions {
    * options of signals.
    * @default { kind: 'gaussian' }
    */
-  shape: Shape1DOptions;
+  shape: Shape1D;
 }
 function checkForSignals(
   ranges: NMRRange[],
-): asserts ranges is rangeWithSignal[] {
+): asserts ranges is RangeWithSignal[] {
   for (let range of ranges) {
     if (!range.signals) throw new Error('range has not signals');
   }
@@ -78,7 +77,15 @@ export function rangesToXY(ranges: NMRRange[], options: any = {}) {
 
   let spectrum: DoubleArray = new Float64Array(nbPoints);
   for (const range of ranges) {
-    const { integration, signals } = range;
+    const { integration, signals = [] } = range;
+    const { multiplicity: rangeMulplicity = '' } = range;
+    if (rangeMulplicity === 'm' && signals.length < 1) {
+      const { from, to } = range;
+      signals.push({
+        delta: (from + to) / 2,
+        multiplicity: 'm',
+      });
+    }
     let rangeSpectrum: DoubleArray = new Float64Array(nbPoints);
     for (const signal of signals) {
       const { multiplicity } = signal;
@@ -168,8 +175,8 @@ function normalizeSpectrum(
     0,
   );
 
-  const norma = (integration / sum) * 1e6;
   if (sum !== 0) {
+    const norma = (integration / sum) * 1e6;
     for (let i = 0; i < spectrum.length; i++) {
       spectrum[i] *= norma;
     }

package/src/signals/signals2DToZ.ts

@@ -3,7 +3,7 @@ import type { XYNumber } from 'spectrum-generator';
 
 import type { NMRSignal2D } from '../types/NMRSignal2D';
 
-interface signals2DToZOptions {
+interface Signals2DToZOptions {
   /**
    * lower limit in the spectrum, if it is a number the value will be defined for both axes
    * @default -1
@@ -36,7 +36,7 @@ export interface Peak2DSeries {
 
 export function signals2DToZ(
   signals: NMRSignal2D[],
-  options: signals2DToZOptions = {},
+  options: Signals2DToZOptions = {},
 ) {
   let { from = -1, to = 12, nbPoints = 512, width = 0.02 } = options;
 

package/src/signals/signalsToXY.ts

@@ -1,6 +1,6 @@
 import rescale from 'ml-array-rescale';
 import arraySequentialFill from 'ml-array-sequential-fill';
-import type { Shape1DOptions } from 'spectrum-generator';
+import type { Shape1D } from 'ml-peak-shape-generator';
 
 import type { MakeMandatory } from '../types/MakeMandatory';
 import type { NMRSignal1D } from '../types/NMRSignal1D';
@@ -25,7 +25,7 @@ export interface OptionsSignalsToXY {
   /**
    * Shape options for ml-spectrum-generator
    */
-  shape?: Shape1DOptions;
+  shape?: Shape1D;
   /**
    * The linewidth of the output spectrum, expresed in Hz.
    * @default 1

package/src/signals/simulation/simulate1D.ts

@@ -1,9 +1,10 @@
 import binarySearch from 'binary-search';
+import { DataXY } from 'cheminfo-types';
 import { Matrix, EVD } from 'ml-matrix';
 import type { Matrix as MatrixClassType } from 'ml-matrix';
+import type { Shape1D } from 'ml-peak-shape-generator';
 import { SparseMatrix } from 'ml-sparse-matrix';
 import { SpectrumGenerator } from 'spectrum-generator';
-import type { Shape1DOptions } from 'spectrum-generator';
 
 import type { SpinSystem } from '../../types/spinSystem';
 
@@ -46,7 +47,7 @@ interface Simulate1DOptions {
    * Shape options
    * @default {kind:'gaussian'}
    */
-  shape?: Shape1DOptions;
+  shape?: Shape1D;
 }
 
 /**
@@ -59,7 +60,7 @@ export default function simulate1D(
    */
   spinSystem: SpinSystem,
   options: Simulate1DOptions = {},
-) {
+): DataXY {
   let {
     lineWidth = 1,
     maxClusterSize = 8,

package/src/types/NMRPeak1D.ts

@@ -1,11 +1,5 @@
-export interface NMRPeak1D {
+import type { Peak1D } from 'ml-gsd';
+
+export interface NMRPeak1D extends Peak1D {
   kind?: string;
-  x: number;
-  y: number;
-  shape: {
-    width: number;
-    noiseLevel?: number;
-    soft?: boolean;
-    kind?: string;
-  };
 }

package/src/types/NMRRange.ts

@@ -3,6 +3,7 @@ import type { NMRSignal1D } from './NMRSignal1D';
 export interface NMRRange {
   from: number;
   to: number;
+  id?: string;
   diaIDs?: string[];
   kind?: string;
   pubIntegral?: number;

package/src/types/NMRSignal1D.ts

@@ -3,6 +3,7 @@ import type { Jcoupling } from './jcoupling';
 
 export interface NMRSignal1D {
   delta: number;
+  id?: string;
   js?: Jcoupling[];
   atoms?: number[];
   assignment?: string;

package/src/types/NMRSignal2D.ts

@@ -6,15 +6,15 @@ export interface Signal2DAxisData {
   resolution?: number;
   atoms?: number[];
   diaIDs?: string[];
-  fromTo?: {
-    from: number;
-    to: number
-  };
+  from: number;
+  to: number;
 }
 export interface NMRSignal2D {
   x: Signal2DAxisData;
   y: Signal2DAxisData;
+  id?: string;
   peaks?: MPFPeak[];
   kind?: string;
+  //eslint-disable-next-line
   _highlight?: (number | string)[];
 }

package/src/types/NMRZone.ts

@@ -1,9 +1,10 @@
 import type { NMRSignal2D } from "./NMRSignal2D";
 
-interface fromTo { from: number, to: number }
+interface FromTo { from: number, to: number }
 
 export interface NMRZone {
-  x: fromTo,
-  y: fromTo,
+  x: FromTo,
+  y: FromTo,
+  id?: string;
   signals: NMRSignal2D
 }

package/src/types/ml-spectra-processing/index.d.ts

@@ -9,7 +9,7 @@ declare module 'ml-spectra-processing' {
     options?: { zones: { from: number; to: number }[] },
   ): XYNumberArray;
 
-  interface xNoiseSanPlotOptions {
+  interface XNoiseSanPlotOptions {
     mask?: boolean[];
     cutOff?: number;
     logBaseY?: number;
@@ -20,7 +20,7 @@ declare module 'ml-spectra-processing' {
     fixOffset?: boolean;
   }
 
-  interface xNoiseSanPlotResult {
+  interface XNoiseSanPlotResult {
     positive: number;
     negative: number;
     snr: number;
@@ -31,21 +31,21 @@ declare module 'ml-spectra-processing' {
   }
   function xNoiseSanPlot(
     data: number[] | Float64Array,
-    options?: xNoiseSanPlotOptions,
-  ): xNoiseSanPlotResult;
+    options?: XNoiseSanPlotOptions,
+  ): XNoiseSanPlotResult;
 
   function xAbsoluteMedian(data: number[] | Float64Array): number;
 
-  interface xGetFromToIndexOptions {
+  interface XGetFromToIndexOptions {
     fromIndex?: number;
     toIndex?: number;
     from?: number;
     to?: number;
   }
 
-  interface xyIntegrationOptions extends xGetFromToIndexOptions {}
+  interface XYIntegrationOptions extends XGetFromToIndexOptions {}
 
-  function xyIntegration(data: XYNumberArray, options?: xyIntegrationOptions): number;
+  function xyIntegration(data: XYNumberArray, options?: XYIntegrationOptions): number;
 
-  function xGetFromToIndex(x: number[] | Float64Array, options?: xGetFromToIndexOptions): number;
+  function xGetFromToIndex(x: number[] | Float64Array, options?: XGetFromToIndexOptions): number;
 }

package/src/types/ml-tree-set/index.d.ts

@@ -0,0 +1,18 @@
+declare module 'ml-tree-set' {
+  type Comparator = (a: Elements, b: Elements) => number;
+  type Elements = any;
+  export default class TreeSet {
+    public length: number;
+    public elements: Array<Elements>;
+
+    public constructor(comparator: Comparator);
+
+    public size: () => number;
+    public last: () => Elements;
+    public first: () => Elements;
+    public isEmpty: () => boolean;
+    public pollLast: () => void;
+    public pollFirst: () => void;
+    public add(element: Elements): () => void;
+  }
+}

package/src/types/openchemlib-utils/index..d.ts

@@ -110,7 +110,7 @@ declare module 'openchemlib-utils' {
 
   function getHoseCodesForPath(molecule: Molecule, from: string, to: string, maxLength: number): HoseCodesForPath;
 
-  export interface getConnectivityMatrixOptions {
+  export interface GetConnectivityMatrixOptions {
     /**
      * get the path length between atoms
      * @default false
@@ -142,7 +142,7 @@ declare module 'openchemlib-utils' {
      */
     stda?: boolean | number;
   }
-  function getConnectivityMatrix(molecule: Molecule, options?: getConnectivityMatrixOptions): number[][] | Float64Array[];
+  function getConnectivityMatrix(molecule: Molecule, options?: GetConnectivityMatrixOptions): number[][] | Float64Array[];
 
   function getDiastereotopicAtomIDs(molecule: Molecule): string[];
 }