nmr-processing 7.4.1 → 8.0.0

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

@@ -11,9 +11,9 @@ import {
 import { predictCarbon } from '../../../prediction/predictCarbon';
 import { predictProton } from '../../../prediction/predictProton';
 import { MakeMandatory } from '../../../utilities/MakeMandatory';
+import { SpectraDataWithIds } from '../../nmrAssigment';
 import { StoreAssignments } from '../buildAssignments';
 
-import { SpectraDataWithIds } from './checkIDs';
 import {
   createMapPossibleAssignment,
   MapPossibleAssignments,
@@ -159,10 +159,13 @@ export async function buildAssignments(props: BuildAssignmentInput) {
       checkNMRSignal1D(joinedSignals);
 
       if (!predictions[atomType]) predictions[atomType] = {};
+
+      let totalHydrogens = 0;
       for (let prediction of joinedSignals) {
         const diaID = prediction.diaIDs[0];
         const index = prediction.atoms[0];
         const allHydrogens = getAllHydrogens[atomType](molecule, index);
+        totalHydrogens += prediction.nbAtoms * allHydrogens;
         predictions[atomType][diaID] = {
           ...prediction,
           diaIDIndex: index,
@@ -171,6 +174,9 @@ export async function buildAssignments(props: BuildAssignmentInput) {
           pathLength: pathLengthMatrix[index] as number[],
         };
       }
+      for (let diaID in predictions[atomType]) {
+        predictions[atomType][diaID].allHydrogens *= 100 / totalHydrogens;
+      }
       infoByAtomType[atomType] = {
         nSources: joinedSignals.length,
         currentIndex: 0,

package/src/assignment/utils/getAssignment/checkIDs.ts

@@ -1,50 +1,28 @@
-import type { NMRRange, NMRSignal1D, NMRSignal2D, NMRZone } from '../../..';
-import { MakeMandatory } from '../../../utilities/MakeMandatory';
+import type { NMRRange, NMRZone } from '../../..';
+import type { SpectraData } from '../../getAssignments';
 import type {
-  SpectraData,
-  SpectraData1D,
-  SpectraData2D,
-} from '../../getAssignments';
+  SpectraDataWithIds,
+  NMRRangeWithIds,
+  NMRZoneWithIds,
+} from '../../nmrAssigment';
 import generateID from '../generateID';
 
 import { isSpectraData1D } from './isSpectraData1D';
 
-export type NMRSignal1DWithId = MakeMandatory<NMRSignal1D, 'id'>;
-export type NMRSignal2DWithId = MakeMandatory<NMRSignal2D, 'id'>;
-
-export interface NMRZoneWithIds extends Omit<NMRZone, 'signals' | 'id'> {
-  id: string;
-  signals: Array<NMRSignal2DWithId>;
-}
-
-export interface NMRRangeWithIds extends Omit<NMRRange, 'id' | 'signals'> {
-  id: string;
-  signals: Array<NMRSignal1DWithId>;
-}
-
-export interface SpectraData1DWithIds extends Omit<SpectraData1D, 'ranges'> {
-  ranges: NMRRangeWithIds[];
-}
-export interface SpectraData2DWithIds extends Omit<SpectraData2D, 'zones'> {
-  zones: NMRZoneWithIds[];
-}
-
-export type SpectraDataWithIds = SpectraData1DWithIds | SpectraData2DWithIds;
-
 export function checkIDs(input: SpectraData[] = []): SpectraDataWithIds[] {
   let inputClone = JSON.parse(JSON.stringify(input)) as SpectraData[];
   let spectra: SpectraDataWithIds[] = [];
   for (const spectraData of inputClone) {
+    if (!('info' in spectraData)) {
+      throw new Error(
+        'each spectrum should contain info properties with nucleus information',
+      );
+    }
+
     const { info, id } = spectraData;
     if (isSpectraData1D(spectraData)) {
-      let data = addIDs(spectraData.ranges) as NMRRangeWithIds[];
-      for (const element of data) {
-        const { integration } = element;
-        for (let signal of element.signals || []) {
-          if (!signal.integration) signal.integration = integration;
-        }
-      }
-      spectra.push({ id, info, ranges: data });
+      let ranges = addIDs(spectraData.ranges) as NMRRangeWithIds[];
+      spectra.push({ id, info, ranges });
     } else {
       let data = addIDs(spectraData.zones) as NMRZoneWithIds[];
       spectra.push({ id, info, zones: data });

package/src/assignment/utils/getAssignment/formatData.ts

@@ -4,7 +4,8 @@ import {
   SpectraData1DWithIds,
   SpectraData2DWithIds,
   SpectraDataWithIds,
-} from './checkIDs';
+} from '../../nmrAssigment';
+
 import { isSpectraData1D } from './isSpectraData1D';
 
 interface SpectraData1DFormatted extends Omit<SpectraData1DWithIds, 'ranges'> {
@@ -24,12 +25,48 @@ export function formatData(
   let inputClone = JSON.parse(JSON.stringify(input)) as SpectraDataWithIds[];
   let spectra: SpectraDataFormatted[] = [];
   for (const spectraData of inputClone) {
-    const { info } = spectraData;
+    const { id, info } = spectraData;
     if (isSpectraData1D(spectraData)) {
-      spectra.push({ info, ranges: { values: spectraData.ranges } });
+      const ranges = rescaleIntegration({
+        id,
+        info,
+        ranges: spectraData.ranges,
+      });
+      spectra.push({ id, info, ranges: { values: ranges } });
     } else {
-      spectra.push({ info, zones: { values: spectraData.zones } });
+      spectra.push({ id, info, zones: { values: spectraData.zones } });
     }
   }
   return spectra;
 }
+
+function rescaleIntegration(spectrum: SpectraData1DWithIds): NMRRangeWithIds[] {
+  if (spectrum.info.nucleus !== '1H') return spectrum.ranges;
+
+  let totalIntegration = spectrum.ranges.reduce(
+    (total, range) => (range.integration ? total + range.integration : total),
+    0,
+  );
+
+  for (let range of spectrum.ranges) {
+    if (range.integration) {
+      range.integration *= 100 / totalIntegration;
+      if (range.signals) {
+        const totalSignalIntegration = range.signals.reduce(
+          (total, signal) =>
+            signal.integration ? total + signal.integration : total,
+          0,
+        );
+        for (let signal of range.signals) {
+          if (signal.integration) {
+            signal.integration *= range.integration / totalSignalIntegration;
+          } else {
+            signal.integration = range.integration;
+          }
+        }
+      }
+    }
+  }
+
+  return spectrum.ranges;
+}

package/src/assignment/utils/getAssignment/getTargetsAndCorrelations.ts

@@ -1,7 +1,8 @@
 import { buildCorrelationData } from 'nmr-correlation';
 import type { Correlation, Link } from 'nmr-correlation';
 
-import { SpectraDataWithIds } from './checkIDs';
+import { SpectraDataWithIds } from '../../nmrAssigment';
+
 import { formatData } from './formatData';
 import { getIntegrationOfAttachedProtons } from './getIntegrationOfAttachedProtons';
 

package/src/assignment/utils/getAssignment/partialScore.ts

@@ -114,9 +114,9 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
       }
     }
   }
+
   for (const group of targetByIntegral) {
     const { integration, atomType } = group;
-
     if (integration === undefined || isNaN(integration)) continue;
 
     let total = 0;
@@ -128,7 +128,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
         if (atomType === atomOfPrediction) total += prediction.allHydrogens;
       }
     }
-    if (total - integration >= 0.5) {
+    if (total - integration >= 5) {
       return 0;
     }
   }

package/src/databases/getDatabase.ts

@@ -6,16 +6,33 @@ import { DatabaseNMREntry } from './DatabaseNMREntry';
 
 export async function getDatabase(
   url = 'https://docs.google.com/spreadsheets/d/1uwyq_L38PMRWCcT4If_EhPbHKyY3q_2tpjV8vr5_zh0/edit?usp=sharing',
+  options: {
+    /**
+     * @default 'tsv'
+     */
+    format?: 'tsv' | 'json';
+  } = {},
 ) {
+  const { format = 'tsv' } = options;
+
   if (url.includes('google.com')) {
     url = `https://googledocs.cheminfo.org/spreadsheets/d/${extractGoogleUUID(
       url,
     )}/export?format=tsv`;
   }
 
+  let parsed;
   const response = await fetch(url);
-  const result = await response.text();
-  const parsed = parseData(result);
+  switch (format) {
+    case 'tsv':
+      parsed = parseData(await response.text());
+      break;
+    case 'json':
+      parsed = await response.json();
+      break;
+    default:
+      throw new Error('unknown database format');
+  }
 
   const results = [];
 

package/src/index.ts

@@ -38,13 +38,21 @@ export * from './databases/carbonImpurities';
 export * from './databases/protonImpurities';
 
 export type { NMRSignal1D } from './signals/NMRSignal1D';
-export type { NMRSignal2D } from './xyz/NMRSignal2D';
+export type { NMRSignal2D, Signal2DProjection } from './xyz/NMRSignal2D';
 export type { NMRRange } from './xy/NMRRange';
 export type { NMRZone } from './xyz/NMRZone';
 export type { NMRPeak1D } from './peaks/NMRPeak1D';
 export type { Prediction1D } from './prediction/prediction1D';
 export type { Jcoupling } from './signals/jcoupling';
+export type { DatabaseNMREntry } from './databases/DatabaseNMREntry';
 export type {
   DataBaseLevelStructure,
   DataBaseStructure,
 } from './prediction/dataStructure';
+export type {
+  NMRSignal1DWithId,
+  NMRSignal2DWithId,
+  SpectraData1DWithIds,
+  SpectraData2DWithIds,
+  SpectraDataWithIds,
+} from './assignment/nmrAssigment';

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/xyz/NMRSignal2D.ts

@@ -1,7 +1,7 @@
 import type { FromTo } from 'cheminfo-types';
 import type { Peak2D } from 'ml-matrix-peaks-finder';
 
-export interface Signal2DAxisData {
+export interface Signal2DProjection {
   nucleus?: string;
   delta: number;
   resolution?: number;
@@ -9,8 +9,8 @@ export interface Signal2DAxisData {
   diaIDs?: string[];
 }
 export interface NMRSignal2D {
-  x: Signal2DAxisData;
-  y: Signal2DAxisData;
+  x: Signal2DProjection;
+  y: Signal2DProjection;
   j?: {
     pathLength?: number | FromTo;
   };