nmr-processing 3.3.3 → 4.0.0

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

@@ -1,9 +1,9 @@
-import type { GSDPeak } from 'ml-gsd';
-
+import type { NMRPeak1D } from './NMRPeak1D';
 import type { Jcoupling } from './jcoupling';
 
 export interface NMRSignal1D {
   delta: number;
+  id?: string;
   js?: Jcoupling[];
   atoms?: number[];
   assignment?: string;
@@ -12,7 +12,7 @@ export interface NMRSignal1D {
   diaIDs?: string[];
   nbAtoms?: number;
   integration?: number;
-  peaks?: GSDPeak[];
+  peaks?: NMRPeak1D[];
   statistic?: {
     mean: number;
     sd: number;

package/src/types/NMRSignal2D.ts

@@ -14,7 +14,9 @@ export interface Signal2DAxisData {
 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[];
 }

package/src/xy/xyAutoPeaksPicking.ts

@@ -1,12 +1,17 @@
 import { DataXY } from 'cheminfo-types';
 import { gsd, joinBroadPeaks, optimizePeaks } from 'ml-gsd';
+import type {
+  Peak1D,
+  IGSDOptions,
+  IOptimizePeaksOptions,
+  IJoinBroadPeaksOptions,
+} from 'ml-gsd';
 import {
   xyExtract,
   xNoiseSanPlot,
   xAbsoluteMedian,
 } from 'ml-spectra-processing';
 
-import type { NMRPeak1D } from '../types/NMRPeak1D';
 /**
  * Implementation of the peak picking method described by Cobas in:
  * A new approach to improving automated analysis of proton NMR spectra
@@ -20,63 +25,19 @@ interface OptionsGetCutOff {
   thresholdFactor: number;
 }
 
-interface OptionsGetPeakList {
-  /**
-   * Noise threshold in spectrum y units. Default is three/thresholdFactor times the absolute median of data.y.
-   * @default `median(data.y) * (options.thresholdFactor || 3)`
-   */
-  noiseLevel?: number;
-  /**
-   * Threshold to determine if a given peak should be considered as a noise, bases on its relative height compared to the highest peak.
-   * @default 0.01
-   */
-  minMaxRatio: number;
-  /**
-   * If broadRatio is higher than 0, then all the peaks which second derivative smaller than broadRatio * maxAbsSecondDerivative will be marked with the soft mask equal to true.
-   * @default 0.00025
-   */
-  broadRatio: number;
-  /**
-   * Select the peak intensities from a smoothed version of the independent variables.
-   * @default true
-   */
-  smoothY: boolean;
+export interface IGetPeakListOptions
+  extends IGSDOptions,
+    IOptimizePeaksOptions,
+    IJoinBroadPeaksOptions {
   /**
    * If it is true, the peaks parameters will be optimized.
    * @default false
    */
   optimize: boolean;
-  /**
-   * factor to determine the width at the moment to group the peaks in signals in 'GSD.optimizePeaks' function.
-   * @default 4
-   */
-  factorWidth: number;
-  /**
-   * if it is true, it optimizes the x and intensity by extrapolation.
-   */
-  realTopDetection: boolean;
-  /**
-   * options to shape used to adapt the FWHM
-   * @default {kind:'gaussian'}
-   */
-  shape: { kind: string };
-  /**
-   * options for optimization step, kind represent the algorithm
-   * @default {kind:'lm'}
-   */
-  optimization: { kind: string };
-  /**
-   * Threshold to determine if some peak is candidate to clustering into range.
-   * @default 0.25
-   */
-  broadWidth: number;
-  /**
-   * Options for savitz Golay
-   */
-  sgOptions: { windowSize: number; polynomial: number };
 }
 
-export interface OptionsXYAutoPeaksPicking extends Partial<OptionsGetPeakList> {
+export interface OptionsXYAutoPeaksPicking
+  extends Partial<IGetPeakListOptions> {
   /**
    * Low limit value in the x axis to extract a sub set of points from the input data.
    */
@@ -105,7 +66,7 @@ export interface OptionsXYAutoPeaksPicking extends Partial<OptionsGetPeakList> {
 export function xyAutoPeaksPicking(
   data: DataXY,
   options: OptionsXYAutoPeaksPicking = {},
-): NMRPeak1D[] {
+): Peak1D[] {
   const {
     from,
     to,
@@ -131,7 +92,7 @@ export function xyAutoPeaksPicking(
 
   const cutOff = getCutOff(data.y, { noiseLevel, useSanPlot, thresholdFactor });
 
-  let getPeakOptions = {
+  let getPeakOptions: IGetPeakListOptions = {
     shape,
     broadWidth,
     optimize,
@@ -154,7 +115,7 @@ export function xyAutoPeaksPicking(
   return peaks;
 }
 
-function getPeakList(data: DataXY, options: OptionsGetPeakList) {
+function getPeakList(data: DataXY, options: IGetPeakListOptions) {
   const {
     shape,
     broadWidth,
@@ -173,15 +134,15 @@ function getPeakList(data: DataXY, options: OptionsGetPeakList) {
     shape,
     sgOptions,
     minMaxRatio,
-    broadRatio,
     noiseLevel,
     smoothY,
     realTopDetection,
   });
 
   if (broadWidth) {
-    peakList = joinBroadPeaks(peakList, {
-      width: broadWidth,
+    peakList = joinBroadPeaks(data, peakList, {
+      broadRatio,
+      broadWidth,
       shape,
       optimization,
     });
@@ -198,7 +159,7 @@ function getPeakList(data: DataXY, options: OptionsGetPeakList) {
   return peakList;
 }
 
-function getNegativePeaks(data: DataXY, options: OptionsGetPeakList) {
+function getNegativePeaks(data: DataXY, options: IGetPeakListOptions) {
   let { x, y } = data;
   let negativeDataY = new Float64Array(data.y.length);
   for (let i = 0; i < negativeDataY.length; i++) {