nmr-processing 9.9.2 → 10.0.0

package/src/assignment/get1HAssignments.ts

@@ -1,12 +1,8 @@
 import { v4 as generateID } from '@lukeed/uuid';
 import { Molecule } from 'openchemlib/full';
-import { ensureHeterotopicChiralBonds } from 'openchemlib-utils';
 
-import { NMRRange } from '..';
-import {
-  predictProton,
-  PredictProtonOptions,
-} from '../prediction/predictProton';
+import { NMRRange, predict } from '..';
+import { PredictProtonOptions } from '../prediction/predictProton';
 import type { NMRSignal1D } from '../signals/NMRSignal1D';
 import { MakeMandatory } from '../utilities/MakeMandatory';
 
@@ -90,10 +86,13 @@ export async function get1HAssignments(
     throw new Error('It is needed a OCL molecule instance to assign');
   }
 
-  molecule.addImplicitHydrogens();
-  ensureHeterotopicChiralBonds(molecule);
+  const { spectra } = await predict(molecule, {
+    predictOptions: {
+      H: predictionOptions,
+    },
+  });
 
-  const { joinedSignals } = await predictProton(molecule, predictionOptions);
+  const joinedSignals = spectra.proton?.joinedSignals || [];
 
   checkForIntegration(ranges);
   checkAtomsAndDiaIDs(joinedSignals);

package/src/assignment/utils/generalAssignment/buildAssignments.ts

@@ -4,12 +4,12 @@ import type { Molecule } from 'openchemlib/full';
 import { getConnectivityMatrix } from 'openchemlib-utils';
 
 import {
-  NMRSignal1D,
-  PredictCarbonOptions,
-  PredictProtonOptions,
-} from '../../..';
-import { predictCarbon } from '../../../prediction/predictCarbon';
-import { predictProton } from '../../../prediction/predictProton';
+  PredictionOptionsByExperiment,
+  predict,
+} from '../../../prediction/predict';
+import { PredictCarbonOptions } from '../../../prediction/predictCarbon';
+import { PredictProtonOptions } from '../../../prediction/predictProton';
+import { NMRSignal1D } from '../../../signals/NMRSignal1D';
 import { MakeMandatory } from '../../../utilities/MakeMandatory';
 import { SpectraDataWithIds } from '../../nmrAssigment';
 import { StoreAssignments } from '../oneDimensionalAssignment/buildAssignments';
@@ -27,8 +27,6 @@ const comparator = (a: AssignmentSolution, b: AssignmentSolution) => {
   return b.score - a.score;
 };
 
-const predictor = { H: predictProton, C: predictCarbon };
-
 export type AtomTypes = 'H' | 'C';
 export type CurrentAtoms = AtomTypes[];
 export type Partial = Record<string, Array<string | null>>;
@@ -141,11 +139,15 @@ export async function buildAssignments(props: BuildAssignmentInput) {
 
   for (const atomTypesToPredict of assignmentOrder) {
     for (const atomType of atomTypesToPredict) {
-      const options = predictionOptions[atomType];
+      const options: PredictionOptionsByExperiment = {};
+      options[atomType] = predictionOptions[atomType];
       const predictedSignals = inputPrediction[atomType];
-      const { joinedSignals } = predictedSignals
-        ? { joinedSignals: predictedSignals }
-        : await predictor[atomType](molecule, options);
+      const joinedSignals = await getJoinedSignals({
+        molecule,
+        predictedSignals,
+        options,
+        atomType,
+      });
 
       checkNMRSignal1D(joinedSignals);
 
@@ -338,3 +340,17 @@ function fillPartial(nSources: number, value: string | null = null) {
   }
   return partial;
 }
+
+async function getJoinedSignals(input: {
+  atomType: AtomTypes;
+  molecule: Molecule;
+  predictedSignals?: NMRSignal1D[];
+  options: PredictionOptionsByExperiment;
+}) {
+  const { molecule, predictedSignals, options, atomType } = input;
+  if (predictedSignals) return predictedSignals;
+  const { spectra } = await predict(molecule, {
+    predictOptions: options,
+  });
+  return spectra[atomType === 'C' ? 'carbon' : 'proton']?.joinedSignals || [];
+}

package/src/index.ts

@@ -7,14 +7,6 @@ export * from './peaks/peaksFilterImpurities';
 export * from './peaks/peaksToXY';
 export * from './peaks/peakToXY';
 
-export * from './prediction/predictProton';
-export * from './prediction/predictCarbon';
-export * from './prediction/predictCOSY';
-export * from './prediction/predictHSQC';
-export * from './prediction/predictHMBC';
-export * from './prediction/predictAll';
-export * from './prediction/predictAllSpectra';
-
 export * from './assignment/get1HAssignments';
 export * from './assignment/get13CAssignments';
 export * from './assignment/getAssignments';
@@ -31,6 +23,9 @@ export * from './signals/simulation/simulate1D';
 export * from './signal/signalJoinCouplings';
 export * from './signal/signalMultiplicityPattern';
 
+export * from './prediction/predict';
+export * from './prediction/predictSpectra';
+
 export * from './utilities/resurrect';
 export * from './utilities/rangeFromSignal';
 export * from './utilities/getFrequency';

package/src/prediction/GroupDiastereotopicAtomIDs.ts

@@ -0,0 +1,6 @@
+export interface GroupDiastereotopicAtomIDs {
+  counter: number;
+  atoms: number[];
+  oclID: string;
+  atomLabel: string;
+}

package/src/prediction/Prediction1D.ts

@@ -1,14 +1,9 @@
 import type { Molecule } from 'openchemlib/full';
 
-import type { NMRSignal1D } from '../signals/NMRSignal1D';
-import type { NMRRange } from '../xy/NMRRange';
+import type { PredictionBase1D } from './PredictionBase1D';
 
-export interface Prediction1D {
+export interface Prediction1D extends PredictionBase1D {
   molfile: string;
   diaIDs: string[];
-  nucleus: string;
-  joinedSignals: NMRSignal1D[];
-  signals: NMRSignal1D[];
-  ranges: NMRRange[];
   molecule: Molecule;
 }

package/src/prediction/Prediction2D.ts

@@ -1,14 +1,9 @@
 import type { Molecule } from 'openchemlib/full';
 
-import { NMRSignal2D } from '../xyz/NMRSignal2D';
-import { NMRZone } from '../xyz/NMRZone';
+import { PredictionBase2D } from './PredictionBase2D';
 
-export interface Prediction2D {
+export interface Prediction2D extends PredictionBase2D {
   molfile: string;
   diaIDs: string[];
-  nuclei: string[];
-  joinedSignals: NMRSignal2D[];
-  signals: NMRSignal2D[];
-  zones: NMRZone[];
   molecule: Molecule;
 }

package/src/prediction/PredictionBase1D.ts

@@ -0,0 +1,9 @@
+import type { NMRSignal1D } from '../signals/NMRSignal1D';
+import type { NMRRange } from '../xy/NMRRange';
+
+export interface PredictionBase1D {
+  nucleus: string;
+  joinedSignals: NMRSignal1D[];
+  signals: NMRSignal1D[];
+  ranges: NMRRange[];
+}

package/src/prediction/PredictionBase2D.ts

@@ -0,0 +1,9 @@
+import { NMRSignal2D } from '../xyz/NMRSignal2D';
+import { NMRZone } from '../xyz/NMRZone';
+
+export interface PredictionBase2D {
+  nuclei: string[];
+  joinedSignals: NMRSignal2D[];
+  signals: NMRSignal2D[];
+  zones: NMRZone[];
+}

package/src/prediction/predict.ts

@@ -0,0 +1,201 @@
+import type { Logger } from 'cheminfo-types';
+import type { Molecule } from 'openchemlib/full';
+import {
+  getHoseCodesAndInfo,
+  groupDiastereotopicAtomIDs,
+} from 'openchemlib-utils';
+
+import { PredictionBase1D } from './PredictionBase1D';
+import { PredictionBase2D } from './PredictionBase2D';
+import { predictCOSY, PredictCOSYOptions } from './predictCOSY';
+import { predictCarbon, PredictCarbonOptions } from './predictCarbon';
+import { predictHMBC, PredictHMBCOptions } from './predictHMBC';
+import { predictHSQC, PredictHSQCOptions } from './predictHSQC';
+import { predictProton, PredictProtonOptions } from './predictProton';
+import { shouldPredict } from './utils/shouldPredict';
+
+export interface PredictionOptionsByExperiment {
+  H?: Partial<PredictProtonOptions>;
+  C?: Partial<PredictCarbonOptions>;
+  hsqc?: Partial<PredictHSQCOptions>;
+  cosy?: Partial<PredictCOSYOptions>;
+  hmbc?: Partial<PredictHMBCOptions>;
+}
+
+interface ToPredictBase {
+  required: Array<'H' | 'C'>;
+  message: string;
+}
+interface ToPredictCOSY extends ToPredictBase {
+  predictor: typeof predictCOSY;
+}
+interface ToPredictHSQC extends ToPredictBase {
+  predictor: typeof predictHSQC;
+}
+interface ToPredictHMBC extends ToPredictBase {
+  predictor: typeof predictHMBC;
+}
+interface ToPredict {
+  cosy: ToPredictCOSY;
+  hsqc: ToPredictHSQC;
+  hmbc: ToPredictHMBC;
+}
+const toPredict: ToPredict = {
+  cosy: {
+    predictor: predictCOSY,
+    required: ['H'],
+    message: 'Proton prediction is missing so COSY could not be generated.',
+  },
+  hsqc: {
+    predictor: predictHSQC,
+    required: ['H', 'C'],
+    message:
+      'Carbon and / or proton prediction is missing so HSQC could not be generated.',
+  },
+  hmbc: {
+    predictor: predictHMBC,
+    required: ['H', 'C'],
+    message:
+      'Carbon and / or proton prediction is missing so HMBC could not be generated.',
+  },
+};
+
+export interface PredictAllOptions {
+  /**
+   *  mono dimensional signal to generate the bidimenionals cross peaks.
+   * The object should has properties with name equal to "H" and "C".
+   */
+  predictOptions?: PredictionOptionsByExperiment;
+  /**
+   * signals with euclidean distance in ppm less than this it will
+   * joined into a zone.
+   * @default {H:0.05,C:0.5}
+   */
+  joinDistance?: { H: number; C: number };
+  logger?: Logger;
+}
+
+export interface PredictedSpectra {
+  proton?: PredictionBase1D;
+  carbon?: PredictionBase1D;
+  cosy?: PredictionBase2D;
+  hsqc?: PredictionBase2D;
+  hmbc?: PredictionBase2D;
+}
+
+export interface Predicted {
+  molfile: string;
+  molfileWithH: string;
+  hoses: any[];
+  diaIDs: any[] | undefined;
+  groupedDiaIDs: any[];
+  moleculeWithHydrogens: Molecule;
+  distanceMatrix: any[];
+  spectra: PredictedSpectra;
+}
+
+/**
+ * Generate the correlation bidimensional nmr peaks based on the number of bonds between a pair of atoms
+ * @returns {Promise<object>} - object with molfile, diaIDs, 1D and 2D signals, joined signals, ranges and zones.
+ */
+export async function predict(
+  molecule: Molecule,
+  options: PredictAllOptions = {},
+): Promise<Predicted> {
+  const {
+    logger,
+    joinDistance = { H: 0.05, C: 0.5 },
+    predictOptions = {
+      H: {},
+      C: {},
+      hsqc: {},
+      hmbc: {},
+      cosy: {},
+    } as PredictionOptionsByExperiment,
+  } = options;
+
+  const hoseCodesAndInfo = getHoseCodesAndInfo(molecule, {
+    maxSphereSize: predictOptions?.C?.maxSphereSize,
+  });
+  const {
+    diaIDs = [],
+    moleculeWithHydrogens,
+    hoses,
+    molfileWithH,
+    distanceMatrix,
+  } = hoseCodesAndInfo;
+
+  const groupedDiaIDs = groupDiastereotopicAtomIDs(
+    diaIDs,
+    moleculeWithHydrogens,
+  );
+
+  const protonPrediction = shouldPredict('H', predictOptions)
+    ? await predictProton(molfileWithH, {
+        ...predictOptions?.H,
+        diaIDs,
+        distanceMatrix,
+      })
+    : undefined;
+
+  const carbonPrediction = shouldPredict('C', predictOptions)
+    ? await predictCarbon({
+        ...predictOptions?.C,
+        molfile: molfileWithH,
+        groupedDiaIDs,
+        hoses,
+      })
+    : undefined;
+
+  const spectra: any = {};
+  const predictions: Record<string, PredictionBase1D> = {};
+  if (check1DPrediction(protonPrediction, diaIDs)) {
+    predictions.H = protonPrediction;
+    if ('H' in predictOptions) spectra.proton = protonPrediction;
+  }
+  if (check1DPrediction(carbonPrediction, diaIDs)) {
+    predictions.C = carbonPrediction;
+    if ('C' in predictOptions) spectra.carbon = carbonPrediction;
+  }
+
+  const optionsTwoD = {
+    predictions,
+    joinDistance,
+    distanceMatrix,
+    groupedDiaIDs,
+    diaIDs,
+  };
+
+  for (const key in predictOptions) {
+    if (key === 'H' || key === 'C') continue;
+    const { predictor, required, message } = toPredict[key as keyof ToPredict];
+    if (required.every((key) => key in predictions)) {
+      spectra[key] = await predictor(molecule, {
+        ...optionsTwoD,
+        ...predictOptions[key as keyof PredictionOptionsByExperiment],
+      });
+    } else if (logger) {
+      logger.warn(message);
+    }
+  }
+
+  return {
+    ...hoseCodesAndInfo,
+    groupedDiaIDs,
+    spectra,
+  };
+}
+
+function check1DPrediction(
+  prediction?: PredictionBase1D,
+  diaIDs: string[] = [],
+): prediction is PredictionBase1D {
+  if (!prediction) return false;
+  if (prediction.ranges.length === 0) return false;
+  const { signals } = prediction;
+  for (const signal of signals) {
+    const isCorrect = signal.diaIDs?.every((diaID) => diaIDs.includes(diaID));
+    if (!isCorrect) return false;
+  }
+  return true;
+}

package/src/prediction/predictCOSY.ts

@@ -1,8 +1,9 @@
 import type { Molecule } from 'openchemlib/full';
 
-import type { Prediction1D } from './Prediction1D';
-import { predictProton, PredictProtonOptions } from './predictProton';
-import { predict2D, Predictor } from './utils/predict2D';
+import { GroupDiastereotopicAtomIDs } from './GroupDiastereotopicAtomIDs';
+import type { PredictionBase1D } from './PredictionBase1D';
+import { PredictProtonOptions } from './predictProton';
+import { predict2D } from './utils/predict2D';
 
 export interface PredictCOSYOptions {
   /**
@@ -15,11 +16,6 @@ export interface PredictCOSYOptions {
    * @default 2
    */
   minLength?: number;
-  /**
-   * mono dimensional predictors. The object should has properties with name
-   * equal to "H" and "C".
-   */
-  predictor?: { H?: Predictor };
   /**
    *  mono dimensional signal to generate the bidimenionals cross peaks.
    * The object should has properties with name equal to "H" and "C".
@@ -36,15 +32,24 @@ export interface PredictCOSYOptions {
    * 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;
+  predictions: {
+    [key: string]: PredictionBase1D | undefined;
+    H?: PredictionBase1D;
   };
   /**
    * if true, the self correlation signal will be add to the prediction.
    * @default true
    */
   includeDiagonal?: boolean;
+  /**
+   * 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
@@ -53,27 +58,22 @@ export interface PredictCOSYOptions {
 
 export async function predictCOSY(
   molecule: Molecule,
-  options: PredictCOSYOptions = {},
+  options: PredictCOSYOptions,
 ) {
   const {
     minLength = 2,
     maxLength = 3,
-    predictions,
-    predictor = { H: predictProton },
-    predictOptions,
     joinDistance = { H: 0.05, C: 0.5 },
     includeDiagonal = true,
   } = options;
 
   return predict2D(molecule, {
+    ...options,
     from: 'H',
     to: 'H',
-    predictor,
     minLength,
     maxLength,
     joinDistance,
-    predictions,
     includeDiagonal,
-    predictOptions,
   });
 }

package/src/prediction/predictCarbon.ts

@@ -1,17 +1,15 @@
 import { v4 as generateID } from '@lukeed/uuid';
-import type { Molecule } from 'openchemlib/full';
-import { getDiastereotopicAtomIDs } from 'openchemlib-utils';
 
 import { setIDs } from '../peaks/util/setIDs';
 import type { NMRSignal1D } from '../signals/NMRSignal1D';
 import { signalsToRanges } from '../signals/signalsToRanges';
 import type { MakeMandatory } from '../utilities/MakeMandatory';
 
-import type { Prediction1D } from './Prediction1D';
+import { PredictionBase1D } from './PredictionBase1D';
 import type { DataBaseStructure } from './dataStructure';
 import { fetchPrediction } from './utils/fetchPrediction';
 import { getFilteredIDiaIDs } from './utils/getFilteredIDiaIDs';
-import { isEmptyMolecule } from './utils/isEmptyMolecule';
+import { isMolfileNotEmpty } from './utils/isMolfileNotEmpty';
 import { Prediction, queryByHose } from './utils/queryByHOSE';
 
 export interface PredictCarbonOptions {
@@ -33,7 +31,16 @@ export interface PredictCarbonOptions {
   /**
    * diastereotopic atom ids.
    */
-  diaIDs?: string[];
+  groupedDiaIDs: string[];
+  /**
+   * hoses code of the molecule.
+   */
+  hoses: Array<any[] | undefined>;
+  /**
+   * molfile of the molecule, it could be used if there is not a database provided.
+   * so the prediction will be fetched to the web service (webserviceURL)
+   */
+  molfile?: string;
 }
 
 export type PredictCarbon = typeof predictCarbon;
@@ -55,29 +62,27 @@ function checkFromPrediction(
  */
 
 export async function predictCarbon(
-  molecule: Molecule,
-  options: PredictCarbonOptions = {},
-): Promise<Prediction1D> {
-  if (isEmptyMolecule(molecule)) {
+  options: PredictCarbonOptions,
+): Promise<PredictionBase1D> {
+  const {
+    hoses,
+    molfile,
+    database,
+    webserviceURL = 'https://nmr-prediction.service.zakodium.com/v1/predict/carbon',
+    groupedDiaIDs,
+  } = options;
+
+  if (!database && isMolfileNotEmpty(molfile)) {
+    return fetchPrediction(molfile, { webserviceURL });
+  } else if (!isMolfileNotEmpty(molfile)) {
     return {
-      molfile: molecule.toMolfile(),
       nucleus: '13C',
-      diaIDs: [],
       joinedSignals: [],
       signals: [],
       ranges: [],
-      molecule,
     };
   }
 
-  const {
-    database,
-    webserviceURL = 'https://nmr-prediction.service.zakodium.com/v1/predict/carbon',
-    diaIDs = getDiastereotopicAtomIDs(molecule),
-  } = options;
-
-  if (!database) return fetchPrediction(molecule, { webserviceURL });
-
   if (!database) {
     throw new Error('There is not a database');
   }
@@ -88,9 +93,9 @@ export async function predictCarbon(
 
   if (maxSphereSize > maxLevel) maxSphereSize = maxLevel;
 
-  const { carbonDiaIDs, molfile } = getFilteredIDiaIDs(molecule, {
-    maxSphereSize,
-    diaIDs,
+  const carbonDiaIDs = getFilteredIDiaIDs({
+    groupedDiaIDs,
+    hoses,
   });
 
   const predictions = queryByHose(carbonDiaIDs, database, {
@@ -100,13 +105,10 @@ export async function predictCarbon(
   const signals = formatSignals(predictions);
   const joinedSignals = joinSignalByDiaID(signals);
   return {
-    molfile,
     nucleus: '13C',
-    diaIDs,
     joinedSignals,
     signals,
     ranges: signalsToRanges(joinedSignals),
-    molecule,
   };
 }
 

package/src/prediction/predictHMBC.ts

@@ -1,12 +1,8 @@
 import type { Molecule } from 'openchemlib/full';
 
-import type { Prediction1D } from './Prediction1D';
-import { predictCarbon } from './predictCarbon';
-import type { PredictCarbonOptions } from './predictCarbon';
-import { predictProton } from './predictProton';
-import type { PredictProtonOptions } from './predictProton';
+import { GroupDiastereotopicAtomIDs } from './GroupDiastereotopicAtomIDs';
+import { PredictionBase1D } from './PredictionBase1D';
 import { predict2D } from './utils/predict2D';
-import type { Predictor } from './utils/predict2D';
 
 /**
  * Generate the correlation bidimensional nmr peaks based on the number of bonds between a pair of atoms
@@ -24,16 +20,6 @@ export interface PredictHMBCOptions {
    * @default 2
    */
   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.
@@ -45,34 +31,38 @@ export interface PredictHMBCOptions {
    * 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[][];
 }
 
 export async function predictHMBC(
   molecule: Molecule,
-  options: PredictHMBCOptions = {},
+  options: PredictHMBCOptions,
 ) {
   const {
     minLength = 2,
     maxLength = 3,
-    predictor = { H: predictProton, C: predictCarbon },
-    predictOptions,
-    predictions,
     joinDistance = { H: 0.05, C: 0.5 },
   } = options;
 
   return predict2D(molecule, {
+    ...options,
     from: 'H',
     to: 'C',
-    predictor,
     minLength,
     maxLength,
-    predictions,
-    predictOptions,
     joinDistance,
   });
 }