nmr-processing 9.5.0 → 9.5.1-pre.1685396168

package/src/datum/data2d/utils/getShift.ts

@@ -0,0 +1,23 @@
+import { Spectrum2D } from '../../../types/Spectrum/Spectrum2D';
+import { Filters } from '../../Filters';
+
+export interface Shift2D {
+  x: number;
+  y: number;
+}
+
+export function getShift(spectrum: Spectrum2D): Shift2D {
+  let shift = { x: 0, y: 0 };
+  if (spectrum?.filters) {
+    for (const filter of spectrum.filters) {
+      if (filter.name === Filters.shift2DX.id) {
+        shift.x = filter?.flag ? filter.value.shift : 0;
+      }
+      if (filter.name === Filters.shift2DY.id) {
+        shift.y = filter?.flag ? filter.value.shift : 0;
+      }
+    }
+  }
+
+  return shift;
+}

package/src/datum/data2d/utils/isZoneExists.ts

@@ -0,0 +1,27 @@
+import { Spectrum2D } from '../../../types/Spectrum/Spectrum2D';
+import { Zone } from '../../../types/Zones/Zone';
+
+import { Zone2DError } from './get2DSpectrumErrorValue';
+
+export function isZoneExists(
+  zone: Zone,
+  spectrum: Spectrum2D,
+  error: Zone2DError,
+) {
+  const newXRange = zone.x || { from: 0, to: 0 };
+  const newYRange = zone.y || { from: 0, to: 0 };
+
+  if (!spectrum.zones?.values) return false;
+
+  for (const { x, y } of spectrum.zones.values) {
+    if (
+      Math.abs(newXRange.from - x.from) < error.x &&
+      Math.abs(newXRange.to - x.to) < error.x &&
+      Math.abs(newYRange.from - y.from) < error.y &&
+      Math.abs(newYRange.to - y.to) < error.y
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/datum/data2d/utils/mapZones.ts

@@ -0,0 +1,80 @@
+import { v4 } from '@lukeed/uuid';
+
+import { DatumKind } from '../../../constants/SignalsKinds';
+import { Signal2D } from '../../../types/Signals/Signal2D';
+import { Spectrum2D } from '../../../types/Spectrum/Spectrum2D';
+import { Zone } from '../../../types/Zones/Zone';
+import { MapOptions, ShiftTarget } from '../../../types/common/MapOptions';
+
+import { get2DSpectrumErrorValue } from './get2DSpectrumErrorValue';
+import { getShift, Shift2D } from './getShift';
+import { isZoneExists } from './isZoneExists';
+
+function getSignal(signal: Signal2D, shiftTarget: ShiftTarget, shift: Shift2D) {
+  const { x, y } = signal;
+
+  if (shiftTarget === 'origin') {
+    return {
+      ...signal,
+      x: {
+        ...x,
+        originDelta: x.delta - shift.x,
+      },
+      y: {
+        ...y,
+        originDelta: y.delta - shift.y,
+      },
+    };
+  } else {
+    return {
+      ...signal,
+      x: {
+        ...x,
+        delta: x.originDelta + shift.x,
+      },
+      y: {
+        ...y,
+        delta: y.originDelta + shift.y,
+      },
+    };
+  }
+}
+
+export function mapZones(
+  zones: Zone[],
+  datum: Spectrum2D,
+  options: MapOptions = {},
+) {
+  const { checkIsExisting = true, shiftTarget = 'origin' } = options;
+  const shift = getShift(datum);
+  const error = get2DSpectrumErrorValue(datum);
+
+  let _zones: Zone[] = zones;
+
+  if (checkIsExisting) {
+    _zones = zones.filter((zone) => !isZoneExists(zone, datum, error));
+  }
+
+  return _zones.map((zone: Zone) => {
+    const x = zone.x || { from: 0, to: 0 };
+    const y = zone.y || { from: 0, to: 0 };
+
+    const signals = zone.signals.map((signal) => {
+      const { id, kind } = signal;
+      return {
+        ...getSignal(signal, shiftTarget, shift),
+        id: id || v4(),
+        kind: kind || 'signal',
+      };
+    });
+
+    return {
+      ...zone,
+      id: zone.id || v4(),
+      x: { from: x.from, to: x.to },
+      y: { from: y.from, to: y.to },
+      signals,
+      kind: zone.kind || DatumKind.signal,
+    };
+  });
+}

package/src/datum/data2d/utils/updateZones.ts

@@ -0,0 +1,10 @@
+import { Spectrum2D } from '../../../types/Spectrum/Spectrum2D';
+
+import { mapZones } from './mapZones';
+
+export function updateZones(spectrum: Spectrum2D) {
+  spectrum.zones.values = mapZones(spectrum.zones.values, spectrum, {
+    checkIsExisting: false,
+    shiftTarget: 'current',
+  });
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from 'gyromagnetic-ratio';
 export * from './constants/impurities';
+export * from './constants/SignalsKinds';
 export * from './constants/couplingPatterns';
 
 export * from './peaks/peaksFilterImpurities';
@@ -40,6 +41,7 @@ export * from './xy/xyPeaksOptimization';
 export * from './xyz/xyzAutoZonesPicking';
 export * from './xyz/xyzAutoSignalsPicking';
 export * from './xyz/xyzJResAnalyzer';
+export * from './xyz/xyzBidimensionalFFT';
 
 export * from './databases/getDatabase';
 export * from './databases/carbonImpurities';
@@ -58,8 +60,44 @@ export * from './multiplicity/checkMultiplet';
 export * from './multiplicity/checkMultiplicity';
 export * from './multiplicity/translateMultiplet';
 
+export * from './datum/Filters';
+export * as FiltersManager from './datum/FiltersManager';
+export * from './datum/data1d/utils/getShiftX';
+export * from './datum/data1d/utils/getSpectrumErrorValue';
+export * from './datum/data1d/utils/mapPeaks';
+export * from './datum/data1d/utils/mapRanges';
+export * from './datum/data1d/utils/updateRanges';
+export * from './datum/data1d/utils/checkIntegralKind';
+export * from './datum/data1d/updateRelatives';
+export * from './datum/data1d/utils/updateRangesRelativeValues';
+export * from './datum/data1d/utils/updateIntegralsRelativeValues';
+export * as RangeUtilities from './datum/data1d/utils/RangeUtilities';
+
+export type { BaseFilter, Filter } from './types/Filter';
+
 export type { NMRSignal1D } from './signals/NMRSignal1D';
 export type { NMRSignal2D, Signal2DProjection } from './xyz/NMRSignal2D';
+export type { Peaks } from './types/Peaks/Peaks';
+export type { Peak1D } from './types/Peaks/Peak1D';
+export type { Peak2D } from './types/Peaks/Peak2D';
+export type { Signal1D } from './types/Signals/Signal1D';
+export type { Signal2D } from './types/Signals/Signal2D';
+export type { Range, Ranges } from './types/Ranges/Ranges';
+export type { Zone } from './types/Zones/Zone';
+export type { Zones } from './types/Zones/Zones';
+export type { Data1D } from './types/Data1D';
+export type { Data2D } from './types/Data2D';
+export type { Display1D } from './types/Display1D';
+export type { Color2D, Display2D } from './types/Display2D';
+export type { Info1D } from './types/Info/Info1D';
+export type { Info2D } from './types/Info/Info2D';
+export type { Integral } from './types/Integral';
+export type { Integrals } from './types/Integrals';
+export type { SumOptions } from './types/Options/SumOptions';
+export type { Spectrum } from './types/Spectrum/Spectrum';
+export type { Spectrum1D, Spectrum1DSource } from './types/Spectrum/Spectrum1D';
+export type { Spectrum2D, Spectrum2DSource } from './types/Spectrum/Spectrum2D';
+
 export type { NMRRange } from './xy/NMRRange';
 export type { NMRZone } from './xyz/NMRZone';
 export type { NMRPeak1D } from './peaks/NMRPeak1D';

package/src/signals/signalsToRanges.ts

@@ -56,7 +56,7 @@ export function signalsToRanges(
 
   wrapped = wrapped.sort((signal1, signal2) => signal1.from - signal2.from);
 
-  let ranges = [];
+  let ranges: RangeFullfiled[] = [];
   let range = {} as RangeFullfiled;
   for (let signal of wrapped) {
     if (range.from === undefined || signal.from > range.to) {

package/src/signals/simulation/simulateXYPeaks.ts

@@ -68,7 +68,7 @@ export function simulateXYPeaks(
 
   const multiplicity = spinSystem.multiplicity;
 
-  const xyPeaks = [];
+  const xyPeaks: Array<{ x: number; y: number }> = [];
   for (const cluster of spinSystem.clusters) {
     let clusterFake = cluster.map((cluster) =>
       cluster < 0 ? -cluster - 1 : cluster,

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/ContourOptions.ts

@@ -0,0 +1,10 @@
+export interface ContourOptions {
+  positive: {
+    contourLevels: [number, number];
+    numberOfLayers: number;
+  };
+  negative: {
+    contourLevels: [number, number];
+    numberOfLayers: number;
+  };
+}

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/Display.ts

@@ -0,0 +1,3 @@
+export interface Display {
+  isVisible: boolean;
+}

package/src/types/Display1D.ts

@@ -0,0 +1,8 @@
+import { Display } from './Display';
+
+export interface Display1D extends Display {
+  color: string;
+  isPeaksMarkersVisible: boolean;
+  isRealSpectrumVisible: boolean;
+  isVisibleInDomain: boolean;
+}

package/src/types/Display2D.ts

@@ -0,0 +1,12 @@
+import { ContourOptions } from './ContourOptions';
+import { Display } from './Display';
+
+export interface Color2D {
+  positiveColor: string;
+  negativeColor: string;
+}
+export interface Display2D extends Color2D, Display {
+  isPositiveVisible: boolean;
+  isNegativeVisible: boolean;
+  contourOptions: ContourOptions;
+}

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/Jcoupling.ts

@@ -0,0 +1,5 @@
+export interface Jcoupling {
+  coupling: number;
+  multiplicity: string;
+  diaID: string[];
+}

package/src/types/ObjectXY.ts

@@ -0,0 +1,4 @@
+export interface ObjectXY {
+  y: number;
+  x: number;
+}

package/src/types/Options/DataSelectionOption.ts

@@ -0,0 +1,6 @@
+export type DataSelectionOption =
+  | 'ft'
+  | 'fid'
+  | 'both'
+  | 'preferFT'
+  | 'preferFID';

package/src/types/Options/JcampParsingOptions.ts

@@ -0,0 +1,35 @@
+import { Logger } from 'cheminfo-types';
+
+import { DataSelectionOption } from './DataSelectionOption';
+
+export interface JcampParsingOptions {
+  name?: string;
+  converter?: JcampConverterOptions;
+  selector?: JcampSelectorOptions;
+  keepSource?: boolean;
+  logger?: Logger;
+}
+
+export interface JcampSelectorOptions {
+  index?: number;
+  tree?: FilterTreeByDataTypeDataClass[];
+  dataSelection?: DataSelectionOption;
+}
+
+export interface JcampConverterOptions {
+  keepRecordsRegExp?: RegExp;
+  profiling?: boolean;
+}
+
+export interface FilterTreeByDataTypeDataClass {
+  /**
+   * dataClass to be filter out of the tree, default value is
+   * the same dataClass of the input data.
+   */
+  dataClass?: string;
+  /**
+   * dataType to be filter out of the tree, default value is
+   * the same dataType of the input data.
+   */
+  dataType?: string;
+}

package/src/types/Options/NmredataParsingOptions.ts

@@ -0,0 +1,20 @@
+import { ConverterOptions as BrukerConverterOptions } from 'brukerconverter';
+
+import { JcampConverterOptions } from './JcampParsingOptions';
+import {
+  BrukerLoaderSelector,
+  GeneralLoadersSelector,
+  JcampLoaderSelector,
+} from './ParsingOptions';
+
+export interface NmredataParsingOptions {
+  converter?: {
+    jcamp?: JcampConverterOptions;
+    bruker?: BrukerConverterOptions;
+  };
+  selector?: {
+    general?: GeneralLoadersSelector;
+    bruker?: BrukerLoaderSelector;
+    jcamp?: JcampLoaderSelector;
+  };
+}

package/src/types/Options/ParsingOptions.ts

@@ -0,0 +1,80 @@
+import { ConverterOptions as BrukerConverterOptions } from 'brukerconverter';
+import type { Logger } from 'cheminfo-types';
+
+import { DataSelectionOption } from './DataSelectionOption';
+import { JcampConverterOptions } from './JcampParsingOptions';
+import { NmredataParsingOptions } from './NmredataParsingOptions';
+
+export interface GeneralLoadersSelector {
+  /**
+   * priories processed or raw data if both exists
+   * @default 'both'
+   */
+  dataSelection?: DataSelectionOption;
+  /**
+   * should we ignore 1D spectra
+   * @default true
+   */
+  keep1D?: boolean;
+  /**
+   * should we ignore 2D spectra
+   * @default true
+   */
+  keep2D?: boolean;
+  /**
+   * should we keep only real part. we will ignore keepFID
+   * @default true
+   */
+  onlyReal?: boolean;
+}
+
+export interface BrukerLoaderSelector {
+  /**
+   * processing number to select, default the smallest number
+   */
+  processingNumbers?: string;
+  /**
+   * experiment number to select, default all
+   */
+  experimentNumbers?: string;
+  /**
+   * should we take only the first processed data (procno).
+   * @default true
+   */
+  onlyFirstProcessedData?: boolean;
+}
+
+export interface JcampTreeFilter {
+  /**
+   * Data type comes from the LDR
+   */
+  dataType?: string;
+  dataClass?: string;
+}
+
+export interface JcampLoaderSelector {
+  index?: number;
+  tree?: JcampTreeFilter[];
+}
+
+export interface NmrLoaderSelectors {
+  general?: GeneralLoadersSelector;
+  bruker?: BrukerLoaderSelector;
+  jcamp?: JcampLoaderSelector;
+  files?: string[];
+}
+export interface ParsingOptions {
+  name?: string;
+  converter?: {
+    jcamp?: JcampConverterOptions;
+    bruker?: BrukerConverterOptions;
+    nmredata?: NmredataParsingOptions;
+  };
+  sourceSelector?: NmrLoaderSelectors;
+  /**
+   * if it is true the source object with files will be keeped
+   * @default false
+   */
+  keepSource?: boolean;
+  logger?: Logger;
+}

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;
+}