nmr-processing 10.0.4 → 10.0.6

package/src/prediction/predictCarbon.ts

@@ -1,4 +1,5 @@
-import { v4 as generateID } from '@lukeed/uuid';
+import { v4 } from '@lukeed/uuid';
+import { TopicMolecule } from 'openchemlib-utils';
 
 import { setIDs } from '../peaks/util/setIDs';
 import type { NMRSignal1D } from '../signals/NMRSignal1D';
@@ -8,10 +9,7 @@ import type { MakeMandatory } from '../utilities/MakeMandatory';
 import { PredictionBase1D } from './PredictionBase1D';
 import type { DataBaseStructure } from './dataStructure';
 import { fetchPrediction } from './utils/fetchPrediction';
-import { getFilteredIDiaIDs } from './utils/getFilteredIDiaIDs';
-import { isMolfileNotEmpty } from './utils/isMolfileNotEmpty';
 import { Prediction, queryByHose } from './utils/queryByHOSE';
-import { GroupedDiaID } from 'openchemlib-utils';
 
 export interface PredictCarbonOptions {
   /**
@@ -29,19 +27,6 @@ export interface PredictCarbonOptions {
    * @default 'maximum level in the database'
    */
   maxSphereSize?: number;
-  /**
-   * diastereotopic atom ids.
-   */
-  groupedDiaIDs: GroupedDiaID[];
-  /**
-   * 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;
@@ -63,19 +48,15 @@ function checkFromPrediction(
  */
 
 export async function predictCarbon(
-  options: PredictCarbonOptions,
+  topicMolecule: TopicMolecule,
+  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)) {
+  if (topicMolecule.molecule.getAllAtoms() === 0) {
     return {
       nucleus: '13C',
       joinedSignals: [],
@@ -85,7 +66,8 @@ export async function predictCarbon(
   }
 
   if (!database) {
-    throw new Error('There is not a database');
+    const molfile = topicMolecule.toMolfile();
+    return fetchPrediction(molfile, { webserviceURL });
   }
 
   const maxLevel = database.length - 1;
@@ -94,13 +76,17 @@ export async function predictCarbon(
 
   if (maxSphereSize > maxLevel) maxSphereSize = maxLevel;
 
-  const carbonDiaIDs = getFilteredIDiaIDs({
-    groupedDiaIDs,
-    hoses,
-  });
+  const hoseCodes = topicMolecule.hoseCodes;
+  const diaIDsWithInfo = topicMolecule.diaIDsAndInfo.map(
+    (entry: any, index: number) => ({
+      ...entry,
+      hoses: hoseCodes[index],
+    }),
+  );
 
-  const predictions = queryByHose(carbonDiaIDs, database, {
+  const predictions = queryByHose(diaIDsWithInfo, database, {
     maxSphereSize,
+    atomLabel: 'C',
   });
 
   const signals = formatSignals(predictions);
@@ -116,10 +102,10 @@ export async function predictCarbon(
 function formatSignals(predictions: Prediction[]) {
   const signals = [];
   for (const prediction of predictions) {
-    const { atoms, nbAtoms, delta, diaIDs, statistic } = prediction;
+    const { nbAtoms, atoms, delta, diaIDs, statistic } = prediction;
     const signal = {
-      id: generateID(),
-      delta: delta || NaN,
+      id: v4(),
+      delta: delta ?? NaN,
       atoms,
       diaIDs,
       multiplicity: 's',

package/src/prediction/predictHMBC.ts

@@ -1,6 +1,5 @@
-import type { Molecule } from 'openchemlib/full';
+import { TopicMolecule } from 'openchemlib-utils';
 
-import { GroupDiastereotopicAtomIDs } from './GroupDiastereotopicAtomIDs';
 import { PredictionBase1D } from './PredictionBase1D';
 import { predict2D } from './utils/predict2D';
 
@@ -36,19 +35,10 @@ export interface PredictHMBCOptions {
     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,
+  topicMolecule: TopicMolecule,
   options: PredictHMBCOptions,
 ) {
   const {
@@ -57,7 +47,7 @@ export async function predictHMBC(
     joinDistance = { H: 0.05, C: 0.5 },
   } = options;
 
-  return predict2D(molecule, {
+  return predict2D(topicMolecule, {
     ...options,
     from: 'H',
     to: 'C',

package/src/prediction/predictHSQC.ts

@@ -1,6 +1,5 @@
-import type { Molecule } from 'openchemlib/full';
+import { TopicMolecule } from 'openchemlib-utils';
 
-import { GroupDiastereotopicAtomIDs } from './GroupDiastereotopicAtomIDs';
 import { PredictionBase1D } from './PredictionBase1D';
 import { predict2D } from './utils/predict2D';
 
@@ -31,15 +30,6 @@ export interface PredictHSQCOptions {
     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
@@ -47,7 +37,7 @@ export interface PredictHSQCOptions {
  */
 
 export async function predictHSQC(
-  molecule: Molecule,
+  topicMolecule: TopicMolecule,
   options: PredictHSQCOptions,
 ) {
   const {
@@ -56,7 +46,7 @@ export async function predictHSQC(
     joinDistance = { H: 0.05, C: 0.5 },
   } = options;
 
-  return predict2D(molecule, {
+  return predict2D(topicMolecule, {
     ...options,
     from: 'H',
     to: 'C',

package/src/prediction/predictProton.ts

@@ -1,13 +1,13 @@
 import { v4 as generateID } from '@lukeed/uuid';
 import fetch from 'cross-fetch';
 import FormData from 'form-data';
+import { TopicMolecule } from 'openchemlib-utils';
 
 import type { NMRSignal1D } from '../signals/NMRSignal1D';
 import { signalsJoin } from '../signals/signalsJoin';
 import { signalsToRanges } from '../signals/signalsToRanges';
 
 import { PredictionBase1D } from './PredictionBase1D';
-import { isMolfileNotEmpty } from './utils/isMolfileNotEmpty';
 
 /**
  * Makes a prediction using proton.
@@ -19,23 +19,15 @@ export interface PredictProtonOptions {
    * A callback receiving a molfile and the result
    */
   cache?: (molfile: string, result?: string) => void | string | undefined;
-  /**
-   * diastereotopic atom ids.
-   */
-  diaIDs: string[];
-  /**
-   * distance matrix
-   */
-  distanceMatrix: number[][];
 }
 
 export type PredictProton = typeof predictProton;
 
 export async function predictProton(
-  molfile: string,
-  options: PredictProtonOptions,
+  topicMolecule: TopicMolecule,
+  options: PredictProtonOptions = {},
 ): Promise<PredictionBase1D> {
-  if (!isMolfileNotEmpty(molfile)) {
+  if (topicMolecule.molecule.getAllAtoms() === 0) {
     return {
       nucleus: '1H',
       joinedSignals: [],
@@ -47,11 +39,11 @@ export async function predictProton(
 
   let result;
   if (cache) {
-    result = cache(molfile);
+    result = cache(topicMolecule.idCode);
   }
   if (result === undefined) {
     const formData = new FormData();
-    formData.append('molfile', molfile);
+    formData.append('molfile', topicMolecule.toMolfile());
     const response = await fetch('https://www.nmrdb.org/service/predictor', {
       method: 'POST',
       // @ts-expect-error RequestInit type does not include FormData.
@@ -59,12 +51,11 @@ export async function predictProton(
     });
     result = await response.text();
     if (cache) {
-      cache(molfile, result);
+      cache(topicMolecule.idCode, result);
     }
   }
 
-  const { diaIDs, distanceMatrix } = options;
-  const signals = protonParser(result, { diaIDs, distanceMatrix });
+  const signals = protonParser(result, topicMolecule);
   const joinedSignals = signalsJoin(signals);
   return {
     nucleus: '1H',
@@ -76,12 +67,13 @@ export async function predictProton(
 
 function protonParser(
   result: string,
-  options: { diaIDs: string[]; distanceMatrix: number[][] },
+  topicMolecule: TopicMolecule,
 ): NMRSignal1D[] {
   if (result.includes('ERR')) {
     throw Error(`Spinus optimization: ${result}`);
   }
-  const { diaIDs, distanceMatrix } = options;
+  const diaIDs = topicMolecule.diaIDs;
+  const distanceMatrix = topicMolecule.distanceMatrix;
   const lines = result.split('\n').filter((line) => line);
   const signals = [];
   for (const line of lines) {

package/src/prediction/predictSpectra.ts

@@ -1,4 +1,4 @@
-import { FromTo, PointXY } from 'cheminfo-types';
+import { FromTo, Logger, PointXY } from 'cheminfo-types';
 import type { Molecule } from 'openchemlib/full';
 
 import { signals2DToZ } from '../signals/signals2DToZ';
@@ -31,26 +31,29 @@ interface SimulationOptions {
   twoD?: Partial<TwoDOptions>;
 }
 interface PredictAllSpectraOptions {
+  logger?: Logger;
   prediction?: PredictAllOptions;
   simulation?: SimulationOptions;
 }
 
-export async function predictAllSpectra(
+export async function predictSpectra(
   molecule: Molecule,
   options: PredictAllSpectraOptions = {},
 ) {
   const {
+    logger,
     simulation: simulationOptions = { oneD: {}, twoD: {} } as SimulationOptions,
-    prediction: predictionOptions = {},
+    prediction: predictOptions = {},
   } = options;
 
-  const { spectra } = await predict(molecule, predictionOptions);
+  const { spectra } = await predict(molecule, { logger, ...predictOptions });
 
   const oneDOptions: OneDOptions = {
     ...{
       proton: { from: 0, to: 14 },
       carbon: { from: 0, to: 200 },
       nbPoints: 65536,
+      frequency: 400,
       lineWidth: 1,
     },
     ...(simulationOptions.oneD || {}),
@@ -65,6 +68,11 @@ export async function predictAllSpectra(
     ...(simulationOptions.twoD || {}),
   };
 
+  if (!('frequency' in simulationOptions) && logger) {
+    logger.warn(`Frequency is settled to 400 MHz`);
+  }
+  const { frequency = 400 } = simulationOptions;
+
   const newSpectra: any[] = [];
   for (const experiment in spectra) {
     switch (experiment) {
@@ -76,7 +84,7 @@ export async function predictAllSpectra(
             lineWidth: oneDOptions.lineWidth,
             ...oneDOptions[experiment],
             experiment,
-            frequency: simulationOptions.frequency,
+            frequency,
           }),
         );
         break;
@@ -88,7 +96,7 @@ export async function predictAllSpectra(
           get2DSpectrum(spectra[experiment], {
             ...twoDOptions,
             experiment,
-            frequency: simulationOptions.frequency,
+            frequency,
           }),
         );
         break;

package/src/prediction/utils/predict2D.ts

@@ -2,6 +2,7 @@ import { v4 as generateID } from '@lukeed/uuid';
 import { agnes, Cluster } from 'ml-hclust';
 import { Matrix } from 'ml-matrix';
 import { Molecule } from 'openchemlib/full';
+import { TopicMolecule } from 'openchemlib-utils';
 
 import { setIDs } from '../../peaks/util/setIDs';
 import type { NMRSignal1D } from '../../signals/NMRSignal1D';
@@ -70,15 +71,6 @@ export interface Predict2DOptions {
    * @default false
    */
   includeDiagonal?: boolean;
-  /**
-   * diastereotopic atom ids of the molecule.
-   */
-  diaIDs: string[];
-  /**
-   * grouped diastereotopic atom ids of the molecule.
-   */
-  groupedDiaIDs: GroupDiastereotopicAtomIDs[];
-  distanceMatrix: number[][];
 }
 
 export interface PredictOptions {
@@ -108,34 +100,30 @@ function checkFromTo(
 
 type Signal1DByDiaID = Record<string, Record<string, NMRSignal1D>>;
 
-export async function predict2D(molecule: Molecule, options: Predict2DOptions) {
+export async function predict2D(
+  topicMolecule: TopicMolecule,
+  options: Predict2DOptions,
+) {
   checkFromTo(options);
 
-  molecule.addImplicitHydrogens();
-
   const {
     from,
     to,
-    diaIDs,
-    groupedDiaIDs,
     minLength = 0,
     maxLength,
     predictions,
-    distanceMatrix,
     joinDistance = { H: 0.05, C: 0.5 },
     includeDiagonal = false,
   } = options;
 
-  const pathsInfo = getPossibleCorrelations({
-    molecule,
+  const pathsInfo = getPossibleCorrelations(topicMolecule, {
     fromLabel: from,
     toLabel: to,
-    diaIDs,
-    distanceMatrix,
     minLength,
     maxLength,
   });
 
+  const groupedDiaIDs = topicMolecule.getGroupedDiastereotopicAtomIDs();
   const diaIDswithAtomInfo: GroupDiastereotopicAtomIDsWithAtomInfo[] = [];
   for (const diaID of groupedDiaIDs) {
     diaIDswithAtomInfo.push({
@@ -223,16 +211,12 @@ interface AtomPartialPathInfo {
   oclID: string;
   paths: Array<{ from: number; to: number }>;
 }
-function getPossibleCorrelations(options: any) {
-  const {
-    fromLabel,
-    toLabel,
-    distanceMatrix,
-    molecule,
-    diaIDs,
-    minLength,
-    maxLength,
-  } = options;
+function getPossibleCorrelations(topicMolecule: TopicMolecule, options: any) {
+  const { fromLabel, toLabel, minLength, maxLength } = options;
+
+  const diaIDs = topicMolecule.diaIDs;
+  const molecule = topicMolecule.moleculeWithH;
+  const distanceMatrix = topicMolecule.distanceMatrix;
   const fromAtomicNumber = Molecule.getAtomicNoFromLabel(fromLabel);
   const toAtomicNumber = Molecule.getAtomicNoFromLabel(toLabel);
   const atomPathInfo: AtomPartialPathInfo[] = [];

package/src/prediction/utils/queryByHOSE.ts

@@ -17,43 +17,44 @@ export interface Prediction {
   };
 }
 export function queryByHose(
-  diaIDs: any,
+  diaIDsWithInfo: any,
   db: DataBaseStructure,
-  options: { maxSphereSize: number },
+  options: { maxSphereSize: number; atomLabel: string },
 ): Prediction[] {
-  const { maxSphereSize } = options;
+  const { maxSphereSize, atomLabel } = options;
+
+  const results = [];
+  for (let i = 0; i < diaIDsWithInfo.length; i++) {
+    const entry = diaIDsWithInfo[i];
+    if (atomLabel && entry.atomLabel !== atomLabel) continue;
 
-  const toReturn = [];
-  for (const element of diaIDs) {
     let res;
     let level = null;
-    for (let k = maxSphereSize; !res && k >= 0; k--) {
-      if (db[k]) {
-        res = db[k][element.hose[k]];
+    for (let k = maxSphereSize; k >= 0; k--) {
+      if (db[k]?.[entry.hoses[k]]) {
+        res = db[k][entry.hoses[k]];
         level = k;
+        break;
       }
     }
-
-    for (const atomNumber of element.atoms) {
-      const atom = {
-        diaIDs: [element.oclID],
-        delta: res ? res[0] : null,
-        atoms: [atomNumber],
-        nbAtoms: 1,
-        level,
-        statistic:
-          res && res.length > 1
-            ? {
-                mean: res[1],
-                sd: res[2],
-                min: res[3],
-                max: res[4],
-                nb: res[5],
-              }
-            : undefined,
-      };
-      toReturn.push(atom);
-    }
+    const result = {
+      diaIDs: [entry.idCode],
+      delta: res ? res[0] : null,
+      atoms: [i],
+      nbAtoms: 1,
+      level,
+      statistic:
+        res && res.length > 1 // only if DB contains statistics
+          ? {
+              mean: res[1],
+              sd: res[2],
+              min: res[3],
+              max: res[4],
+              nb: res[5],
+            }
+          : undefined,
+    };
+    results.push(result);
   }
-  return toReturn;
+  return results;
 }

package/src/ranges/rangesToACS.ts

@@ -1,4 +1,5 @@
 import { isAnyArray } from 'is-any-array';
+
 import { signalJoinCouplings } from '../signal/signalJoinCouplings';
 import { signalMultiplicityPattern } from '../signal/signalMultiplicityPattern';
 import type { NMRSignal1D } from '../signals/NMRSignal1D';

package/src/xyz/xyzAutoSignalsPicking.ts

@@ -1,5 +1,6 @@
 import { v4 as generateID } from '@lukeed/uuid';
 import { NmrData2DContent } from 'cheminfo-types';
+import { isAnyArray } from 'is-any-array';
 import * as convolution from 'ml-matrix-convolution';
 import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
 import type { Peak2D } from 'ml-matrix-peaks-finder';
@@ -14,7 +15,6 @@ import { MakeMandatory } from '../utilities/MakeMandatory';
 
 import type { NMRSignal2D } from './NMRSignal2D';
 import { padData } from './util/padData';
-import { isAnyArray } from 'is-any-array';
 
 const smallFilter = [
   [0, 0, 1, 2, 2, 2, 1, 0, 0],
@@ -108,7 +108,7 @@ export function xyzAutoSignalsPicking(
 
   let { thresholdFactor = 0.5 } = options;
 
-  if (isAnyArray(observedFrequencies)) {
+  if (!isAnyArray(observedFrequencies)) {
     throw new Error('observedFrequencies is mandatory');
   }