nmr-processing 9.7.8 → 9.8.0

package/src/signals/simulation/splitSpinSystem.ts

@@ -21,25 +21,28 @@ export function splitSpinSystem(
   options: SplitSpinSystemOptions = {},
 ) {
   const spinSystem = ensureSpinSystemProps(spinSystemInput);
-  let { chemicalShifts, couplingConstants, connectivity } = spinSystem;
-  let { frequency = 400, maxClusterSize = 8 } = options;
-  let betas = calculateBetas(chemicalShifts, couplingConstants, frequency);
-  let initClusters = agnes(betas, { method: 'single', isDistanceMatrix: true });
-  let clusterList: Array<Int16Array> = [];
-  let nSpins = chemicalShifts.length;
+  const { chemicalShifts, couplingConstants, connectivity } = spinSystem;
+  const { frequency = 400, maxClusterSize = 8 } = options;
+  const betas = calculateBetas(chemicalShifts, couplingConstants, frequency);
+  const initClusters = agnes(betas, {
+    method: 'single',
+    isDistanceMatrix: true,
+  });
+  const clusterList: Int16Array[] = [];
+  const nSpins = chemicalShifts.length;
   splitCluster(initClusters, clusterList, {
     maxClusterSize,
     force: false,
     nSpins,
     connectivity,
   });
-  let mergedClusters = mergeClusters(clusterList, maxClusterSize);
-  let nClusters = mergedClusters.length;
-  let clusters = new Array(nClusters);
+  const mergedClusters = mergeClusters(clusterList, maxClusterSize);
+  const nClusters = mergedClusters.length;
+  const clusters = new Array(nClusters);
   for (let j = 0; j < nClusters; j++) {
     clusters[j] = [];
     for (let i = 0; i < nSpins; i++) {
-      let element = mergedClusters[j][i];
+      const element = mergedClusters[j][i];
       if (element === 0) continue;
       clusters[j].push(element < 0 ? -(i + 1) : i);
     }
@@ -57,16 +60,16 @@ interface SplitClusterOptions {
 
 function splitCluster(
   cluster: Cluster,
-  clusterList: Array<Int16Array>,
+  clusterList: Int16Array[],
   options: SplitClusterOptions,
 ) {
-  let { maxClusterSize, force, nSpins, connectivity } = options;
+  const { maxClusterSize, force, nSpins, connectivity } = options;
   if (!force && cluster.size <= maxClusterSize) {
     clusterList.push(getMembers(cluster.indices(), nSpins));
   } else {
-    for (let child of cluster.children) {
+    for (const child of cluster.children) {
       if (child.size <= maxClusterSize) {
-        let members = getMembers(child.indices(), nSpins);
+        const members = getMembers(child.indices(), nSpins);
         // Add the neighbors that shares at least 1 coupling with the given cluster
         let count = 0;
         for (let i = 0; i < nSpins; i++) {
@@ -111,15 +114,15 @@ function calculateBetas(
   couplingConstants: Matrix,
   frequency: number,
 ) {
-  let nRows = couplingConstants.rows;
-  let nColumns = couplingConstants.columns;
-  let betas = Matrix.zeros(nRows, nRows);
+  const nRows = couplingConstants.rows;
+  const nColumns = couplingConstants.columns;
+  const betas = Matrix.zeros(nRows, nRows);
   // Before clustering, we must add hidden couplingConstants, we could use molecular information if available
   for (let i = 0; i < nRows; i++) {
     for (let j = i; j < nColumns; j++) {
-      let element = couplingConstants.get(i, j);
+      const element = couplingConstants.get(i, j);
       if (chemicalShifts[i] - chemicalShifts[j] !== 0) {
-        let value =
+        const value =
           1 -
           Math.abs(
             element / ((chemicalShifts[i] - chemicalShifts[j]) * frequency),
@@ -135,10 +138,10 @@ function calculateBetas(
   return betas.to2DArray();
 }
 
-function mergeClusters(list: Array<Int16Array>, maxClusterSize: number) {
+function mergeClusters(list: Int16Array[], maxClusterSize: number) {
   for (let i = list.length - 1; i >= 0; i--) {
-    let clusterA = list[i];
-    let nElements = clusterA.length;
+    const clusterA = list[i];
+    const nElements = clusterA.length;
     let index = 0;
 
     // Is it a candidate to be merged?
@@ -146,7 +149,7 @@ function mergeClusters(list: Array<Int16Array>, maxClusterSize: number) {
     if (index >= nElements) continue;
 
     for (let j = list.length - 1; j >= i + 1; j--) {
-      let clusterB = list[j];
+      const clusterB = list[j];
       // Do they have common elements?
       let count = 0;
       let common = 0;
@@ -172,8 +175,8 @@ function mergeClusters(list: Array<Int16Array>, maxClusterSize: number) {
 }
 
 function getMembers(cluster: number[], nSpins: number) {
-  let members = new Int16Array(nSpins);
-  for (let e of cluster) {
+  const members = new Int16Array(nSpins);
+  for (const e of cluster) {
     members[e] = 1;
   }
   return members;

package/src/signals/utils/jAnalyzer.ts

@@ -7,16 +7,16 @@ import { Jcoupling } from '../Jcoupling';
  * A two-stage approach to automatic determination of 1H NMR coupling constants
  */
 const patterns = ['s', 'd', 't', 'q', 'quint', 'h', 'sept', 'o', 'n'];
-let symRatio = 1.5;
-let maxErrorIter1 = 2.5; // Hz
-let maxErrorIter2 = 1; // Hz
+const symRatio = 1.5;
+const maxErrorIter1 = 2.5; // Hz
+const maxErrorIter2 = 1; // Hz
 
 export interface JAxisKeys {
   [key: string]: string;
   jAxis: string;
   intensity: string;
 }
-let jAxisKeys: JAxisKeys = { jAxis: 'x', intensity: 'intensity' };
+const jAxisKeys: JAxisKeys = { jAxis: 'x', intensity: 'intensity' };
 
 interface GetRanges {
   values: number[][];
@@ -96,7 +96,7 @@ export default {
     inputSignal: SignalFlexiblePeaks,
     options: OpitonsCompilePatter = {},
   ) => {
-    let { jAxisKey = jAxisKeys } = options;
+    const { jAxisKey = jAxisKeys } = options;
 
     // checkForPeaks(inputSignal);
 
@@ -126,7 +126,7 @@ export default {
       // Loop over the possible number of coupling contributing to the multiplet
       for (let n = 0; n < 9; n++) {
         // 1.2 Normalize. It makes a deep copy of the peaks before to modify them.
-        let peaks = normalize(signal, n);
+        const peaks = normalize(signal, n);
         let validPattern = false; // It will change to true, when we find the good patter
         // Lets check if the signal could be a singulet.
         if (peaks.length === 1 && n === 0) {
@@ -135,7 +135,7 @@ export default {
           continue;
         }
         // 1.3 Establish a range for the Heights Hi [peaks.intensity*0.85,peaks.intensity*1.15];
-        let ranges = getRanges(peaks);
+        const ranges = getRanges(peaks);
         n2 = Math.pow(2, n);
 
         // 1.4 Find a combination of integer heights Hi, one from each Si, that sums to 2^n.
@@ -148,7 +148,7 @@ export default {
         ) {
           // 2.1 Number the components of the multiplet consecutively from 1 to 2n,
           // starting at peak 1
-          let numbering = new Array(heights.length);
+          const numbering = new Array(heights.length);
           k = 1;
           for (let i = 0; i < heights.length; i++) {
             numbering[i] = new Array(heights[i]);
@@ -202,7 +202,7 @@ export default {
             }
           }
           // Calculate the ideal patter by using the extracted j-couplings
-          let pattern = idealPattern(jCouplings);
+          const pattern = idealPattern(jCouplings);
           // Compare the ideal pattern with the proposed intensities.
           // All the intensities have to match to accept the multiplet
           validPattern = true;
@@ -219,7 +219,7 @@ export default {
       }
     }
     // Before to return, change the units of peaksComp from Hz to PPM again
-    for (let peakComp of signal.peaksComp) {
+    for (const peakComp of signal.peaksComp) {
       peakComp.x /= signal.observe;
       peakComp.width *= signal.observe;
     }
@@ -235,8 +235,8 @@ export default {
  */
 function updateSignal(signal: SignalInternMandatory, jCouplings: number[]) {
   // Update the limits of the signal
-  let peaks = signal.peaksComp; // Always in Hz
-  let nbPeaks = peaks.length;
+  const peaks = signal.peaksComp; // Always in Hz
+  const nbPeaks = peaks.length;
   signal.startX = peaks[0].x / signal.observe - peaks[0].width;
   signal.stopX =
     peaks[nbPeaks - 1].x / signal.observe + peaks[nbPeaks - 1].width;
@@ -257,10 +257,10 @@ function updateSignal(signal: SignalInternMandatory, jCouplings: number[]) {
  * @private
  */
 function abstractPattern(signal: SignalInternMandatory, jCouplings: number[]) {
-  let tol = 0.05;
+  const tol = 0.05;
   let pattern = '';
   let cont = 1;
-  let newNmrJs: Jcoupling[] = [];
+  const newNmrJs: Jcoupling[] = [];
 
   if (jCouplings && jCouplings.length > 0) {
     jCouplings.sort((a, b) => {
@@ -279,7 +279,7 @@ function abstractPattern(signal: SignalInternMandatory, jCouplings: number[]) {
         cont = 1;
       }
     }
-    let index = jCouplings.length - 1;
+    const index = jCouplings.length - 1;
     newNmrJs.push({
       coupling: Math.abs(jCouplings[index]),
       multiplicity: patterns[cont],
@@ -303,8 +303,8 @@ function abstractPattern(signal: SignalInternMandatory, jCouplings: number[]) {
  * @private
  */
 function idealPattern(jCouplings: number[]) {
-  let hsum = Math.pow(2, jCouplings.length);
-  let pattern = [{ x: 0, intensity: hsum }];
+  const hsum = Math.pow(2, jCouplings.length);
+  const pattern = [{ x: 0, intensity: hsum }];
   // To split the initial height
   for (const jc of jCouplings) {
     for (let j = pattern.length - 1; j >= 0; j--) {
@@ -337,8 +337,8 @@ function idealPattern(jCouplings: number[]) {
  * @private
  */
 function getNextCombination(ranges: GetRanges, value: number) {
-  let half = Math.ceil(ranges.values.length * 0.5);
-  let lng = ranges.values.length;
+  const half = Math.ceil(ranges.values.length * 0.5);
+  const lng = ranges.values.length;
   let sum = 0;
   let ok;
   while (sum !== value) {
@@ -375,7 +375,7 @@ function getNextCombination(ranges: GetRanges, value: number) {
   }
   // If the sum is equal to the expected value, fill the array to return
   if (sum === value) {
-    let heights = new Array(lng);
+    const heights = new Array(lng);
     for (let i = 0; i < half; i++) {
       heights[i] = ranges.values[i][ranges.currentIndex[i]];
       heights[lng - i - 1] = ranges.values[i][ranges.currentIndex[i]];
@@ -393,8 +393,8 @@ function getNextCombination(ranges: GetRanges, value: number) {
  * @private
  */
 function getRanges(peaks: Peak1DIntern[]): GetRanges {
-  let ranges: number[][] = new Array(peaks.length);
-  let currentIndex: number[] = new Array(peaks.length);
+  const ranges: number[][] = new Array(peaks.length);
+  const currentIndex: number[] = new Array(peaks.length);
   let min, max;
   ranges[0] = [1];
   ranges[peaks.length - 1] = [1];
@@ -428,20 +428,20 @@ function symmetrizeChoiseBest(
     jAxisKey: JAxisKeys;
   },
 ): SignalIntern {
-  let { maxError, iteration, jAxisKey = jAxisKeys } = options;
+  const { maxError, iteration, jAxisKey = jAxisKeys } = options;
   //make a clone of signal
-  let newSignal1 = symmetrize(signal, maxError, iteration, jAxisKey);
+  const newSignal1 = symmetrize(signal, maxError, iteration, jAxisKey);
 
   if (!newSignal1.peaksComp) {
     throw new Error('internal peaksComp was not created');
   }
 
-  let tmpPeaks = newSignal1.peaksComp;
-  let tmpMask = newSignal1.mask;
-  let cs = signal.delta;
+  const tmpPeaks = newSignal1.peaksComp;
+  const tmpMask = newSignal1.mask;
+  const cs = signal.delta;
   signal.delta =
     (signal.peaks[0].x + signal.peaks[signal.peaks.length - 1].x) / 2;
-  let newSignal2 = symmetrize(signal, maxError, iteration, jAxisKey);
+  const newSignal2 = symmetrize(signal, maxError, iteration, jAxisKey);
 
   if (!newSignal2.peaksComp) {
     throw new Error('internal peaksComp was not created');
@@ -471,15 +471,15 @@ function symmetrize(
   iteration: number,
   key: JAxisKeys,
 ): SignalIntern {
-  let { jAxis, intensity } = key;
+  const { jAxis, intensity } = key;
 
   const newSignal = JSON.parse(JSON.stringify(signalInput));
   // Before to symmetrize we need to keep only the peaks that possibly conforms the multiplete
   let max, min, avg, ratio, avgWidth;
-  let peaks: Peak1DIntern[] = new Array(newSignal.peaks.length);
+  const peaks: Peak1DIntern[] = new Array(newSignal.peaks.length);
   // Make a deep copy of the peaks and convert PPM ot HZ
   for (let i = 0; i < peaks.length; i++) {
-    let peak = newSignal.peaks[i];
+    const peak = newSignal.peaks[i];
     peaks[i] = {
       x: peak[jAxis] * newSignal.observe,
       intensity: peak[intensity],
@@ -500,8 +500,8 @@ function symmetrize(
     }
   }
   newSignal.peaksComp = peaks;
-  let nbPeaks = peaks.length;
-  let mask = new Array(nbPeaks);
+  const nbPeaks = peaks.length;
+  const mask = new Array(nbPeaks);
   newSignal.mask = mask;
   let left = 0;
   let right = peaks.length - 1;
@@ -537,8 +537,8 @@ function symmetrize(
           left--;
         }
       } else {
-        let diffL = Math.abs(peaks[left].x - cs);
-        let diffR = Math.abs(peaks[right].x - cs);
+        const diffL = Math.abs(peaks[left].x - cs);
+        const diffR = Math.abs(peaks[right].x - cs);
 
         if (Math.abs(diffL - diffR) < maxError) {
           avg = Math.min(peaks[left].intensity, peaks[right].intensity);
@@ -654,10 +654,10 @@ function error(value: number) {
  */
 function normalize(signal: SignalInternMandatory, n: number) {
   // Perhaps this is slow
-  let peaks: Peak1DIntern[] = JSON.parse(JSON.stringify(signal.peaksComp));
+  const peaks: Peak1DIntern[] = JSON.parse(JSON.stringify(signal.peaksComp));
   let norm = 0;
   let norm2 = 0;
-  for (let peak of peaks) {
+  for (const peak of peaks) {
     norm += peak.intensity;
   }
   norm = Math.pow(2, n) / norm;
@@ -704,7 +704,7 @@ function chemicalShift(peaks: Peak1DIntern[], mask: boolean[] = []) {
       }
     }
   } else {
-    for (let peak of peaks) {
+    for (const peak of peaks) {
       area = getArea(peak);
       sum += area;
       cs += area * peak.x;

package/src/types/Integrals.ts

@@ -2,6 +2,6 @@ import { Integral } from './Integral';
 import { SumOptions as Options } from './Options/SumOptions';
 
 export interface Integrals {
-  values: Array<Integral>;
+  values: Integral[];
   options: Options;
 }

package/src/types/Peaks/Peaks.ts

@@ -1,6 +1,6 @@
 import { Peak1D } from './Peak1D';
 
 export interface Peaks {
-  values: Array<Peak1D>;
+  values: Peak1D[];
   options: any;
 }

package/src/types/Ranges/Ranges.ts

@@ -3,7 +3,7 @@ import { SumOptions as Options } from '../Options/SumOptions';
 import { Signal1D } from '../Signals/Signal1D';
 
 export interface Ranges {
-  values: Array<Range>;
+  values: Range[];
   options: Options;
 }
 

package/src/types/Zones/Zone.ts

@@ -11,6 +11,6 @@ export interface Zone {
   id: string;
   x: ZoneAxis;
   y: ZoneAxis;
-  signals: Array<Signal2D>;
+  signals: Signal2D[];
   kind?: string;
 }

package/src/types/Zones/Zones.ts

@@ -1,6 +1,6 @@
 import { Zone } from './Zone';
 
 export interface Zones {
-  values: Array<Zone>;
+  values: Zone[];
   options?: any;
 }

package/src/utilities/getFrequency.ts

@@ -35,7 +35,7 @@ export function getFrequency(
 }
 
 function checkExistence(...nucleus: Nucleus[]) {
-  let nuclei: string[] = [];
+  const nuclei: string[] = [];
   for (const n of nucleus) {
     if (!(n in gyromagneticRatio)) {
       nuclei.push(n);

package/src/utilities/resurrectRange.ts

@@ -21,7 +21,7 @@ export function resurrectRange(part: string, options: any = {}) {
   const from = Number(beforeMatch.groups.from);
   const to = isARange ? Number(beforeMatch.groups.to) : from;
   const insideParts = split.inside.split(/ *, */);
-  let signal: NMRSignal1D = { delta: NaN, js: [] };
+  const signal: NMRSignal1D = { delta: NaN, js: [] };
   let range: NMRRange = { from, to, signals: [signal] };
   const integrationParts = insideParts.filter((part: any) =>
     part.match(/^[0-9]+\s*H$/),

package/src/xy/xyAutoPeaksPicking.ts

@@ -106,9 +106,9 @@ export function xyAutoPeaksPicking(
     direction = 'positive',
   } = options;
 
-  let pointsPerHz = 1 / frequency / (data.x[1] - data.x[0]);
+  const pointsPerHz = 1 / frequency / (data.x[1] - data.x[0]);
   // we can consider a peak with of 0.5 Hz for the windowSize
-  let ws = Math.max(Math.round(pointsPerHz / 2), 5);
+  const ws = Math.max(Math.round(pointsPerHz / 2), 5);
 
   const { windowSize = ws - (ws % 2) + 1, polynomial = 3 } = sgOptions;
 
@@ -134,7 +134,7 @@ export function xyAutoPeaksPicking(
 
   const cutOff = getCutOff(data.y, { noiseLevel, useSanPlot, thresholdFactor });
 
-  let getPeakOptions: GetPeakListOptions = {
+  const getPeakOptions: GetPeakListOptions = {
     shape,
     frequency,
     broadWidth,

package/src/xyz/quadrature.ts

@@ -1,5 +1,5 @@
 import { NmrData2D, DoubleArray } from 'cheminfo-types';
-import { xAdd, xMultiply, xSubtract } from 'ml-spectra-processing';
+import { xMultiply } from 'ml-spectra-processing';
 
 import { checkData2DFid, Data2DFidComplete } from '../utilities/checkData2DFid';
 
@@ -8,13 +8,11 @@ export function quadrature(data: NmrData2D, options: { fnMode: string }) {
 
   const { fnMode } = options;
 
-  switch (fnMode) {
+  switch (fnMode.toLowerCase()) {
     case 'ttpi':
       return ttpiQuadrature(data);
     case 'states':
       return shrQuadrature(data);
-    case 'echo':
-      return echoQuadrature(data);
     default:
       return {
         re: data.re.z,
@@ -23,29 +21,6 @@ export function quadrature(data: NmrData2D, options: { fnMode: string }) {
   }
 }
 
-function echoQuadrature(data: Data2DFidComplete) {
-  const {
-    re: { z: reMatrix },
-    im: { z: imMatrix },
-  } = data;
-
-  const newRe: DoubleArray[] = [];
-  const newIm: DoubleArray[] = [];
-  for (let i = 0; i < reMatrix.length; i += 2) {
-    let reCosine = reMatrix[i];
-    let imCosine = imMatrix[i];
-    let reSine = reMatrix[i + 1];
-    let imSine = imMatrix[i + 1];
-
-    newRe.push(xSubtract(xMultiply(imSine, -1), imCosine));
-    newRe.push(xSubtract(reSine, reCosine));
-    newIm.push(xAdd(reSine, reCosine));
-    newIm.push(xSubtract(imSine, imCosine));
-  }
-
-  return { re: newRe, im: newIm };
-}
-
 function shrQuadrature(data: Data2DFidComplete) {
   const { re, im } = data;
   return { re: re.z, im: im.z };

package/src/xyz/util/fft2d/digitalFilter.ts

@@ -4,9 +4,9 @@ export function digitalFilter(
   data: DataReIm,
   options: { digitalFilterValue: number },
 ) {
-  let { digitalFilterValue = 0 } = options;
-  let re = new Float64Array(data.re);
-  let im = new Float64Array(data.im);
+  const { digitalFilterValue = 0 } = options;
+  const re = new Float64Array(data.re);
+  const im = new Float64Array(data.im);
 
   let pointsToShift = Math.floor(digitalFilterValue);
 

package/src/xyz/util/fft2d/fftDirectDimension.ts

@@ -1,10 +1,6 @@
 import { DoubleArray } from 'cheminfo-types';
 import Matrix from 'ml-matrix';
-import {
-  reimAutoPhaseCorrection,
-  reimFFT,
-  reimPhaseCorrection,
-} from 'ml-spectra-processing';
+import { reimFFT, reimPhaseCorrection } from 'ml-spectra-processing';
 
 import {
   apodization,
@@ -31,7 +27,7 @@ export interface DirectDimensionOptions {
 
 export function fftDirectDimension(
   data: { re: DoubleArray[]; im: DoubleArray[] },
-  options: DirectDimensionOptions,
+  options: DirectDimensionOptions = {},
 ) {
   const { re: reData, im: imData } = data;
   const nbRows = reData.length;
@@ -46,12 +42,8 @@ export function fftDirectDimension(
   const reFFT = new Matrix(nbRows, nbPointsF2);
   const imFFT = new Matrix(nbRows, nbPointsF2);
 
-  const { apodization: apodizationF2 } = options;
-  let {
-    ph0: ph0F2,
-    ph1: ph1F2,
-    mode: pcModeF2 = 'no',
-  } = options?.phaseCorrection || {};
+  const { apodization: apodizationF2, phaseCorrection = {} } = options;
+  const { ph0: ph0F2, ph1: ph1F2, mode: pcModeF2 = 'no' } = phaseCorrection;
 
   for (let i = 0; i < nbRows; i++) {
     const newData = digitalFilter(
@@ -78,17 +70,6 @@ export function fftDirectDimension(
     if (dfResidual > 0) {
       Object.assign(newData, reimPhaseCorrection(newData, 0, -dfResidual));
     }
-
-    if (
-      i === 0 &&
-      pcModeF2 === 'pk' &&
-      ph0F2 === undefined &&
-      ph1F2 === undefined
-    ) {
-      const phased = reimAutoPhaseCorrection(newData, { magnitudeMode: false });
-      ph0F2 = phased.ph0;
-      ph1F2 = phased.ph1;
-    }
     if (pcModeF2 === 'pk' && ph0F2 !== undefined && ph1F2 !== undefined) {
       Object.assign(
         newData,