nmr-processing 9.9.2 → 10.0.0

package/src/prediction/predictHSQC.ts

@@ -1,9 +1,8 @@
 import type { Molecule } from 'openchemlib/full';
 
-import type { Prediction1D } from './Prediction1D';
-import { predictCarbon, PredictCarbonOptions } from './predictCarbon';
-import { predictProton, PredictProtonOptions } from './predictProton';
-import { predict2D, Predictor } from './utils/predict2D';
+import { GroupDiastereotopicAtomIDs } from './GroupDiastereotopicAtomIDs';
+import { PredictionBase1D } from './PredictionBase1D';
+import { predict2D } from './utils/predict2D';
 
 export interface PredictHSQCOptions {
   /**
@@ -16,16 +15,6 @@ export interface PredictHSQCOptions {
    * @default 1
    */
   minLength?: number;
-  /**
-   * mono dimensional predictors. The object should has properties with name
-   * equal to "H" and "C".
-   */
-  predictor?: { H?: Predictor; C?: Predictor };
-  /**
-   *  mono dimensional signal to generate the bidimenionals cross peaks.
-   * The object should has properties with name equal to "H" and "C".
-   */
-  predictOptions?: { H?: PredictProtonOptions; C?: PredictCarbonOptions };
   /**
    * signals with euclidean distance in ppm less than this it will
    * joined into a zone.
@@ -37,11 +26,20 @@ export interface PredictHSQCOptions {
    * The object should has properties with name equal to "H" and "C".
    * the value of each prediction should be similar that predictProton and predictCarbon.
    */
-  predictions?: {
-    [key: string]: Prediction1D | undefined;
-    H?: Prediction1D;
-    C?: Prediction1D;
+  predictions: {
+    [key: string]: PredictionBase1D | undefined;
+    H?: PredictionBase1D;
+    C?: PredictionBase1D;
   };
+  /**
+   * diastereotopic atom ids of the molecule.
+   */
+  diaIDs: string[];
+  /**
+   * grouped diastereotopic atom ids of the molecule.
+   */
+  groupedDiaIDs: GroupDiastereotopicAtomIDs[];
+  distanceMatrix: number[][];
 }
 /**
  * Generate the correlation bidimensional nmr peaks based on the number of bonds between a pair of atoms
@@ -50,25 +48,20 @@ export interface PredictHSQCOptions {
 
 export async function predictHSQC(
   molecule: Molecule,
-  options: PredictHSQCOptions = {},
+  options: PredictHSQCOptions,
 ) {
   const {
     minLength = 1,
     maxLength = 1,
-    predictor = { H: predictProton, C: predictCarbon },
-    predictions,
     joinDistance = { H: 0.05, C: 0.5 },
-    predictOptions,
   } = options;
 
   return predict2D(molecule, {
+    ...options,
     from: 'H',
     to: 'C',
-    predictor,
     minLength,
     maxLength,
-    predictions,
-    predictOptions,
     joinDistance,
   });
 }

package/src/prediction/predictProton.ts

@@ -1,19 +1,13 @@
 import { v4 as generateID } from '@lukeed/uuid';
 import fetch from 'cross-fetch';
 import FormData from 'form-data';
-import type { Molecule } from 'openchemlib/full';
-import {
-  ensureHeterotopicChiralBonds,
-  getConnectivityMatrix,
-  getDiastereotopicAtomIDs,
-} from 'openchemlib-utils';
 
 import type { NMRSignal1D } from '../signals/NMRSignal1D';
 import { signalsJoin } from '../signals/signalsJoin';
 import { signalsToRanges } from '../signals/signalsToRanges';
 
-import type { Prediction1D } from './Prediction1D';
-import { isEmptyMolecule } from './utils/isEmptyMolecule';
+import { PredictionBase1D } from './PredictionBase1D';
+import { isMolfileNotEmpty } from './utils/isMolfileNotEmpty';
 
 /**
  * Makes a prediction using proton.
@@ -28,31 +22,28 @@ export interface PredictProtonOptions {
   /**
    * diastereotopic atom ids.
    */
-  diaIDs?: string[];
+  diaIDs: string[];
+  /**
+   * distance matrix
+   */
+  distanceMatrix: number[][];
 }
 
 export type PredictProton = typeof predictProton;
 
 export async function predictProton(
-  molecule: Molecule,
-  options: PredictProtonOptions = {},
-): Promise<Prediction1D> {
-  if (isEmptyMolecule(molecule)) {
+  molfile: string,
+  options: PredictProtonOptions,
+): Promise<PredictionBase1D> {
+  if (!isMolfileNotEmpty(molfile)) {
     return {
-      molfile: molecule.toMolfile(),
-      nucleus: '13C',
-      diaIDs: [],
+      nucleus: '1H',
       joinedSignals: [],
       signals: [],
       ranges: [],
-      molecule,
     };
   }
   const { cache } = options;
-  molecule = molecule.getCompactCopy();
-  molecule.addImplicitHydrogens();
-  ensureHeterotopicChiralBonds(molecule);
-  const molfile = molecule.toMolfile();
 
   let result;
   if (cache) {
@@ -72,30 +63,25 @@ export async function predictProton(
     }
   }
 
-  const { diaIDs = getDiastereotopicAtomIDs(molecule) } = options;
-  const signals = protonParser(result, molecule, diaIDs);
+  const { diaIDs, distanceMatrix } = options;
+  const signals = protonParser(result, { diaIDs, distanceMatrix });
   const joinedSignals = signalsJoin(signals);
   return {
-    molfile,
-    diaIDs,
     nucleus: '1H',
     joinedSignals,
     signals,
     ranges: signalsToRanges(joinedSignals),
-    molecule,
   };
 }
 
 function protonParser(
   result: string,
-  molecule: Molecule,
-  diaIDs: string[],
+  options: { diaIDs: string[]; distanceMatrix: number[][] },
 ): NMRSignal1D[] {
-  if (molecule.getAllAtoms() === 0) return [];
   if (result.includes('ERR')) {
     throw Error(`Spinus optimization: ${result}`);
   }
-  const distanceMatrix = getConnectivityMatrix(molecule, { pathLength: true });
+  const { diaIDs, distanceMatrix } = options;
   const lines = result.split('\n').filter((line) => line);
   const signals = [];
   for (const line of lines) {

package/src/prediction/{predictAllSpectra.ts → predictSpectra.ts}

@@ -5,7 +5,7 @@ import { signals2DToZ } from '../signals/signals2DToZ';
 import { OptionsSignalsToXY, signalsToXY } from '../signals/signalsToXY';
 import { getFrequency } from '../utilities/getFrequency';
 
-import { PredictAllOptions, predictAll } from './predictAll';
+import { PredictAllOptions, predict } from './predict';
 /**
  * This function will generate an object compatible with NMR-ium
  *
@@ -44,8 +44,7 @@ export async function predictAllSpectra(
     prediction: predictionOptions = {},
   } = options;
 
-  const predictions = await predictAll(molecule, predictionOptions);
-  const { molfile, spectra } = predictions;
+  const { spectra } = await predict(molecule, predictionOptions);
 
   const oneDOptions: OneDOptions = {
     ...{
@@ -99,7 +98,10 @@ export async function predictAllSpectra(
     }
   }
 
-  return { spectra: newSpectra, molecules: [{ molfile }] };
+  return {
+    spectra: newSpectra,
+    molecules: [{ molfile: molecule.toMolfile() }],
+  };
 }
 
 type Get2DSpectrumOptions = TwoDOptions & {

package/src/prediction/utils/fetchPrediction.ts

@@ -1,33 +1,38 @@
 import fetch from 'cross-fetch';
-import type { Molecule } from 'openchemlib/full';
 
-import type { Prediction1D } from '../Prediction1D';
+import { PredictionBase1D } from '../PredictionBase1D';
+
+import { isMolfileNotEmpty } from './isMolfileNotEmpty';
 
 interface FetchPredictionOptions {
   webserviceURL: string;
 }
 
 export async function fetchPrediction(
-  molecule: Molecule,
+  molfile: string,
   options: FetchPredictionOptions,
-): Promise<Prediction1D> {
+): Promise<PredictionBase1D> {
+  if (!isMolfileNotEmpty(molfile)) {
+    return {
+      nucleus: '13C',
+      joinedSignals: [],
+      signals: [],
+      ranges: [],
+    };
+  }
   const { webserviceURL } = options;
   const response = await fetch(webserviceURL, {
     headers: {
       accept: 'application/json',
       'content-type': 'application/json',
     },
-    body: JSON.stringify({ molfile: molecule.toMolfile() }),
+    body: JSON.stringify({ molfile }),
     method: 'POST',
   });
 
   if (response.status >= 400) {
     throw new Error(response.statusText);
   }
-  const prediction = (await response.json()).data;
 
-  prediction.molecule = molecule
-    .getOCL()
-    .Molecule.fromMolfile(prediction.molfile);
-  return prediction;
+  return (await response.json()).data;
 }

package/src/prediction/utils/getFilteredIDiaIDs.ts

@@ -1,54 +1,21 @@
-import type { Molecule } from 'openchemlib/full';
-import {
-  getHoseCodesFromDiastereotopicID,
-  ensureHeterotopicChiralBonds,
-  groupDiastereotopicAtomIDs,
-} from 'openchemlib-utils';
-import type { GroupDiastereotopicAtomIDs } from 'openchemlib-utils';
+export function getFilteredIDiaIDs(options: {
+  groupedDiaIDs: any[];
+  hoses: any;
+}) {
+  const { groupedDiaIDs, hoses } = options;
+
+  const carbonDiaIDs = groupedDiaIDs
+    .filter((group) => group.atomLabel === 'C')
+    .sort((a, b) => {
+      if (a.atomLabel === b.atomLabel) {
+        return b.counter - a.counter;
+      }
+      return a.atomLabel < b.atomLabel ? 1 : -1;
+    });
 
-export interface GroupDiaIDsWithHose extends GroupDiastereotopicAtomIDs {
-  hose: string[];
-}
-
-export type GroupedDiaIDsWithHose = GroupDiaIDsWithHose[];
-
-export function getFilteredIDiaIDs(
-  molecule: Molecule,
-  options: { maxSphereSize: number; diaIDs: string[] },
-) {
-  const { maxSphereSize, diaIDs } = options;
-
-  molecule.addImplicitHydrogens();
-  molecule.addMissingChirality();
-  ensureHeterotopicChiralBonds(molecule);
-
-  const molfile = molecule.toMolfile();
-
-  const groupedDiaIDs = groupDiastereotopicAtomIDs(diaIDs, molecule, {
-    atomLabel: 'C',
-  });
-
-  const carbonDiaIDs = groupedDiaIDs.sort((a, b) => {
-    if (a.atomLabel === b.atomLabel) {
-      return b.counter - a.counter;
-    }
-    return a.atomLabel < b.atomLabel ? 1 : -1;
-  }) as any;
-
-  const OCL = molecule.getOCL();
   for (const diaId of carbonDiaIDs) {
-    diaId.hose = getHoseCodesFromDiastereotopicID(
-      OCL.Molecule.fromIDCode(diaId.oclID),
-      {
-        maxSphereSize,
-      },
-    );
+    diaId.hose = hoses[diaId.atoms[0]];
   }
 
-  const toReturn = {
-    molfile,
-    carbonDiaIDs: carbonDiaIDs as GroupedDiaIDsWithHose,
-  };
-
-  return toReturn;
+  return carbonDiaIDs;
 }

package/src/prediction/utils/isMolfileNotEmpty.ts

@@ -0,0 +1,8 @@
+import { Molecule } from 'openchemlib/full';
+
+import { isEmptyMolecule } from './isEmptyMolecule';
+
+export function isMolfileNotEmpty(molFile?: string): molFile is string {
+  if (!molFile?.match(/V[23]0/)) return false;
+  return !isEmptyMolecule(Molecule.fromMolfile(molFile));
+}

package/src/prediction/utils/predict2D.ts

@@ -1,30 +1,20 @@
 import { v4 as generateID } from '@lukeed/uuid';
 import { agnes, Cluster } from 'ml-hclust';
 import { Matrix } from 'ml-matrix';
-import type { Molecule } from 'openchemlib/full';
-import {
-  getGroupedDiastereotopicAtomIDs,
-  getPathsInfo,
-  groupDiastereotopicAtomIDs,
-} from 'openchemlib-utils';
-import type {
-  AtomInfo,
-  GroupDiastereotopicAtomIDs,
-  PathInfo,
-} from 'openchemlib-utils';
+import { Molecule } from 'openchemlib/full';
 
 import { setIDs } from '../../peaks/util/setIDs';
 import type { NMRSignal1D } from '../../signals/NMRSignal1D';
 import type { MakeMandatory } from '../../utilities/MakeMandatory';
 import type { NMRSignal2D } from '../../xyz/NMRSignal2D';
 import { NMRZone } from '../../xyz/NMRZone';
-import type { Prediction1D } from '../Prediction1D';
-import { Prediction2D } from '../Prediction2D';
+import { GroupDiastereotopicAtomIDs } from '../GroupDiastereotopicAtomIDs';
+import { PredictionBase1D } from '../PredictionBase1D';
+import { PredictionBase2D } from '../PredictionBase2D';
 import type { PredictCarbon, PredictCarbonOptions } from '../predictCarbon';
 import type { PredictProton, PredictProtonOptions } from '../predictProton';
 
 import { getNuclei } from './getNuclei';
-import { getPredictions } from './getPredictions';
 
 /**
  * Generate the correlation bidimensional nmr peaks based on the number of bonds between a pair of atoms
@@ -63,15 +53,6 @@ export interface Predict2DOptions {
    * @default 0
    */
   minLength?: number;
-  /**
-   * mono dimensional predictors.
-   */
-  predictor?: Predictors;
-  /**
-   *  mono dimensional signal to generate the bidimenionals cross peaks.
-   * The object should has properties with name equal to "H" and "C".
-   */
-  predictOptions?: PredictOptions;
   /**
    * signals with euclidean distance in ppm less than this it will
    * joined into a zone.
@@ -83,7 +64,7 @@ export interface Predict2DOptions {
    * The object should has properties with name equal to "H" and "C".
    * the value of each prediction should be similar that predictProton and predictCarbon.
    */
-  predictions?: Predictions;
+  predictions: Predictions;
   /**
    * if true, the self correlation signal will be add to the prediction.
    * @default false
@@ -92,7 +73,12 @@ export interface Predict2DOptions {
   /**
    * diastereotopic atom ids of the molecule.
    */
-  diaIDs?: string[];
+  diaIDs: string[];
+  /**
+   * grouped diastereotopic atom ids of the molecule.
+   */
+  groupedDiaIDs: GroupDiastereotopicAtomIDs[];
+  distanceMatrix: number[][];
 }
 
 export interface PredictOptions {
@@ -101,10 +87,10 @@ export interface PredictOptions {
   C?: PredictCarbonOptions;
 }
 
-export type Predictions = Record<string, Prediction1D | undefined>;
+export type Predictions = Record<string, PredictionBase1D | undefined>;
 
 type GroupDiastereotopicAtomIDsWithAtomInfo = GroupDiastereotopicAtomIDs & {
-  pathInfo: PathInfo;
+  pathInfo: AtomPartialPathInfo;
 };
 
 type PredictHMBCOptionsWithFromTo = MakeMandatory<
@@ -122,10 +108,7 @@ function checkFromTo(
 
 type Signal1DByDiaID = Record<string, Record<string, NMRSignal1D>>;
 
-export async function predict2D(
-  molecule: Molecule,
-  options: Predict2DOptions = {},
-) {
+export async function predict2D(molecule: Molecule, options: Predict2DOptions) {
   checkFromTo(options);
 
   molecule.addImplicitHydrogens();
@@ -134,60 +117,41 @@ export async function predict2D(
     from,
     to,
     diaIDs,
+    groupedDiaIDs,
     minLength = 0,
     maxLength,
-    predictOptions = {},
     predictions,
-    predictor,
+    distanceMatrix,
     joinDistance = { H: 0.05, C: 0.5 },
     includeDiagonal = false,
   } = options;
 
-  const pathsInfo = getPathsInfo(molecule, {
+  const pathsInfo = getPossibleCorrelations({
+    molecule,
     fromLabel: from,
     toLabel: to,
+    diaIDs,
+    distanceMatrix,
     minLength,
     maxLength,
   });
 
-  const groupedDiaIDS = diaIDs
-    ? groupDiastereotopicAtomIDs(diaIDs, molecule)
-    : getGroupedDiastereotopicAtomIDs(molecule);
-
   const diaIDswithAtomInfo: GroupDiastereotopicAtomIDsWithAtomInfo[] = [];
-  for (const diaID of groupedDiaIDS) {
+  for (const diaID of groupedDiaIDs) {
     diaIDswithAtomInfo.push({
       ...diaID,
-      pathInfo: JSON.parse(
-        JSON.stringify(pathsInfo[diaID.atoms[0]]),
-      ) as PathInfo,
+      pathInfo: JSON.parse(JSON.stringify(pathsInfo[diaID.atoms[0]])),
     });
   }
 
-  const xPrediction = await getPredictions(
-    from,
-    molecule,
-    predictOptions,
-    predictor,
-    predictions,
-  );
-
-  const yPrediction =
-    from === to
-      ? xPrediction
-      : await getPredictions(
-          to,
-          molecule,
-          predictOptions,
-          predictor,
-          predictions,
-        );
+  const yPrediction = predictions[to];
+  const xPrediction = predictions[from];
 
   if (!xPrediction || !yPrediction) {
     throw new Error('predictions are not availaible');
   }
 
-  const spectra: Record<string, Prediction1D> = {
+  const spectra: Record<string, PredictionBase1D> = {
     x: xPrediction,
     y: yPrediction,
   };
@@ -202,6 +166,7 @@ export async function predict2D(
       signalsByDiaID[axis][signal.diaIDs[0]] = signal;
     }
   }
+
   const group: Record<string, NMRSignal2D> = {};
   for (const diaID of diaIDswithAtomInfo) {
     const pathInfo = diaID.pathInfo;
@@ -213,13 +178,12 @@ export async function predict2D(
     for (const path of currentPaths) {
       if (!signalsByDiaID.y[pathsInfo[path.to].oclID]) continue;
 
-      const fromToDiaID: Record<string, AtomInfo> = {
+      const fromToDiaID: Record<string, AtomPartialPathInfo> = {
         x: pathInfo,
         y: pathsInfo[path.to],
       };
 
       const key = `${fromToDiaID.x.oclID}-${fromToDiaID.y.oclID}`;
-
       if (key === `${pathInfo.oclID}-${pathInfo.oclID}` || group[key]) {
         continue;
       }
@@ -240,7 +204,7 @@ export async function predict2D(
   }
 
   if (includeDiagonal) {
-    addSelftCorrelation(group, { paths: pathsInfo, signalsByDiaID });
+    addSelfCorrelation(group, { paths: pathsInfo, signalsByDiaID });
   }
 
   // clusterize signals by distance
@@ -248,14 +212,50 @@ export async function predict2D(
   const zones = createZones(joinedSignals, { joinDistance, from, to });
 
   return {
-    molfile: molecule.toMolfile(),
-    diaIDs: spectra.x.diaIDs,
     nuclei: getNuclei({ from, to }),
     joinedSignals,
     signals: splitSignals(joinedSignals),
     zones,
+  } as PredictionBase2D;
+}
+
+interface AtomPartialPathInfo {
+  oclID: string;
+  paths: Array<{ from: number; to: number }>;
+}
+function getPossibleCorrelations(options: any) {
+  const {
+    fromLabel,
+    toLabel,
+    distanceMatrix,
     molecule,
-  } as Prediction2D;
+    diaIDs,
+    minLength,
+    maxLength,
+  } = options;
+  const fromAtomicNumber = Molecule.getAtomicNoFromLabel(fromLabel);
+  const toAtomicNumber = Molecule.getAtomicNoFromLabel(toLabel);
+  const atomPathInfo: AtomPartialPathInfo[] = [];
+  for (let from = 0; from < molecule.getAllAtoms(); from++) {
+    const toSave: AtomPartialPathInfo = {
+      oclID: diaIDs[from],
+      paths: [],
+    };
+    for (let to = 0; to < molecule.getAllAtoms(); to++) {
+      if (from === to) continue;
+      if (molecule.getAtomicNo(to) !== toAtomicNumber) continue;
+      if (molecule.getAtomicNo(from) !== fromAtomicNumber) continue;
+      const pathLength = distanceMatrix[from][to];
+      if (pathLength >= minLength && pathLength <= maxLength) {
+        toSave.paths.push({
+          from,
+          to,
+        });
+      }
+    }
+    atomPathInfo.push(toSave);
+  }
+  return atomPathInfo;
 }
 
 function splitSignals(joinedSignals: NMRSignal2D[]) {
@@ -274,10 +274,10 @@ function splitSignals(joinedSignals: NMRSignal2D[]) {
 }
 
 interface AddSelftCorrelationOptions {
-  paths: PathInfo[];
+  paths: AtomPartialPathInfo[];
   signalsByDiaID: Signal1DByDiaID;
 }
-function addSelftCorrelation(
+function addSelfCorrelation(
   group: Record<string, NMRSignal2D>,
   options: AddSelftCorrelationOptions,
 ) {

package/src/prediction/utils/queryByHOSE.ts

@@ -1,6 +1,6 @@
 import type { DataBaseStructure } from '../dataStructure';
 
-import type { GroupedDiaIDsWithHose } from './getFilteredIDiaIDs';
+// import type { GroupedDiaIDsWithHose } from './getFilteredIDiaIDs';
 
 export interface Prediction {
   diaIDs: string[];
@@ -17,7 +17,7 @@ export interface Prediction {
   };
 }
 export function queryByHose(
-  diaIDs: GroupedDiaIDsWithHose,
+  diaIDs: any,
   db: DataBaseStructure,
   options: { maxSphereSize: number },
 ): Prediction[] {

package/src/prediction/utils/shouldPredict.ts

@@ -0,0 +1,14 @@
+import { PredictionOptionsByExperiment } from '../predict';
+
+export function shouldPredict(
+  key: keyof PredictionOptionsByExperiment,
+  options: PredictionOptionsByExperiment,
+) {
+  if (key in options) return true;
+  const heteroRequired = 'hsqc' in options || 'hmbc' in options;
+  return key === 'C'
+    ? heteroRequired
+    : key === 'H'
+    ? heteroRequired || 'cosy' in options
+    : false;
+}