nmr-processing 7.1.0 → 7.4.0

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

@@ -0,0 +1,76 @@
+import type { NMRRange, NMRSignal1D, NMRSignal2D, NMRZone } from '../../..';
+import { MakeMandatory } from '../../../utilities/MakeMandatory';
+import type {
+  SpectraData,
+  SpectraData1D,
+  SpectraData2D,
+} from '../../getAssignments';
+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) {
+    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 });
+    } else {
+      let data = addIDs(spectraData.zones) as NMRZoneWithIds[];
+      spectra.push({ id, info, zones: data });
+    }
+  }
+  return spectra;
+}
+
+export function hasIDs(
+  data: NMRRange[] | NMRZone[],
+): asserts data is NMRRangeWithIds[] | NMRZoneWithIds[] {
+  for (const element of data) {
+    if (!element.id) throw new Error('A range/zone has not an ID');
+    for (let signal of element.signals || []) {
+      if (!signal.id) throw new Error('A signal has not an ID');
+    }
+  }
+}
+
+export function addIDs(data: NMRRange[] | NMRZone[]) {
+  for (const element of data) {
+    if (!element.id) element.id = generateID();
+    for (let signal of element.signals || []) {
+      if (!signal.id) signal.id = generateID();
+    }
+  }
+  hasIDs(data);
+  return data;
+}

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

@@ -0,0 +1,85 @@
+import { getCorrelationDelta } from 'nmr-correlation';
+
+import { PossibleAssignmentMap } from '../createMapPossibleAssignments';
+
+import {
+  AtomTypes,
+  PredictionsByAtomType,
+  RestrictionByCS,
+} from './buildAssignments';
+import { TargetsByAtomType } from './getTargetsAndCorrelations';
+
+export interface PossibleAssignments {
+  [key: string]: string[];
+}
+export interface MapPossibleAssignments {
+  [key: string]: PossibleAssignmentMap;
+}
+export interface CreateMapPossibleAssignmentOptions {
+  restrictionByCS: RestrictionByCS;
+  predictions: PredictionsByAtomType;
+  targets: TargetsByAtomType;
+}
+export function createMapPossibleAssignment(
+  expandMap: MapPossibleAssignments,
+  props: CreateMapPossibleAssignmentOptions,
+) {
+  const { restrictionByCS, predictions, targets } = props;
+
+  const { tolerance: toleranceCS, chemicalShiftRestriction } = restrictionByCS;
+
+  const atomTypes = Object.keys(predictions) as AtomTypes[];
+
+  for (const atomType of atomTypes) {
+    let errorAbs = toleranceCS[atomType];
+    let predictionByAtomType = predictions[atomType];
+    let targetByAtomType = targets[atomType];
+    if (!expandMap[atomType]) expandMap[atomType] = {};
+    for (const diaID in predictionByAtomType) {
+      let prediction = predictionByAtomType[diaID];
+      expandMap[atomType][diaID] = [];
+
+      if (targetByAtomType) {
+        for (const targetID in targetByAtomType) {
+          let target = targetByAtomType[targetID];
+          const { nbAtoms, protonsCount: protonsCountFromPrediction } =
+            prediction;
+          const { integration, protonsCount } = target;
+
+          const couldBeAssigned = !integration
+            ? true
+            : atomType === 'H'
+            ? nbAtoms - integration < 1
+            : protonsCount.length > 0
+            ? protonsCount.some(
+                (count: number) => protonsCountFromPrediction === count,
+              )
+            : true;
+          if (couldBeAssigned) {
+            if (
+              !chemicalShiftRestriction ||
+              typeof prediction.delta === 'undefined'
+            ) {
+              // Chemical shift is not a restriction
+              expandMap[atomType][diaID].push(targetID);
+            } else {
+              let targetDelta = getCorrelationDelta(target);
+              if (targetDelta === undefined) {
+                throw new Error(`Correlation has not delta`);
+              }
+              let distAfterLimit = Math.abs(
+                prediction.delta - targetDelta - errorAbs,
+              );
+
+              if (distAfterLimit < 4 * errorAbs) {
+                expandMap[atomType][diaID].push(targetID);
+              }
+            }
+          }
+        }
+      }
+      expandMap[atomType][diaID].push('*');
+    }
+  }
+  return expandMap;
+}