nmr-processing 8.2.0 → 8.3.0

package/src/assignment/utils/exploreTreeRec.ts

@@ -113,7 +113,7 @@ function addSolution(store: StoreAssignments, props: AddSolutionProps) {
   store.nSolutions++;
   let solution: SolutionAssignment = {
     assignment: JSON.parse(JSON.stringify(partial)),
-    score: score,
+    score,
   };
 
   if (store.nSolutions >= maxSolutions) {

package/src/assignment/utils/getAssignment/buildAssignments.ts

@@ -1,4 +1,4 @@
-import treeSet from 'ml-tree-set';
+import TreeSet from 'ml-tree-set';
 import { Values } from 'nmr-correlation';
 import { Molecule } from 'openchemlib';
 import { getConnectivityMatrix } from 'openchemlib-utils';
@@ -135,7 +135,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
   let lowerBoundScore = minScore;
 
   let store: StoreAssignments = {
-    solutions: new treeSet(comparator),
+    solutions: new TreeSet(comparator),
     nSolutions: 0,
   };
 
@@ -204,7 +204,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
     );
 
     store = {
-      solutions: new treeSet(comparator),
+      solutions: new TreeSet(comparator),
       nSolutions: 0,
     };
 

package/src/databases/DatabaseNMREntry.ts

@@ -1,6 +1,9 @@
+import { OCLMolecule } from 'cheminfo-types';
+
 import { NMRRange } from '../xy/NMRRange';
 
 export interface DatabaseNMREntry {
+  ocl?: OCLMolecule;
   smiles?: string;
   solvent: string;
   nucleus: string;

package/src/index.ts

@@ -40,6 +40,9 @@ 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/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,

package/src/peaks/solventSuppression.ts

@@ -15,7 +15,7 @@ import { NMRPeak1D } from './NMRPeak1D';
 export function solventSuppression<T extends NMRPeak1D>(
   peakList: T[],
   solvent: NMRSignal1D[],
-  options: any = {},
+  options: { markSolventPeaks?: boolean; solventZoneExtension?: number } = {},
 ) {
   const peaks = [...peakList].sort((a, b) => a.x - b.x);
 
@@ -38,9 +38,9 @@ export function solventSuppression<T extends NMRPeak1D>(
       solventXYPeaks[0].x - solventZoneExtension,
     );
 
-    if (upIndex === lowIndex) continue;
-    const nearPeaks = peaks.slice(lowIndex, upIndex + 1);
-
+    const nearPeaks = peaks.filter(
+      (peak, index) => index >= lowIndex && index <= upIndex,
+    );
     const amplitudeResiduals = [];
     const deltaResiduals = [];
     const positionResiduals = [];
@@ -76,9 +76,14 @@ export function solventSuppression<T extends NMRPeak1D>(
       positionResiduals.push(positionResidual);
     }
 
-    const maxAmplitude = xMaxValue(amplitudeResiduals);
-    const maxDelta = xMaxValue(deltaResiduals);
-    const maxPosition = xMaxValue(positionResiduals);
+    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;
@@ -98,7 +103,7 @@ export function solventSuppression<T extends NMRPeak1D>(
       }
     }
 
-    if (minScore < 0) {
+    if (minScore < 0 || minIndex < 0) {
       new Error('There is not a correct match with the pattern');
       return peaks;
     }

package/src/peaks/util/jAnalyzer.ts

@@ -120,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);
@@ -399,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.
@@ -533,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++;
         }
       }
     }
@@ -595,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) {
@@ -608,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;
@@ -660,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) {
@@ -691,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/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/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;
     }
   }