nmr-processing 9.1.0 → 9.2.0

package/src/signals/optimization/getInternalSignals.ts

@@ -0,0 +1,287 @@
+import { DataXY } from 'cheminfo-types';
+import { getShape1D, Shape1D, Shape1DInstance } from 'ml-peak-shape-generator';
+import { xyFindClosestPoint } from 'ml-spectra-processing';
+
+import { MakeMandatory } from '../../utilities/MakeMandatory';
+import { Jcoupling } from '../Jcoupling';
+import { Signal } from '../optimizeSignals';
+
+import { defaultParameters } from './defaultParameters';
+import { signalsToPointXY } from './signalsToPointXY';
+
+const properties = ['init', 'min', 'max', 'gradientDifference'];
+
+export interface InternalSignal {
+  shape: Shape1D;
+  shapeFct: Shape1DInstance;
+  signal: MakeMandatory<Signal, 'js' | 'intensity'>;
+  parameters: string[];
+  propertiesValues: Record<string, number[]>;
+  fromIndex: number;
+  toIndex: number;
+  fromIndexCoupling: number;
+  toIndexCoupling: number;
+}
+export type Parameter = 'delta' | 'intensity' | 'fwhm' | 'mu' | 'coupling';
+
+export type ParametersFromOptions = Record<
+  Parameter,
+  Record<
+    string,
+    | number
+    | ((options?: {
+        signal?: Signal;
+        shape?: Shape1D;
+        index?: number;
+        jCoupling?: Jcoupling;
+      }) => number)
+  >
+>;
+export interface GetInternalSignalsOptions {
+  /**
+   * Initial line width in Hz
+   * @default 1
+   */
+  lineWidth?: number;
+  /**
+   * frequency
+   */
+  frequency: number;
+  baseline?: number;
+  shape?: Shape1D;
+  parameters?: ParametersFromOptions;
+}
+
+export type Shape1DWithFWHM = Omit<Shape1D, 'fwhm'> & { fwhm: number };
+export function getInternalSignals(
+  data: DataXY,
+  signals: Signal[],
+  minMaxY: Record<string, number>,
+  options: GetInternalSignalsOptions,
+) {
+  let index = 0;
+  let internalSignals = [];
+  const {
+    shape: shapeAsOption = { kind: 'gaussian' },
+    baseline: shiftValue = minMaxY.min,
+    lineWidth = 1,
+    frequency,
+  } = options;
+
+  const normalizedSignals = normalizeSignals({
+    signals,
+    data,
+    shiftValue,
+    frequency,
+    range: minMaxY.range,
+  });
+
+  for (const signal of normalizedSignals) {
+    const { shape = { ...shapeAsOption } } = signal;
+
+    if (!shape.fwhm) {
+      shape.fwhm = lineWidth;
+    }
+
+    shape.fwhm /= frequency;
+    const shapeFct = getShape1D(shape);
+
+    const parameters: Parameter[] = [
+      'delta',
+      'intensity',
+      ...shapeFct.getParameters(),
+    ];
+
+    const propertiesValues: Record<string, number[]> = {
+      min: [],
+      max: [],
+      init: [],
+      gradientDifference: [],
+    };
+
+    for (const parameter of parameters) {
+      for (const property of properties) {
+        propertiesValues[property].push(
+          getPropertyValue({
+            signal,
+            frequency,
+            parameter,
+            property,
+            minMaxY,
+            shapeFct,
+          }),
+        );
+      }
+    }
+
+    for (const jCoupling of signal.js || []) {
+      for (const property of properties) {
+        const parameter = 'coupling' as Parameter;
+        let generalParameterValue =
+          options?.parameters?.[parameter]?.[property];
+        if (generalParameterValue) {
+          if (typeof generalParameterValue === 'number') {
+            propertiesValues[property].push(
+              getNormalizedValue(
+                generalParameterValue,
+                parameter,
+                property,
+                minMaxY,
+                frequency,
+                options.baseline,
+              ),
+            );
+          } else {
+            let value = generalParameterValue({ jCoupling });
+            propertiesValues[property].push(
+              getNormalizedValue(
+                value,
+                parameter,
+                property,
+                minMaxY,
+                frequency,
+                options.baseline,
+              ),
+            );
+          }
+        }
+        if (!defaultParameters[parameter]) {
+          throw new Error(`No default parameter for ${parameter}`);
+        }
+        const defaultParameterValues = defaultParameters[parameter][property];
+        propertiesValues[property].push(defaultParameterValues({ jCoupling }));
+      }
+    }
+
+    const fromIndex = index;
+    const toIndex = fromIndex + parameters.length - 1;
+
+    const fromIndexCoupling = toIndex + 1;
+    const toIndexCoupling = fromIndexCoupling + signal.js.length - 1;
+
+    index += toIndexCoupling - fromIndex + 1;
+    internalSignals.push({
+      shape: shape as Shape1DWithFWHM,
+      shapeFct,
+      signal,
+      parameters,
+      propertiesValues,
+      fromIndex,
+      toIndex,
+      fromIndexCoupling,
+      toIndexCoupling,
+    });
+  }
+
+  return internalSignals;
+}
+
+function normalizeSignals<T extends Signal>(options: {
+  signals: T[];
+  data: DataXY;
+  shiftValue: number;
+  frequency: number;
+  range: number;
+}) {
+  const { signals, data, frequency, shiftValue, range } = options;
+
+  const getMaxIntensity = (signal: Signal) => {
+    const peaks = signalsToPointXY([signal], { frequency, maxClusterSize: 1 });
+    const biggestPeak = peaks.reduce(
+      (biggest, peak) => (peak.y > biggest.y ? peak : biggest),
+      peaks[0],
+    );
+    const { y: maxIntensity } = xyFindClosestPoint(data, biggestPeak.x);
+    return maxIntensity;
+  };
+
+  return signals.map((signal) => {
+    const { intensity = getMaxIntensity(signal) } = signal;
+    return {
+      ...signal,
+      js: signal.js || [],
+      intensity: (intensity - shiftValue) / range,
+    };
+  });
+}
+
+function getPropertyValue(options: {
+  signal: Signal;
+  parameter: Parameter;
+  property: string;
+  minMaxY: Record<string, number>;
+  shapeFct: Shape1DInstance;
+  frequency: number;
+  baseline?: number;
+  parameters?: ParametersFromOptions;
+}) {
+  const { signal, frequency, parameter, property, minMaxY, shapeFct } = options;
+
+  // check if the property is specified in the signal
+  let propertyValue = signal?.parameters?.[parameter]?.[property];
+  if (propertyValue) {
+    return getNormalizedValue(
+      propertyValue,
+      parameter,
+      property,
+      minMaxY,
+      frequency,
+      options.baseline,
+    );
+  }
+
+  // check if there are some global option, it could be a number or a callback
+
+  let generalParameterValue = options?.parameters?.[parameter]?.[property];
+  if (generalParameterValue) {
+    if (typeof generalParameterValue === 'number') {
+      return getNormalizedValue(
+        generalParameterValue,
+        parameter,
+        property,
+        minMaxY,
+        frequency,
+        options.baseline,
+      );
+    } else {
+      let value = generalParameterValue(signal);
+      return getNormalizedValue(
+        value,
+        parameter,
+        property,
+        minMaxY,
+        frequency,
+        options.baseline,
+      );
+    }
+  }
+
+  // we just need to take the default parameters
+  if (!defaultParameters[parameter]) {
+    throw new Error(`No default parameter for ${parameter}`);
+  }
+  const defaultParameterValues = defaultParameters[parameter][property];
+  return defaultParameterValues({ signal, shape: shapeFct });
+}
+
+function getNormalizedValue(
+  value: number,
+  parameter: keyof ParametersFromOptions,
+  property: string,
+  minMaxY: Record<string, number>,
+  frequency: number,
+  baseline?: number,
+) {
+  if (parameter === 'intensity') {
+    if (property === 'gradientDifference') {
+      return value;
+    } else {
+      return baseline !== undefined
+        ? (value - baseline) / minMaxY.range
+        : (value - minMaxY.min) / minMaxY.range;
+    }
+  } else if (parameter === 'fwhm') {
+    return value / frequency;
+  }
+  return value;
+}

package/src/signals/optimization/getSumOfShapes.ts

@@ -0,0 +1,54 @@
+import { InternalSignal } from './getInternalSignals';
+import { signalsToPointXY, SignalsToPointXYOptions } from './signalsToPointXY';
+
+export type SumOfShapes = (parameters: number[]) => (x: number) => number;
+
+const defaultSimulationOptions: Partial<SignalsToPointXYOptions> = {
+  maxClusterSize: 1,
+};
+export function getSumOfShapes(
+  internalSignals: InternalSignal[],
+  options: SignalsToPointXYOptions,
+) {
+  const simulationOptions = { ...defaultSimulationOptions, ...options };
+  return function sumOfShapes(parameters: number[]) {
+    const peaks: any = [];
+    for (const internalSignal of internalSignals) {
+      const delta = parameters[internalSignal.fromIndex];
+      const intensity = parameters[internalSignal.fromIndex + 1];
+      for (let i = 2; i < internalSignal.parameters.length; i++) {
+        //@ts-expect-error Not simply to solve the issue
+        internalSignal.shapeFct[internalSignal.parameters[i]] =
+          parameters[internalSignal.fromIndex + i];
+      }
+      const couplings = internalSignal.signal.js;
+      for (let i = 0; i < couplings.length; i++) {
+        couplings[i].coupling =
+          parameters[internalSignal.fromIndexCoupling + i];
+      }
+      const currentPeaks = signalsToPointXY(
+        [
+          {
+            delta,
+            js: couplings,
+          },
+        ],
+        simulationOptions,
+      );
+
+      peaks.push(
+        ...currentPeaks.map((peak) => {
+          return { intensity, shape: internalSignal.shapeFct, ...peak };
+        }),
+      );
+    }
+    return (currentX: number) => {
+      let totalY = 0;
+      for (let peak of peaks) {
+        const { x, y, intensity, shape } = peak;
+        totalY += y * intensity * shape.fct(currentX - x);
+      }
+      return totalY;
+    };
+  };
+}

package/src/signals/optimization/signalsToPointXY.ts

@@ -0,0 +1,37 @@
+import { NMRSignal1D } from '../NMRSignal1D';
+import { addDummySignals } from '../addDummySignals';
+import { signalsToSpinSystem } from '../simulation/signalsToSpinSystem';
+import { simulateXYPeaks } from '../simulation/simulateXYPeaks';
+import { splitSpinSystem } from '../simulation/splitSpinSystem';
+
+export interface SignalsToPointXYOptions {
+  frequency: number;
+  maxClusterSize?: number;
+}
+
+export function signalsToPointXY(
+  signals: NMRSignal1D[],
+  options: SignalsToPointXYOptions,
+) {
+  const { frequency, maxClusterSize = 1 } = options;
+  const completeSignalSet = addDummySignals(signals);
+
+  const spinSystem = signalsToSpinSystem(completeSignalSet);
+  spinSystem.clusters = splitSpinSystem(spinSystem, {
+    frequency,
+    maxClusterSize,
+  });
+  const pointsXY = simulateXYPeaks(spinSystem, options).filter(
+    (point) => point.x < 1000,
+  );
+
+  const maxIntensity = pointsXY.reduce(
+    (max, peak) => (peak.y > max ? peak.y : max),
+    Number.MIN_SAFE_INTEGER,
+  );
+
+  for (const point of pointsXY) {
+    point.y /= maxIntensity;
+  }
+  return pointsXY;
+}

package/src/signals/optimizeSignals.ts

@@ -0,0 +1,173 @@
+import { v4 } from '@lukeed/uuid';
+import { DataXY } from 'cheminfo-types';
+import { levenbergMarquardt } from 'ml-levenberg-marquardt';
+import { getShape1D, Shape1D } from 'ml-peak-shape-generator';
+import { xMinMaxValues } from 'ml-spectra-processing';
+
+import { NMRPeak1D } from '../peaks/NMRPeak1D';
+
+import { NMRSignal1D } from './NMRSignal1D';
+import { directOptimization } from './optimization/directOptimization';
+import {
+  getInternalSignals,
+  ParametersFromOptions,
+  Shape1DWithFWHM,
+} from './optimization/getInternalSignals';
+import { getSumOfShapes } from './optimization/getSumOfShapes';
+import {
+  signalsToPointXY,
+  SignalsToPointXYOptions,
+} from './optimization/signalsToPointXY';
+
+const defaultLMOptimizationOptions = {
+  damping: 1.5,
+  maxIterations: 100,
+  errorTolerance: 1e-8,
+};
+
+const defaultDirectOptimizationOptions = {
+  iterations: 25,
+};
+
+type ParametersFromSignal = Record<string, Record<string, number>>;
+
+export interface Signal extends NMRSignal1D {
+  intensity?: number;
+  shape?: Shape1D;
+  parameters?: ParametersFromSignal;
+}
+
+export interface NMRPeak1DFull extends NMRPeak1D {
+  id: string;
+  shape: Shape1DWithFWHM;
+  width: number;
+}
+
+export interface OptimizeSignalsOptions {
+  /**
+   * Initial line width in Hz
+   * @default 1
+   */
+  lineWidth?: number;
+  baseline?: number;
+  shape?: Shape1D;
+  parameters?: ParametersFromOptions;
+  optimization?: any;
+  simulation: SignalsToPointXYOptions;
+}
+
+export function optimizeSignals(
+  data: DataXY,
+  signals: Signal[],
+  options: OptimizeSignalsOptions,
+) {
+  const {
+    optimization = {},
+    simulation: simulationOptions,
+    ...restOptions
+  } = options;
+  let temp = xMinMaxValues(data.y);
+  const minMaxY = { ...temp, range: temp.max - temp.min };
+
+  const internalSignals = getInternalSignals(data, signals, minMaxY, {
+    frequency: simulationOptions.frequency,
+    ...restOptions,
+  });
+  const { baseline: shiftValue = minMaxY.min } = options;
+  let normalizedY = new Float64Array(data.y.length);
+  for (let i = 0; i < data.y.length; i++) {
+    normalizedY[i] = (data.y[i] - shiftValue) / minMaxY.range;
+  }
+
+  const nbParams =
+    internalSignals[internalSignals.length - 1].toIndexCoupling + 1;
+  const minValues = new Float64Array(nbParams);
+  const maxValues = new Float64Array(nbParams);
+  const initialValues = new Float64Array(nbParams);
+  const gradientDifferences = new Float64Array(nbParams);
+  let index = 0;
+  for (const internalSignal of internalSignals) {
+    for (let i = 0; i < internalSignal.parameters.length; i++) {
+      minValues[index] = internalSignal.propertiesValues.min[i];
+      maxValues[index] = internalSignal.propertiesValues.max[i];
+      initialValues[index] = internalSignal.propertiesValues.init[i];
+      gradientDifferences[index++] =
+        internalSignal.propertiesValues.gradientDifference[i];
+    }
+    for (
+      let i = internalSignal.parameters.length;
+      i < internalSignal.parameters.length + internalSignal.signal.js.length;
+      i++
+    ) {
+      minValues[index] = internalSignal.propertiesValues.min[i];
+      maxValues[index] = internalSignal.propertiesValues.max[i];
+      initialValues[index] = internalSignal.propertiesValues.init[i];
+      gradientDifferences[index++] =
+        internalSignal.propertiesValues.gradientDifference[i];
+    }
+  }
+  const sumOfShapes = getSumOfShapes(internalSignals, simulationOptions);
+
+  const { kind, options: optimizationOptions } = optimization;
+
+  const [algorithm, defaultOptimizationOptions] =
+    kind === 'direct'
+      ? [directOptimization, defaultDirectOptimizationOptions]
+      : [levenbergMarquardt, defaultLMOptimizationOptions];
+
+  let fitted = algorithm({ x: data.x, y: normalizedY }, sumOfShapes, {
+    minValues,
+    maxValues,
+    initialValues,
+    gradientDifference: gradientDifferences,
+    ...defaultOptimizationOptions,
+    ...optimizationOptions,
+  });
+
+  const fittedValues = fitted.parameterValues;
+  const newSignals = [];
+
+  for (const internalSignal of internalSignals) {
+    const { fromIndexCoupling } = internalSignal;
+    const js = internalSignal.signal.js.map((jCoupling, i) => {
+      jCoupling.coupling = fittedValues[fromIndexCoupling + i];
+      return jCoupling;
+    });
+
+    const delta = fittedValues[internalSignal.fromIndex];
+    const pointXYs = signalsToPointXY([{ delta, js }], simulationOptions);
+
+    const intensity =
+      fittedValues[internalSignal.fromIndex + 1] * minMaxY.range + shiftValue;
+
+    const newPeaks: NMRPeak1DFull[] = [];
+    for (const { x, y } of pointXYs) {
+      const peak = {
+        id: v4(),
+        x,
+        y: intensity * y,
+        width: 0,
+        shape: { ...internalSignal.shape },
+      };
+      for (let i = 2; i < internalSignal.parameters.length; i++) {
+        //@ts-expect-error should be fixed once
+        peak.shape[internalSignal.parameters[i]] =
+          fittedValues[internalSignal.fromIndex + i];
+      }
+
+      peak.shape.fwhm *= simulationOptions.frequency;
+      peak.width = getShape1D(peak.shape).fwhmToWidth(peak.shape.fwhm);
+      newPeaks.push(peak);
+    }
+
+    newSignals.push({
+      delta,
+      js,
+      shape: { ...newPeaks[0].shape },
+      intensity,
+      peaks: newPeaks,
+    });
+  }
+
+  return newSignals;
+}

package/src/signals/signalsJoin.ts

@@ -6,8 +6,8 @@ import { signalJoinCouplings } from '../signal/signalJoinCouplings';
 import type { SignalJoinCouplingsOptions } from '../signal/signalJoinCouplings';
 import type { MakeMandatory } from '../utilities/MakeMandatory';
 
+import type { Jcoupling } from './Jcoupling';
 import type { NMRSignal1D } from './NMRSignal1D';
-import type { Jcoupling } from './jcoupling';
 
 export interface SignalsJoinOptions {
   /**

package/src/signals/signalsToXY.ts

@@ -4,8 +4,8 @@ import { xSequentialFill } from 'ml-spectra-processing';
 
 import type { MakeMandatory } from '../utilities/MakeMandatory';
 
+import type { Jcoupling } from './Jcoupling';
 import type { NMRSignal1D } from './NMRSignal1D';
-import type { Jcoupling } from './jcoupling';
 import { signalsToSpinSystem } from './simulation/signalsToSpinSystem';
 import simulate1D from './simulation/simulate1D';
 import { splitSpinSystem } from './simulation/splitSpinSystem';

package/src/signals/simulation/signalsToSpinSystem.ts

@@ -2,8 +2,8 @@ import { Matrix } from 'ml-matrix';
 import simpleClustering from 'ml-simple-clustering';
 
 import type { MakeMandatory } from '../../utilities/MakeMandatory';
+import type { Jcoupling } from '../Jcoupling';
 import type { NMRSignal1D } from '../NMRSignal1D';
-import type { Jcoupling } from '../jcoupling';
 import type { SpinSystem } from '../spinSystem';
 
 interface Ids {

package/src/signals/simulation/simulateXYPeaks.ts

@@ -207,7 +207,6 @@ export function simulateXYPeaks(
     }
 
     const numFreq = frequencies.length;
-
     if (numFreq > 0) {
       weight /= sumI;
       const diff = lineWidth / 64;
@@ -237,7 +236,7 @@ export function simulateXYPeaks(
     }
   }
 
-  return xyPeaks;
+  return xyPeaks.filter((peak) => peak.x < 1000);
 }
 
 function triuTimesAbs(A: SparseMatrix, val: number) {

package/src/xy/xyAutoPeaksPicking.ts

@@ -8,7 +8,9 @@ import {
   OptimizePeaksOptions,
   JoinBroadPeaksOptions,
   GSDPeakOptimizedID,
+  setShape,
 } from 'ml-gsd';
+import { Shape1D } from 'ml-peak-shape-generator';
 import {
   xyExtract,
   xNoiseSanPlot,
@@ -77,12 +79,13 @@ export interface OptionsXYAutoPeaksPicking extends Partial<GetPeakListOptions> {
   frequency: number;
 }
 
-export type NMRPeak1DWithID = MakeMandatory<NMRPeak1D, 'id'>;
+type GSDPeakShapeID = GSDPeakID & { shape: Shape1D };
+export type NMRPeak1DWithShapeID = MakeMandatory<NMRPeak1D, 'id' | 'shape'>;
 
 export function xyAutoPeaksPicking(
   data: DataXY,
   options: OptionsXYAutoPeaksPicking,
-): NMRPeak1DWithID[] {
+): NMRPeak1DWithShapeID[] {
   const {
     from,
     to,
@@ -177,8 +180,7 @@ function getPeakList(data: DataXY, options: GetPeakListOptions) {
     realTopDetection,
   } = options;
 
-  let peakList = gsd(data, {
-    shape,
+  const peaks = gsd(data, {
     sgOptions,
     maxCriteria,
     minMaxRatio,
@@ -187,6 +189,8 @@ function getPeakList(data: DataXY, options: GetPeakListOptions) {
     realTopDetection,
   });
 
+  const peakList = setShape(peaks, { output: peaks, shape });
+
   const newPeaks = broadWidth
     ? joinBroadPeaks(peakList, {
         broadRatio,
@@ -226,8 +230,8 @@ function getCutOff(data: number[] | Float64Array, options: OptionsGetCutOff) {
 }
 
 function toNMRPeak1DStructure(
-  peak: GSDPeakID | GSDPeakOptimizedID,
-): NMRPeak1DWithID {
+  peak: GSDPeakShapeID | GSDPeakOptimizedID,
+): NMRPeak1DWithShapeID {
   const { id, shape, x, y, width } = peak;
   return {
     id,

package/src/xy/xyPeaksOptimization.ts

@@ -10,6 +10,7 @@ export interface XYPeaksOptimizationOptions extends OptimizePeaksOptions {
    */
   frequency: number;
 }
+
 export function xyPeaksOptimization<T extends PeakXYWidth>(
   data: DataXY,
   peaks: T[],
@@ -18,8 +19,9 @@ export function xyPeaksOptimization<T extends PeakXYWidth>(
   const { frequency } = options;
   const newPeaks = convertWidthToPPM(peaks, { frequency });
   const optimizedPeaks = optimizePeaks(data, newPeaks, options);
-  return convertWidthToHz(optimizedPeaks, {
+  const result = convertWidthToHz(optimizedPeaks, {
     frequency,
     output: optimizedPeaks,
   });
+  return result;
 }

package/lib/prediction/prediction1D.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prediction1D.js","sourceRoot":"","sources":["../../src/prediction/prediction1D.ts"],"names":[],"mappings":""}

package/lib/signals/jcoupling.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jcoupling.js","sourceRoot":"","sources":["../../src/signals/jcoupling.ts"],"names":[],"mappings":""}

package/lib-esm/prediction/prediction1D.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=prediction1D.js.map

package/lib-esm/prediction/prediction1D.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prediction1D.js","sourceRoot":"","sources":["../../src/prediction/prediction1D.ts"],"names":[],"mappings":""}

package/lib-esm/signals/jcoupling.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=jcoupling.js.map

package/lib-esm/signals/jcoupling.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"jcoupling.js","sourceRoot":"","sources":["../../src/signals/jcoupling.ts"],"names":[],"mappings":""}