nmr-processing 9.5.1 → 9.5.2-pre.1685982544

package/src/signals/utils/jAnalyzer.ts

@@ -1,5 +1,6 @@
 import type { NMRPeak1D } from '../../peaks/NMRPeak1D';
 import type { MakeMandatory } from '../../utilities/MakeMandatory';
+import { Jcoupling } from '../Jcoupling';
 
 /*
  * This library implements the J analyser described by Cobas et al in the paper:
@@ -34,7 +35,7 @@ export type Peak1DIntern = Omit<NMRPeak1D, 'y' | 'shape'> & {
 };
 
 export interface SignalIntern {
-  id: string;
+  id?: string;
   delta: number;
   nbPeaks: number;
   startX: number;
@@ -44,17 +45,26 @@ export interface SignalIntern {
   mask?: boolean[];
   mask2?: boolean[];
   maskPattern?: boolean[];
-  nmrJs?: Array<{ coupling: number; multiplicity: string }>;
+  nmrJs?: Jcoupling[];
   multiplicity?: string;
   pattern?: string;
+
   observe: number;
-  nucleus: string;
-  kind: string;
+  nucleus?: string;
+  kind?: string;
   integralData: IntergralData;
   peaks: Peak1DIntern[];
   peaksComp?: Peak1DIntern[];
 }
 
+export type SignalFlexiblePeaks = Omit<SignalIntern, 'peaks'> & {
+  peaks: Array<
+    Omit<Peak1DIntern, 'intensity'> & {
+      intensity?: number;
+    }
+  >;
+};
+
 type SignalInternMandatory = MakeMandatory<
   SignalIntern,
   'symRank' | 'mask' | 'peaksComp'
@@ -83,7 +93,7 @@ export default {
    * @private
    */
   compilePattern: (
-    inputSignal: SignalIntern,
+    inputSignal: SignalFlexiblePeaks,
     options: OpitonsCompilePatter = {},
   ) => {
     let { jAxisKey = jAxisKeys } = options;
@@ -111,7 +121,7 @@ export default {
       signal.asymmetric = false;
       let P1, n2, maxFlagged;
       let k = 1;
-      let jCouplings = [];
+      let jCouplings: number[] = [];
 
       // Loop over the possible number of coupling contributing to the multiplet
       for (let n = 0; n < 9; n++) {
@@ -129,7 +139,7 @@ export default {
         n2 = Math.pow(2, n);
 
         // 1.4 Find a combination of integer heights Hi, one from each Si, that sums to 2^n.
-        let heights = null;
+        let heights: number[] | null = null;
         let counter = 1;
         while (
           !validPattern &&
@@ -250,7 +260,7 @@ function abstractPattern(signal: SignalInternMandatory, jCouplings: number[]) {
   let tol = 0.05;
   let pattern = '';
   let cont = 1;
-  let newNmrJs = [];
+  let newNmrJs: Jcoupling[] = [];
 
   if (jCouplings && jCouplings.length > 0) {
     jCouplings.sort((a, b) => {
@@ -411,7 +421,7 @@ function getRanges(peaks: Peak1DIntern[]): GetRanges {
  * @private
  */
 function symmetrizeChoiseBest(
-  signal: SignalIntern,
+  signal: SignalFlexiblePeaks,
   options: {
     maxError: number;
     iteration: number;
@@ -456,7 +466,7 @@ function symmetrizeChoiseBest(
  * @private
  */
 function symmetrize(
-  signalInput: SignalIntern,
+  signalInput: SignalFlexiblePeaks,
   maxError: number,
   iteration: number,
   key: JAxisKeys,

package/src/types/Data1D.ts

@@ -0,0 +1,5 @@
+export interface Data1D {
+  x: Float64Array;
+  re: Float64Array;
+  im?: Float64Array;
+}

package/src/types/Data2D.ts

@@ -0,0 +1,7 @@
+import { Data2DFid, Data2DFt } from 'cheminfo-types';
+
+export { Data2DFid } from 'cheminfo-types';
+export { Data2DFt } from 'cheminfo-types';
+export { MinMaxContent as Data2DContent } from 'cheminfo-types';
+
+export type Data2D = Data2DFid | Data2DFt;

package/src/types/Filter.ts

@@ -0,0 +1,12 @@
+export interface BaseFilter {
+  name: string;
+  value: any;
+  isDeleteAllow?: boolean;
+  flag?: boolean | null;
+  label?: string;
+}
+
+export interface Filter extends Required<BaseFilter> {
+  id: string;
+  error?: string;
+}

package/src/types/Info/Info.ts

@@ -0,0 +1,15 @@
+export interface Info {
+  isFid: boolean;
+  phc1?: number;
+  phc0?: number;
+  aqMod?: number;
+  isComplex: boolean;
+  dimension: number;
+  isFt: boolean;
+  experiment?: any;
+  digitalFilter?: number;
+  experimentNumber?: number;
+  solvent?: string;
+  pulseSequence?: string;
+  name: string;
+}

package/src/types/Info/Info1D.ts

@@ -0,0 +1,14 @@
+import { Info } from './Info';
+
+export interface Info1D extends Info {
+  nucleus: string;
+  spectralWidth: number;
+  originFrequency: number;
+  baseFrequency?: number;
+  digitalFilter?: number;
+  frequencyOffset?: number;
+  owner?: string;
+  reverse?: boolean;
+  DECIM?: number;
+  DSPFVS?: number;
+}

package/src/types/Info/Info2D.ts

@@ -0,0 +1,11 @@
+import { Info } from './Info';
+
+export interface Info2D extends Info {
+  nucleus: string[];
+  digitalFilter?: number;
+  originFrequency: number[];
+  baseFrequency: number[];
+  frequencyOffset: number[];
+  spectralWidth: number[];
+  reverse?: boolean[];
+}

package/src/types/Integral.ts

@@ -0,0 +1,10 @@
+export interface Integral {
+  id: string;
+  originFrom: number;
+  originTo: number;
+  from: number;
+  to: number;
+  absolute: number;
+  integral?: number;
+  kind: string;
+}

package/src/types/Integrals.ts

@@ -0,0 +1,7 @@
+import { Integral } from './Integral';
+import { SumOptions as Options } from './Options/SumOptions';
+
+export interface Integrals {
+  values: Array<Integral>;
+  options: Options;
+}

package/src/types/Options/SumOptions.ts

@@ -0,0 +1,24 @@
+export interface SumOptions {
+  /**
+   * @default true
+   */
+  isSumConstant: boolean;
+  /**
+   * If you force the "sum" the mf should not be exists any more otherwise if mf is exists the "sum" must be null or undefined
+   * @default undefined
+   */
+  sum: number | undefined;
+  /**
+   * @default true
+   */
+  sumAuto: boolean;
+  /**
+   * mf will be set automatically for the first time based on the first molecules unless the user change it
+   * example 'C10H20O3'
+   */
+  mf?: string;
+  /**
+   * key of the selected molecule
+   */
+  moleculeId?: string;
+}

package/src/types/Peaks/BasePeak.ts

@@ -0,0 +1,3 @@
+export interface BasePeak {
+  id: string;
+}

package/src/types/Peaks/Peak1D.ts

@@ -0,0 +1,7 @@
+import { NMRPeak1D } from '../..';
+
+import { BasePeak } from './BasePeak';
+
+export interface Peak1D extends Omit<NMRPeak1D, 'id'>, BasePeak {
+  originalX?: number;
+}

package/src/types/Peaks/Peak2D.ts

@@ -0,0 +1,11 @@
+import { BasePeak } from './BasePeak';
+
+export interface Peak2D extends BasePeak {
+  x: number;
+  y: number;
+  z: number;
+  originX?: number;
+  originY?: number;
+  originZ?: number;
+  width?: number | { x: number; y: number };
+}

package/src/types/Peaks/Peaks.ts

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

package/src/types/Ranges/Ranges.ts

@@ -0,0 +1,18 @@
+import { NMRRange } from '../..';
+import { SumOptions as Options } from '../Options/SumOptions';
+import { Signal1D } from '../Signals/Signal1D';
+
+export interface Ranges {
+  values: Array<Range>;
+  options: Options;
+}
+
+export interface Range extends Omit<NMRRange, 'signals' | 'id'> {
+  id: string;
+  originFrom?: number;
+  originTo?: number;
+  absolute: number;
+  signals: Signal1D[];
+  integration: number;
+  nbAtoms?: number;
+}

package/src/types/Signals/Signal.ts

@@ -0,0 +1,4 @@
+export interface Signal {
+  id: string;
+  kind?: string;
+}

package/src/types/Signals/Signal1D.ts

@@ -0,0 +1,8 @@
+import { NMRSignal1D } from '../../signals/NMRSignal1D';
+
+type ObjectKeys = 'id' | 'multiplicity' | 'js';
+export interface Signal1D
+  extends Required<Pick<NMRSignal1D, ObjectKeys>>,
+    Omit<NMRSignal1D, ObjectKeys> {
+  originDelta?: number;
+}

package/src/types/Signals/Signal2D.ts

@@ -0,0 +1,21 @@
+import { FromTo } from 'cheminfo-types';
+
+import type { Peak2D } from '../Peaks/Peak2D';
+
+import type { Signal } from './Signal';
+
+interface SignalAxis {
+  delta: number;
+  diaIDs?: string[];
+  originDelta: number;
+}
+
+export interface Signal2D extends Signal {
+  sign?: number;
+  x: SignalAxis;
+  y: SignalAxis;
+  peaks?: Peak2D[];
+  j?: {
+    pathLength?: number | FromTo;
+  };
+}

package/src/types/Zones/Zone.ts

@@ -0,0 +1,15 @@
+import { FromTo } from 'cheminfo-types';
+
+import { Signal2D } from '../Signals/Signal2D';
+
+interface ZoneAxis extends FromTo {
+  diaIDs?: string[];
+}
+
+export interface Zone {
+  id: string;
+  x: ZoneAxis;
+  y: ZoneAxis;
+  signals: Array<Signal2D>;
+  kind?: string;
+}

package/src/types/Zones/Zones.ts

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

package/src/types/common/MapOptions.ts

@@ -0,0 +1,6 @@
+export type ShiftTarget = 'origin' | 'current';
+
+export interface MapOptions {
+  checkIsExisting?: boolean;
+  shiftTarget?: ShiftTarget;
+}

package/src/utilities/checkData2DFid.ts

@@ -0,0 +1,10 @@
+import { Data2D, Data2DFid } from 'cheminfo-types';
+
+export type Data2DFidComplete = Required<Data2DFid>;
+export function checkData2DFid(
+  data: Data2D,
+): asserts data is Data2DFidComplete {
+  if (!('re' in data && 'im' in data)) {
+    throw new Error('imaginary (im) data should exists');
+  }
+}

package/src/utilities/cloneData1D.ts

@@ -0,0 +1,6 @@
+import { Data1D } from '../types/Data1D';
+
+export function cloneData1D(datum: Data1D) {
+  const { x, re, im } = datum || { x: [], re: [], im: [] };
+  return { x: x.slice(), re: re.slice(), im: im?.slice() || null };
+}

package/src/utilities/cloneData2D.ts

@@ -0,0 +1,27 @@
+import { Data2D, Data2DFid, Data2DFt, MinMaxContent } from 'cheminfo-types';
+
+export function cloneData2D(data: Data2D) {
+  const newData: any = {};
+
+  if (isData2DFt(data)) {
+    for (const key in data) {
+      addCloneData(newData, key, data[key as keyof Data2DFt]);
+    }
+  } else {
+    for (const key in data) {
+      addCloneData(newData, key, data[key as keyof Data2DFid]);
+    }
+  }
+  return newData;
+}
+
+function isData2DFt(data: Data2D): data is Data2DFt {
+  return 're' in data;
+}
+
+function addCloneData(newData: any, key: string, data?: MinMaxContent) {
+  if (data) {
+    const { z, ...other } = data;
+    newData[key] = { z: z.slice(), ...other };
+  }
+}

package/src/utilities/getSum.ts

@@ -0,0 +1,23 @@
+/**
+ * Sum values for specific key in the object
+ * @param values array of object
+ * @param key key
+ * @param check custom check function to to indicate if certain object included or not in the summation
+ * @returns number
+ */
+
+export function getSum<Type extends object>(
+  values: Type[],
+  key: keyof Type,
+  check: ((value: Type) => boolean) | null = null,
+) {
+  let sum = 0;
+  for (const current of values) {
+    if (check?.(current)) {
+      const value = current[key];
+      if (!value || isNaN(value)) continue;
+      sum += Math.abs(value);
+    }
+  }
+  return sum;
+}

package/src/xyz/quadrature.ts

@@ -0,0 +1,68 @@
+import { Data2D, DoubleArray } from 'cheminfo-types';
+import { xAdd, xMultiply, xSubtract } from 'ml-spectra-processing';
+
+import { checkData2DFid, Data2DFidComplete } from '../utilities/checkData2DFid';
+
+export function quadrature(data: Data2D, options: { fnMode: string }) {
+  checkData2DFid(data);
+
+  const { fnMode } = options;
+
+  switch (fnMode) {
+    case 'ttpi':
+      return ttpiQuadrature(data);
+    case 'states':
+      return shrQuadrature(data);
+    case 'echo':
+      return echoQuadrature(data);
+    default:
+      return {
+        re: data.re.z,
+        im: data.im.z,
+      };
+  }
+}
+
+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 };
+}
+
+function ttpiQuadrature(data: Data2DFidComplete) {
+  const newRe: DoubleArray[] = [];
+  const newIm: DoubleArray[] = [];
+
+  const {
+    re: { z: reMatrix },
+    im: { z: imMatrix },
+  } = data;
+  for (let i = 0; i < reMatrix.length; i++) {
+    newRe.push(i % 2 ? reMatrix[i].slice() : xMultiply(reMatrix[i], -1));
+    newIm.push(i % 2 ? imMatrix[i].slice() : xMultiply(imMatrix[i], -1));
+  }
+
+  return { re: newRe, im: newIm };
+}

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

@@ -0,0 +1,24 @@
+import { DataReIm } from 'ml-spectra-processing';
+
+export function digitalFilter(
+  data: DataReIm,
+  options: { digitalFilterValue: number },
+) {
+  let { digitalFilterValue = 0 } = options;
+  let re = new Float64Array(data.re);
+  let im = new Float64Array(data.im);
+
+  let pointsToShift = Math.floor(digitalFilterValue);
+
+  const skip = 0;
+  pointsToShift += 0;
+
+  const newRe = new Float64Array(re.length);
+  const newIm = new Float64Array(im.length);
+  newRe.set(re.slice(pointsToShift));
+  newRe.set(re.slice(skip, pointsToShift), re.length - pointsToShift);
+  newIm.set(im.slice(pointsToShift));
+  newIm.set(im.slice(skip, pointsToShift), im.length - pointsToShift);
+
+  return { re: newRe, im: newIm };
+}

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

@@ -0,0 +1,111 @@
+import { DoubleArray } from 'cheminfo-types';
+import Matrix from 'ml-matrix';
+import {
+  reimAutoPhaseCorrection,
+  reimFFT,
+  reimPhaseCorrection,
+} from 'ml-spectra-processing';
+
+import {
+  apodization,
+  ApodizationFilterOptions,
+} from '../../../apodization/apodization';
+
+import { digitalFilter } from './digitalFilter';
+import { removeDCOffset } from './removeDCOffset';
+import { zeroFilling, ZeroFillingOptions } from './zeroFilling';
+
+interface PhaseCorrection {
+  mode?: string;
+  ph0?: number;
+  ph1?: number;
+}
+
+export interface DirectDimensionOptions {
+  fnMode?: string;
+  digitalFilterValue?: number;
+  zeroFilling?: ZeroFillingOptions;
+  apodization?: ApodizationFilterOptions;
+  phaseCorrection?: PhaseCorrection;
+}
+
+export function fftDirectDimension(
+  data: { re: DoubleArray[]; im: DoubleArray[] },
+  options: DirectDimensionOptions,
+) {
+  const { re: reData, im: imData } = data;
+  const nbRows = reData.length;
+  const nbColumns = reData[0].length;
+
+  const { zeroFilling: zeroFillingF2, digitalFilterValue = 0 } = options;
+
+  const { factor: f2Factor = 2 } = zeroFillingF2 || {};
+  const nbPointsF2 =
+    zeroFillingF2?.nbPoints || 2 ** Math.round(Math.log2(nbColumns * f2Factor));
+
+  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 || {};
+
+  for (let i = 0; i < nbRows; i++) {
+    const newData = digitalFilter(
+      { re: reData[i], im: imData[i] },
+      { digitalFilterValue },
+    );
+
+    Object.assign(newData, removeDCOffset(newData, { digitalFilterValue }));
+
+    if (apodizationF2) {
+      const { re: aRe, im: aIm } = apodization(newData, apodizationF2);
+      Object.assign(newData, { re: aRe, im: aIm });
+    }
+
+    Object.assign(
+      newData,
+      zeroFilling(newData, { digitalFilterValue, nbPoints: nbPointsF2 }),
+    );
+
+    Object.assign(newData, reimFFT(newData, { applyZeroShift: true }));
+
+    const dfResidual =
+      (digitalFilterValue - Math.round(digitalFilterValue)) * Math.PI * 2;
+    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,
+        reimPhaseCorrection(
+          newData,
+          (ph0F2 * Math.PI) / 180,
+          (ph1F2 * Math.PI) / 180,
+        ),
+      );
+    }
+
+    reFFT.setRow(i, newData.re);
+    imFFT.setRow(i, newData.im);
+  }
+
+  return {
+    re: reFFT,
+    im: imFFT,
+  };
+}