nmr-processing 7.4.2 → 8.1.0

package/src/peaks/solventSuppression.ts

@@ -0,0 +1,186 @@
+import { PointXY } from 'cheminfo-types';
+import linearSumAssignment from 'linear-sum-assignment';
+import { Matrix } from 'ml-matrix';
+import { gaussianFct } from 'ml-peak-shape-generator';
+import { xFindClosestIndex, xMaxValue } from 'ml-spectra-processing';
+
+import { NMRSignal1D } from '../signals/NMRSignal1D';
+import { addDummySignals } from '../signals/addDummySignals';
+import { signalsToSpinSystem } from '../signals/simulation/signalsToSpinSystem';
+import { simulateXYPeaks } from '../signals/simulation/simulateXYPeaks';
+import { splitSpinSystem } from '../signals/simulation/splitSpinSystem';
+
+import { NMRPeak1D } from './NMRPeak1D';
+
+export function solventSuppression(
+  peakList: NMRPeak1D[],
+  solvent: NMRSignal1D[],
+  options: any = {},
+) {
+  const peaks = [...peakList];
+  sortAscending(peaks);
+  const xValues = peaks.map((peak) => peak.x);
+
+  const { markSolventPeaks = false } = options;
+
+  let solventSignals = solvent; //addDummySignals(solvent);
+  // solventSignals = solventSignals.slice(0, solventSignals.findIndex((signal) => signal.delta > 400));
+
+  for (const solventSignal of solventSignals) {
+    const solventXYPeaks = solventSignal.peaks
+      ? solventSignal.peaks
+      : getSolventPeaks(solventSignal);
+    sortAscending(solventXYPeaks);
+    let upIndex = xFindClosestIndex(
+      xValues,
+      solventXYPeaks[solventXYPeaks.length - 1].x + 1,
+    );
+    let lowIndex = xFindClosestIndex(xValues, solventXYPeaks[0].x - 1);
+    if (upIndex === lowIndex) continue;
+    const nearPeaks = peaks.slice(lowIndex, upIndex + 1);
+    const amplitudeResiduals = [];
+    const deltaResiduals = [];
+    const positionResiduals = [];
+    for (let peak of nearPeaks) {
+      const shiftedSolventPeaks = getShiftedSolventPeaks(
+        peak,
+        solventSignal,
+        solventXYPeaks,
+      );
+      const closestPeaks = getClosestPeaks(shiftedSolventPeaks, nearPeaks);
+      let deltaResidual = 0;
+      let amplitudeResidual = 0;
+      let positionResidual = 0;
+      for (let i = 0; i < closestPeaks.length; i++) {
+        amplitudeResidual += Math.abs(
+          shiftedSolventPeaks[i].y - closestPeaks[i].y,
+        );
+        deltaResidual += Math.abs(shiftedSolventPeaks[i].x - closestPeaks[i].x);
+      }
+
+      if (closestPeaks.length === 0) {
+        deltaResidual = Number.MAX_SAFE_INTEGER;
+        amplitudeResidual = Number.MAX_SAFE_INTEGER;
+        positionResidual = Number.MAX_SAFE_INTEGER;
+      } else {
+        positionResidual = gaussianFct(solventSignal.delta - peak.x, 0.5);
+      }
+      amplitudeResiduals.push(amplitudeResidual);
+      deltaResiduals.push(deltaResidual);
+      positionResiduals.push(positionResidual);
+    }
+
+    const maxAmplitude = xMaxValue(amplitudeResiduals);
+    const maxDelta = xMaxValue(deltaResiduals);
+    const maxPosition = xMaxValue(positionResiduals);
+
+    let minIndex = -1;
+    let minScore = Number.MAX_SAFE_INTEGER;
+    for (let i = 0; i < deltaResiduals.length; i++) {
+      const value =
+        (amplitudeResiduals[i] / maxAmplitude +
+          deltaResiduals[i] / maxDelta +
+          (1 - positionResiduals[i]) / maxPosition) /
+        3;
+      if (minScore > value) {
+        minIndex = i;
+        minScore = value;
+      }
+    }
+    const shiftedSolventPeaks = getShiftedSolventPeaks(
+      nearPeaks[minIndex],
+      solventSignal,
+      solventXYPeaks,
+    );
+    const diff = getDiffMatrix(shiftedSolventPeaks, nearPeaks);
+    const { rowAssignments, gain } = linearSumAssignment(diff, {
+      maximaze: false,
+    });
+    if (gain === -1) return peaks;
+
+    if (markSolventPeaks) {
+      for (let index of rowAssignments) {
+        peaks[index + lowIndex].kind = 'solvent';
+      }
+    } else {
+      rowAssignments.sort((a, b) => b - a);
+      for (let index of rowAssignments) {
+        peaks.splice(index + lowIndex, 1);
+      }
+    }
+  }
+
+  return peaks;
+}
+
+function getSolventPeaks(
+  signal: NMRSignal1D,
+  options: { frequency?: number; maxClusterSize?: number } = {},
+) {
+  let signals = addDummySignals([signal]);
+  let spinSystem = signalsToSpinSystem(signals);
+
+  const { frequency = 400, maxClusterSize = 8 } = options;
+
+  spinSystem.clusters = splitSpinSystem(spinSystem, {
+    frequency,
+    maxClusterSize,
+  });
+
+  const peaks = simulateXYPeaks(spinSystem);
+  return peaks.filter((peak) => peak.x < 1000);
+}
+
+function getShiftedSolventPeaks(
+  peak: PointXY,
+  solventSignal: any,
+  solventXYPeaks: PointXY[],
+) {
+  const shiftedSolventPeaks: PointXY[] = JSON.parse(
+    JSON.stringify(solventXYPeaks),
+  );
+  // shift x values of solventPeaks to center it to the current peak.
+  const deltaPPM = peak.x - solventSignal.delta;
+  const maxIntensity = shiftedSolventPeaks.reduce(
+    (max, current) => (current.y > max ? current.y : max),
+    shiftedSolventPeaks[0].y,
+  );
+  for (let shiftedSolventPeak of shiftedSolventPeaks) {
+    shiftedSolventPeak.x += deltaPPM;
+    shiftedSolventPeak.y /= maxIntensity;
+  }
+  return shiftedSolventPeaks;
+}
+
+function getClosestPeaks(shiftedSolventPeaks: PointXY[], nearPeaks: PointXY[]) {
+  const diff = getDiffMatrix(shiftedSolventPeaks, nearPeaks);
+  const { rowAssignments, gain } = linearSumAssignment(diff, {
+    maximaze: false,
+  });
+  if (gain === -1) return [];
+
+  const assignmentPeaks = [];
+  let maxValue = Number.MIN_SAFE_INTEGER;
+  for (let index of rowAssignments) {
+    if (maxValue < nearPeaks[index].y) maxValue = nearPeaks[index].y;
+    assignmentPeaks.push({ ...nearPeaks[index] });
+  }
+  assignmentPeaks.forEach((peak, i, arr) => (arr[i].y /= maxValue));
+  return assignmentPeaks;
+}
+
+function sortAscending(peaks: PointXY[]) {
+  return peaks[0].x > peaks[1].x ? peaks.sort((a, b) => a.x - b.x) : peaks;
+}
+
+function getDiffMatrix(rows: PointXY[], columns: PointXY[]) {
+  const nbColumns = columns.length;
+  const nbRows = rows.length;
+  const diff = new Matrix(nbRows, nbColumns);
+  for (let r = 0; r < nbRows; r++) {
+    for (let c = 0; c < nbColumns; c++) {
+      diff.set(r, c, Math.abs(rows[r].x - columns[c].x));
+    }
+  }
+  return diff;
+}

package/src/peaks/util/jAnalyzer.ts

@@ -29,7 +29,7 @@ interface IntergralData {
   to: number;
 }
 
-export type Peak1DIntern = Omit<NMRPeak1D, 'y' | 'shape' | 'fwhm'> & {
+export type Peak1DIntern = Omit<NMRPeak1D, 'y' | 'shape'> & {
   intensity: number;
 };
 

package/src/prediction/predictAllSpectra.ts

@@ -1,6 +1,9 @@
+import { FromTo, PointXY } from 'cheminfo-types';
 import type { Molecule } from 'openchemlib';
 
+import { signals2DToZ } from '../signals/signals2DToZ';
 import { OptionsSignalsToXY, signalsToXY } from '../signals/signalsToXY';
+import { getFrequency } from '../utilities/getFrequency';
 
 import { PredictAllOptions, predictAll } from './predictAll';
 /**
@@ -10,39 +13,173 @@ import { PredictAllOptions, predictAll } from './predictAll';
  * @param options
  */
 
+interface OneDOptions {
+  proton: FromTo;
+  carbon: FromTo;
+  nbPoints: number;
+  lineWidth: number;
+}
+
+interface TwoDOptions {
+  from: PointXY;
+  to: PointXY;
+  nbPoints: PointXY;
+}
+interface SimulationOptions {
+  frequency: number;
+  oneD?: Partial<OneDOptions>;
+  twoD?: Partial<TwoDOptions>;
+}
+interface PredictAllSpectraOptions {
+  prediction?: PredictAllOptions;
+  simulation?: SimulationOptions;
+}
+
 export async function predictAllSpectra(
   molecule: Molecule,
-  options: {
-    prediction?: PredictAllOptions;
-    simulation?: OptionsSignalsToXY;
-  } = {},
+  options: PredictAllSpectraOptions = {},
 ) {
-  const predictions = await predictAll(molecule, options.prediction);
+  const {
+    simulation: simulationOptions = { oneD: {}, twoD: {} } as SimulationOptions,
+    prediction: predictionOptions = {},
+  } = options;
+
+  const predictions = await predictAll(molecule, predictionOptions);
   const spectra: any[] = [];
   const result = { spectra, molecules: [{ molfile: predictions.molfile }] };
-  spectra.push(getProton(predictions.proton, options.simulation));
+
+  const oneDOptions: OneDOptions = {
+    ...{
+      proton: { from: 0, to: 14 },
+      carbon: { from: 0, to: 200 },
+      nbPoints: 4098,
+      lineWidth: 0.03,
+    },
+    ...(simulationOptions.oneD || {}),
+  };
+
+  const twoDOptions: TwoDOptions = {
+    ...{
+      from: { x: oneDOptions.proton.from, y: oneDOptions.carbon.from },
+      to: { x: oneDOptions.proton.to, y: oneDOptions.carbon.to },
+      nbPoints: { x: 1024, y: 1024 },
+    },
+    ...(simulationOptions.twoD || {}),
+  };
+
+  for (const experiment in predictions) {
+    switch (experiment) {
+      case 'carbon':
+      case 'proton': {
+        spectra.push(
+          get1DSpectrum(predictions[experiment], {
+            nbPoints: oneDOptions.nbPoints,
+            lineWidth: oneDOptions.lineWidth,
+            ...oneDOptions[experiment],
+            experiment,
+            frequency: simulationOptions.frequency,
+          }),
+        );
+        break;
+      }
+      case 'cosy':
+      case 'hsqc':
+      case 'hmbc': {
+        spectra.push(
+          get2DSpectrum(predictions[experiment], {
+            ...twoDOptions,
+            experiment,
+            frequency: simulationOptions.frequency,
+          }),
+        );
+        break;
+      }
+      default:
+        break;
+    }
+  }
 
   return result;
 }
 
-function getProton(prediction: any, options?: OptionsSignalsToXY) {
-  const { x, y } = signalsToXY(prediction.signals, options);
+type Get2DSpectrumOptions = TwoDOptions & {
+  experiment: string;
+  frequency: number;
+};
+
+function get2DSpectrum(prediction: any, options: Get2DSpectrumOptions) {
+  const { signals, zones, nuclei } = prediction;
+  const { frequency: baseFrequency, experiment } = options;
+
+  const width = get2DWidth(nuclei);
+  const frequency = calculateFrequency(nuclei, baseFrequency);
+
+  const spectrumData = signals2DToZ(signals, {
+    ...options,
+    width,
+    factor: 3,
+  });
+
+  const spectrum = {
+    data: { ...spectrumData, noise: 0.01 },
+    info: {
+      nucleus: nuclei,
+      originFrequency: frequency,
+      baseFrequency: frequency,
+      pulseSequence: experiment,
+      experiment: '2d',
+    },
+    zones: { values: zones },
+  };
+  return spectrum;
+}
+
+function get2DWidth(nucleus: string[]) {
+  return nucleus[0] === nucleus[1] ? 0.02 : { x: 0.02, y: 0.2133 };
+}
+
+type Get1DSpectrumOptions = OptionsSignalsToXY & { experiment: string };
+
+function get1DSpectrum(prediction: any, options: Get1DSpectrumOptions) {
+  const { frequency = 400, experiment } = options;
+  const { signals, nucleus } = prediction;
+  const realFrequency = calculateFrequency(nucleus, frequency) as number;
+  const { x, y } = signalsToXY(signals, {
+    ...options,
+    frequency: realFrequency,
+  });
   const spectrum = {
-    id: '',
     // todo Array.from is temporary for the developement
     data: { x: Array.from(x), re: Array.from(y), im: null },
     info: {
       nucleus: prediction.nucleus,
       dimension: 1,
-      originFrequency: 400,
-      baseFrequency: 400,
+      originFrequency: realFrequency,
+      baseFrequency: realFrequency,
       pulseSequence: 'prediction',
-      experiment: 'proton',
+      experiment,
       isFt: true,
     },
-    // todo: currently we disable the ranges because there is no ID
-    //ranges: { values: prediction.ranges },
+    ranges: { values: prediction.ranges },
   };
 
   return spectrum;
 }
+
+function calculateFrequency(
+  nucleus: string | string[],
+  frequency: number,
+): number | string {
+  if (typeof nucleus === 'string') {
+    return getFrequency(nucleus, { nucleus: '1H', frequency });
+  } else {
+    if (nucleus[0] === nucleus[1]) {
+      return `${frequency},${frequency}`;
+    } else {
+      return `${frequency},${getFrequency(nucleus[1], {
+        nucleus: nucleus[0],
+        frequency,
+      })}`;
+    }
+  }
+}

package/src/ranges/rangesToXY.ts

@@ -49,13 +49,21 @@ function checkForSignals(
     if (!range.signals) throw new Error('range has not signals');
   }
 }
+
+const defaultFromTo = (nucleus = '') => {
+  switch (nucleus.toUpperCase()) {
+    case '13C':
+      return { from: -5, to: 206 };
+    default:
+      return { from: -0.5, to: 10.5 };
+  }
+};
+
 export function rangesToXY(ranges: NMRRange[], options: any = {}) {
   checkForSignals(ranges);
   let {
     frequency = 400,
     lineWidth = 1,
-    from = 0,
-    to = 10,
     nbPoints = 16 * 1024,
     shape = { kind: 'gaussian' },
   } = options;
@@ -66,9 +74,10 @@ export function rangesToXY(ranges: NMRRange[], options: any = {}) {
     }
   };
 
+  const { from, to } = getFromTo(ranges, options);
   const spectrumOptions = {
-    from,
     to,
+    from,
     nbPoints,
     shape,
     lineWidth,
@@ -139,7 +148,7 @@ function peaksOfMultiplet(delta: number, options: any) {
   const {
     frequency,
     lineWidth,
-    intensities = [1, 2, 5, 4, 5, 3, 4, 2, 1],
+    intensities = [1, 2, 5, 4, 5, 7, 5, 4, 5, 2, 1],
   } = options;
 
   const lineWidthPpm = lineWidth / frequency;
@@ -182,3 +191,23 @@ function normalizeSpectrum(
     }
   }
 }
+
+function getFromTo(ranges: NMRRange[], options: any) {
+  const { from: defaultFrom, to: defaultTo } = defaultFromTo(options.nucleus);
+
+  let rangesFrom = Number.MAX_SAFE_INTEGER;
+  let rangesTo = Number.MIN_SAFE_INTEGER;
+  for (const range of ranges) {
+    for (const signal of range.signals || []) {
+      if (rangesFrom > signal.delta) rangesFrom = signal.delta;
+      if (rangesTo < signal.delta) rangesTo = signal.delta;
+    }
+  }
+
+  const {
+    from = Math.min(rangesFrom - 0.5, defaultFrom),
+    to = Math.max(rangesTo + 0.5, defaultTo),
+  } = options;
+
+  return { from, to };
+}

package/src/signals/addDummySignals.ts

@@ -0,0 +1,77 @@
+import { couplingPatterns } from '../constants/couplingPatterns';
+
+import { NMRSignal1D } from './NMRSignal1D';
+import type { Jcoupling } from './jcoupling';
+
+export function addDummySignals(signals: NMRSignal1D[]) {
+  let newSignals: NMRSignal1D[] = JSON.parse(JSON.stringify(signals));
+
+  signals.forEach((signal, s) => {
+    const { js: jCouplings = [], atoms: signalAssignment = [s] } = signal;
+
+    let { newCouplings, tempSignals } = checkCouplings(
+      jCouplings,
+      newSignals,
+      signalAssignment,
+    );
+
+    if (tempSignals.length > 0) newSignals.push(...tempSignals);
+
+    newSignals[s].js = newCouplings;
+    newSignals[s].atoms = signalAssignment;
+  });
+
+  return newSignals.sort((a, b) => a.delta - b.delta);
+}
+
+function checkCouplings(
+  jCouplings: Jcoupling[],
+  signals: NMRSignal1D[],
+  signalAssignment: number[],
+) {
+  let newSignalAssignment = signals.length - 1;
+  let tempSignals: NMRSignal1D[] = [];
+  const newCouplings = jCouplings.reduce<Jcoupling[]>(
+    (newCouplings, jCoupling) => {
+      const { atoms = [], multiplicity, coupling } = jCoupling;
+      if (atoms.length === 0) {
+        if (coupling && multiplicity) {
+          let tempCouplings: Jcoupling[] = [];
+          const nbLinks = couplingPatterns.indexOf(multiplicity);
+          for (let i = 0; i < nbLinks; i++) {
+            newSignalAssignment++;
+            tempCouplings.push({
+              coupling,
+              atoms: [newSignalAssignment],
+            });
+            tempSignals.push(
+              formatSignal(coupling, [newSignalAssignment], signalAssignment),
+            );
+          }
+        } else {
+          newCouplings.push(jCoupling);
+        }
+      }
+      return newCouplings;
+    },
+    [],
+  );
+  return { newCouplings, tempSignals };
+}
+
+function formatSignal(
+  coupling: number,
+  newSignalAssignment: number[],
+  signalAssignment: number[],
+) {
+  return {
+    delta: 100000,
+    atoms: newSignalAssignment,
+    js: [
+      {
+        coupling,
+        atoms: signalAssignment,
+      },
+    ],
+  };
+}

package/src/signals/hackSignalsToXY.ts

@@ -1,7 +1,5 @@
-import { couplingPatterns } from '../constants/couplingPatterns';
-
 import type { NMRSignal1D } from './NMRSignal1D';
-import type { Jcoupling } from './jcoupling';
+import { addDummySignals } from './addDummySignals';
 import { OptionsSignalsToXY, signalsToXY } from './signalsToXY';
 
 /**
@@ -13,74 +11,6 @@ export function hackSignalsToXY(
   signals: NMRSignal1D[],
   options: OptionsSignalsToXY = {},
 ) {
-  let newSignals = JSON.parse(JSON.stringify(signals));
-
-  signals.forEach((signal, s) => {
-    const { js: jCouplings = [], atoms: signalAssignment = [s] } = signal;
-
-    let { newCouplings, tempSignals } = checkCouplings(
-      jCouplings,
-      newSignals,
-      signalAssignment,
-    );
-
-    if (tempSignals.length > 0) newSignals.push(...tempSignals);
-
-    newSignals[s].js = newCouplings;
-    newSignals[s].atoms = signalAssignment;
-  });
-
+  let newSignals = addDummySignals(signals);
   return signalsToXY(newSignals, options);
 }
-
-function checkCouplings(
-  jCouplings: Jcoupling[],
-  signals: NMRSignal1D[],
-  signalAssignment: number[],
-) {
-  let newSignalAssignment = signals.length - 1;
-  let tempSignals: NMRSignal1D[] = [];
-  const newCouplings = jCouplings.reduce<Jcoupling[]>(
-    (newCouplings, jCoupling) => {
-      const { atoms = [], multiplicity, coupling } = jCoupling;
-      if (atoms.length === 0) {
-        if (coupling && multiplicity) {
-          let tempCouplings: Jcoupling[] = [];
-          const nbLinks = couplingPatterns.indexOf(multiplicity);
-          for (let i = 0; i < nbLinks; i++) {
-            newSignalAssignment++;
-            tempCouplings.push({
-              coupling,
-              atoms: [newSignalAssignment],
-            });
-            tempSignals.push(
-              formatSignal(coupling, [newSignalAssignment], signalAssignment),
-            );
-          }
-        } else {
-          newCouplings.push(jCoupling);
-        }
-      }
-      return newCouplings;
-    },
-    [],
-  );
-  return { newCouplings, tempSignals };
-}
-
-function formatSignal(
-  coupling: number,
-  newSignalAssignment: number[],
-  signalAssignment: number[],
-) {
-  return {
-    delta: 100000,
-    atoms: newSignalAssignment,
-    js: [
-      {
-        coupling,
-        atoms: signalAssignment,
-      },
-    ],
-  };
-}