nmr-processing 9.1.0 → 9.2.0-pre.1668170175

package/src/signals/optimization/directOptimization.ts

@@ -0,0 +1,49 @@
+import { DataXY } from 'cheminfo-types';
+import direct from 'ml-direct';
+
+import { SumOfShapes } from './getSumOfShapes';
+
+interface DirectOptions {
+  iterations?: number;
+  epsilon?: number;
+  tolerance?: number;
+  tolerance2?: number;
+  initialState?: any;
+}
+
+interface DirectOptimizationOptions extends DirectOptions {
+  directOptions?: DirectOptions;
+  minValues: number[];
+  maxValues: number[];
+}
+
+export function directOptimization(
+  data: DataXY,
+  sumOfShapes: SumOfShapes,
+  options: DirectOptimizationOptions,
+) {
+  const { minValues, maxValues, directOptions = {} } = options;
+  const objectiveFunction = getObjectiveFunction(data, sumOfShapes);
+  const result = direct(objectiveFunction, minValues, maxValues, directOptions);
+
+  const { optima } = result;
+
+  return {
+    error: result.minFunctionValue,
+    iterations: result.iterations,
+    parameterValues: optima[0],
+  };
+}
+
+function getObjectiveFunction(data: DataXY, sumOfShapes: SumOfShapes) {
+  const { x, y } = data;
+  const nbPoints = x.length;
+  return (parameters: number[]) => {
+    const fct = sumOfShapes(parameters);
+    let error = 0;
+    for (let i = 0; i < nbPoints; i++) {
+      error += Math.pow(y[i] - fct(x[i]), 2);
+    }
+    return error;
+  };
+}

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

@@ -0,0 +1,84 @@
+import { xSequentialFill } from 'ml-spectra-processing';
+
+import { apodization } from '../apodization/apodization';
+
+import { NMRSignal1D } from './NMRSignal1D';
+import { signalsToSpinSystem } from './simulation/signalsToSpinSystem';
+import { simulateXYPeaks } from './simulation/simulateXYPeaks';
+import { splitSpinSystem } from './simulation/splitSpinSystem';
+
+export interface SignalsToFIDOptions {
+  lb?: number;
+  from?: number;
+  to?: number;
+  nbPoints?: number;
+  frequency?: number;
+  maxClusterSize?: number;
+}
+
+const twoPi = Math.PI * 2;
+
+export function signalsToFID(
+  signals: NMRSignal1D[],
+  options: SignalsToFIDOptions,
+) {
+  const {
+    lb = 1,
+    from = 0,
+    to = 10,
+    nbPoints = 1024,
+    frequency = 400,
+    maxClusterSize = 8,
+  } = options;
+
+  let spinSystem = signalsToSpinSystem(signals);
+
+  spinSystem.clusters = splitSpinSystem(spinSystem, {
+    frequency,
+    maxClusterSize,
+  });
+
+  const peaks = simulateXYPeaks(spinSystem, { frequency });
+  const re = new Float64Array(nbPoints);
+  const im = new Float64Array(nbPoints);
+
+  const sw = Math.abs(to - from);
+  const adquisitionTime = nbPoints / (2 * sw * frequency);
+  const time = xSequentialFill({
+    size: nbPoints,
+    from: 0,
+    to: adquisitionTime,
+  });
+
+  for (const peak of peaks) {
+    const { x, y } = peak;
+    const cs = x * frequency * twoPi;
+    for (let i = 0; i < nbPoints; i++) {
+      re[i] += y * Math.cos(cs * time[i]);
+      im[i] += y * Math.sin(cs * time[i]);
+    }
+  }
+
+  const { windowData, ...result } = apodization(
+    { re, im },
+    {
+      pointsToShift: 0,
+      compose: {
+        length: nbPoints,
+        shapes: [
+          {
+            start: 0,
+            shape: {
+              kind: 'exponential',
+              options: {
+                dw: adquisitionTime / (nbPoints - 1),
+                lb,
+              },
+            },
+          },
+        ],
+      },
+    },
+  );
+  return result;
+}

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';