nmr-processing 7.4.3 → 8.2.0

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

@@ -0,0 +1,121 @@
+import { NMRRangeWithIds, NMRSignal1DWithId } from '../assignment/nmrAssigment';
+import generateID from '../assignment/utils/generateID';
+import { addIDs } from '../assignment/utils/getAssignment/checkIDs';
+import { NMRPeak1D } from '../peaks/NMRPeak1D';
+import { detectSignals } from '../peaks/peaksToRanges';
+import { solventSuppression } from '../peaks/solventSuppression';
+import { SignalIntern } from '../peaks/util/jAnalyzer';
+import { NMRSignal1D } from '../signals/NMRSignal1D';
+import { NMRRange } from '../xy/NMRRange';
+
+interface NMRPeak1DWithSignalID extends NMRPeak1D {
+  signalID: string;
+  rangeID: string;
+}
+
+export function markSolventPeaks<T extends NMRRange>(
+  input: T[],
+  solventSignals: NMRSignal1D[],
+  options: any = {},
+) {
+  const { frequency = 400 } = options;
+  const ranges = addIDs([...input]) as NMRRangeWithIds[];
+
+  let peakList: NMRPeak1DWithSignalID[] = [];
+  for (const range of ranges) {
+    const rangeID = range.id;
+    for (const signal of range.signals || []) {
+      const signalID = signal.id;
+      for (let peak of signal.peaks || []) {
+        peakList.push({
+          ...peak,
+          rangeID,
+          signalID,
+        });
+      }
+    }
+  }
+
+  const peaks = solventSuppression(peakList, solventSignals, {
+    markSolventPeaks: true,
+  });
+
+  const signalsWithSolvent = getSignalIDsWithSolvent(peaks);
+  for (let range of ranges) {
+    if (!range.signals) continue;
+    for (let signal of range.signals) {
+      if (!signalsWithSolvent.includes(signal.id)) continue;
+      const signalPeaks = [];
+      const solventSignalPeaks = [];
+      for (let peak of peaks) {
+        if (peak.signalID === signal.id) {
+          const { signalID, rangeID, ...newPeak } = peak;
+          if (peak.kind === 'solvent') {
+            solventSignalPeaks.push(newPeak);
+          } else {
+            signalPeaks.push(newPeak);
+          }
+        }
+      }
+      const newSignals =
+        signalPeaks.length > 0
+          ? detectSignals({ x: [], y: [] }, signalPeaks, {
+              integralType: 'peak',
+              frequency,
+            })
+          : [];
+      solventSignalPeaks.sort((a, b) => a.x - b.x);
+      const lowPPMValue = solventSignalPeaks[0].x;
+      const highPPMValue = solventSignalPeaks[solventSignalPeaks.length - 1].x;
+      const newSolventSignals = detectSignals(
+        { x: [], y: [] },
+        solventSignalPeaks,
+        {
+          integralType: 'peak',
+          frequencyCluster: (highPPMValue - lowPPMValue) * frequency,
+          frequency,
+        },
+      );
+
+      range.signals = [
+        ...adaptSignals(newSignals),
+        ...adaptSignals(newSolventSignals),
+        ...range.signals.filter((currSignal) => currSignal.id !== signal.id),
+      ];
+    }
+  }
+  return ranges as T[];
+}
+
+function getSignalIDsWithSolvent(solventPeaks: NMRPeak1DWithSignalID[]) {
+  const uniqueSignalID = new Set();
+  for (let peak of solventPeaks) {
+    if (peak.kind !== 'solvent') continue;
+    uniqueSignalID.add(peak.signalID);
+  }
+  return Array.from(uniqueSignalID);
+}
+
+function adaptSignals(signals: SignalIntern[]) {
+  const newSignals = [];
+  for (let signal of signals) {
+    const signalResult: NMRSignal1DWithId = {
+      id: generateID(),
+      delta: signal.delta,
+      kind: signal.kind || 'signal',
+      multiplicity: signal.multiplicity,
+      integration: signal.integralData.value,
+    };
+    signalResult.peaks = signal.peaks.map((peak) => {
+      const newResult: any = {
+        y: peak.intensity,
+        ...peak,
+      };
+      delete newResult.intensity;
+      return newResult as NMRPeak1D;
+    });
+    signalResult.js = signal.nmrJs || [];
+    newSignals.push(signalResult);
+  }
+  return newSignals;
+}

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,
-      },
-    ],
-  };
-}