nmr-processing 7.1.0 → 7.2.0

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

@@ -0,0 +1,339 @@
+import treeSet from 'ml-tree-set';
+import { Values } from 'nmr-correlation';
+import { Molecule } from 'openchemlib';
+import { getConnectivityMatrix } from 'openchemlib-utils';
+
+import {
+  NMRSignal1D,
+  PredictCarbonOptions,
+  PredictProtonOptions,
+} from '../../..';
+import { predictCarbon } from '../../../prediction/predictCarbon';
+import { predictProton } from '../../../prediction/predictProton';
+import { MakeMandatory } from '../../../utilities/MakeMandatory';
+import { StoreAssignments } from '../buildAssignments';
+
+import { SpectraDataWithIds } from './checkIDs';
+import {
+  createMapPossibleAssignment,
+  MapPossibleAssignments,
+} from './createMapPossibleAssignment';
+import { AssignmentSolution, exploreTree } from './exploreTree';
+import { TargetsByAtomType } from './getTargetsAndCorrelations';
+import { isSpectraData1D } from './isSpectraData1D';
+import { searchIndices } from './searchIndices';
+
+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 = Array<AtomTypes>;
+export interface Partial {
+  [key: string]: Array<string | null>;
+}
+
+export interface DiaIDPeerPossibleAssignment {
+  [key: string]: string[];
+}
+
+export interface RestrictionByCS {
+  chemicalShiftRestriction: boolean;
+  tolerance: { [key: string]: number };
+  useChemicalShiftScore: boolean;
+}
+
+export interface BuildAssignmentInput {
+  spectra: SpectraDataWithIds[];
+  molecule: Molecule;
+  restrictionByCS: RestrictionByCS;
+  timeout: number;
+  minScore: number;
+  nbAllowedUnAssigned?: { [key: string]: number };
+  maxSolutions: number;
+  correlations: Values;
+  assignmentOrder: Array<Array<AtomTypes>>;
+  predictions: {
+    H?: NMRSignal1D[];
+    C?: NMRSignal1D[];
+  };
+  predictionOptions: {
+    H?: PredictProtonOptions;
+    C?: PredictCarbonOptions;
+  };
+  targets: TargetsByAtomType;
+}
+
+type NMRSignal1DFromPrediction = MakeMandatory<
+  NMRSignal1D,
+  'nbAtoms' | 'diaIDs' | 'atoms'
+>;
+
+function checkNMRSignal1D(
+  signals: NMRSignal1D[],
+): asserts signals is NMRSignal1DFromPrediction[] {
+  const keys: Array<'nbAtoms' | 'diaIDs' | 'atoms'> = [
+    'nbAtoms',
+    'diaIDs',
+    'atoms',
+  ];
+  for (const signal of signals) {
+    for (let key of keys) {
+      if (!signal[key]) throw new Error(`property ${key} does not exist`);
+    }
+  }
+}
+
+export interface Prediction extends NMRSignal1DFromPrediction {
+  diaIDIndex: number;
+  allHydrogens: number;
+  protonsCount: number;
+  pathLength: number[];
+}
+
+export interface Predictions {
+  [key: string]: Prediction;
+}
+
+export interface PredictionsByAtomType {
+  [key: string]: Predictions;
+}
+
+export interface InfoByAtomType {
+  [key: string]: {
+    nSources: number;
+    currentIndex: number;
+    nbAllowedUnAssigned: number;
+  };
+}
+
+export const getAllHydrogens = {
+  C: (m: Molecule, i: number) => m.getAllHydrogens(i),
+  H: () => 1,
+};
+
+export async function buildAssignments(props: BuildAssignmentInput) {
+  const {
+    spectra,
+    molecule,
+    restrictionByCS,
+    timeout,
+    minScore,
+    nbAllowedUnAssigned = {},
+    maxSolutions,
+    correlations,
+    assignmentOrder,
+    predictionOptions,
+    predictions: inputPrediction = {},
+    targets,
+  } = props;
+
+  let date = new Date();
+  let timeStart = date.getTime();
+  let lowerBoundScore = minScore;
+
+  let store: StoreAssignments = {
+    solutions: new treeSet(comparator),
+    nSolutions: 0,
+  };
+
+  const pathLengthMatrix = getConnectivityMatrix(molecule, {
+    pathLength: true,
+  });
+
+  let infoByAtomType: InfoByAtomType = {};
+  const predictions: PredictionsByAtomType = {};
+  let possibleAssignmentMap: MapPossibleAssignments = {};
+  let diaIDPeerPossibleAssignment: DiaIDPeerPossibleAssignment = {};
+
+  for (const atomTypesToPredict of assignmentOrder) {
+    for (const atomType of atomTypesToPredict) {
+      const options = predictionOptions[atomType];
+      const predictedSignals = inputPrediction[atomType];
+      let { joinedSignals } = predictedSignals
+        ? { joinedSignals: predictedSignals }
+        : await predictor[atomType](molecule, options);
+
+      checkNMRSignal1D(joinedSignals);
+
+      if (!predictions[atomType]) predictions[atomType] = {};
+      for (let prediction of joinedSignals) {
+        const diaID = prediction.diaIDs[0];
+        const index = prediction.atoms[0];
+        const allHydrogens = getAllHydrogens[atomType](molecule, index);
+        predictions[atomType][diaID] = {
+          ...prediction,
+          diaIDIndex: index,
+          allHydrogens: prediction.nbAtoms * allHydrogens,
+          protonsCount: allHydrogens,
+          pathLength: pathLengthMatrix[index] as number[],
+        };
+      }
+      infoByAtomType[atomType] = {
+        nSources: joinedSignals.length,
+        currentIndex: 0,
+        nbAllowedUnAssigned: nbAllowedUnAssigned[atomType] || 0,
+      };
+    }
+
+    possibleAssignmentMap = createMapPossibleAssignment(possibleAssignmentMap, {
+      restrictionByCS,
+      predictions,
+      targets,
+    });
+
+    diaIDPeerPossibleAssignment = {};
+    for (const atomType in possibleAssignmentMap) {
+      diaIDPeerPossibleAssignment[atomType] = Object.keys(
+        possibleAssignmentMap[atomType],
+      );
+    }
+
+    let sourceOfPartials = getSourceOfPartials(
+      store,
+      infoByAtomType,
+      atomTypesToPredict,
+    );
+
+    store = {
+      solutions: new treeSet(comparator),
+      nSolutions: 0,
+    };
+
+    for (let partial of sourceOfPartials) {
+      exploreTree(
+        {
+          currentAtomTypes: atomTypesToPredict,
+          restrictionByCS,
+          timeout,
+          timeStart,
+          targets,
+          predictions,
+          correlations,
+          maxSolutions,
+          lowerBoundScore,
+          possibleAssignmentMap,
+          diaIDPeerPossibleAssignment,
+        },
+        infoByAtomType,
+        partial,
+        store,
+      );
+    }
+  }
+  return annotateSpectraData({
+    store,
+    spectra,
+    diaIDPeerPossibleAssignment,
+    targets,
+  });
+}
+
+interface AnnotateSpectraDataInput {
+  store: StoreAssignments;
+  spectra: SpectraDataWithIds[];
+  targets: TargetsByAtomType;
+  diaIDPeerPossibleAssignment: DiaIDPeerPossibleAssignment;
+}
+
+function annotateSpectraData(input: AnnotateSpectraDataInput) {
+  const { store, spectra, diaIDPeerPossibleAssignment, targets } = input;
+  const { solutions } = store;
+  const mapSignalId: any = {};
+  const atomTypes = Object.keys(targets) as AtomTypes[];
+  for (const atomType of atomTypes) {
+    const targetByAtomType = targets[atomType];
+    for (const targetId in targetByAtomType) {
+      let target = targetByAtomType[targetId];
+      for (const link of target.link) {
+        const signalId = link.signal.id;
+        if (mapSignalId[signalId]) continue;
+        mapSignalId[link.signal.id] = searchIndices(signalId, spectra);
+      }
+    }
+  }
+
+  const result = [];
+  for (let solution of solutions.elements) {
+    const spectraResult = JSON.parse(
+      JSON.stringify(spectra),
+    ) as SpectraDataWithIds[];
+    const { assignment, score } = solution;
+    const atomTypes = Object.keys(assignment) as AtomTypes[];
+    for (const atomType of atomTypes) {
+      const targetByAtomType = targets[atomType];
+      const assignmentPeerAtomType = assignment[atomType];
+      for (let index = 0; index < assignmentPeerAtomType.length; index++) {
+        const targetID = assignmentPeerAtomType[index];
+
+        if (targetID === '*' || !targetID) continue;
+
+        const target = targetByAtomType[targetID];
+        const diaId = diaIDPeerPossibleAssignment[atomType][index];
+
+        for (let link of target.link) {
+          const { spectrumIndex, elementIndex, signalIndex } =
+            mapSignalId[link.signal.id];
+          const spectrum = spectraResult[spectrumIndex];
+
+          if (isSpectraData1D(spectrum)) {
+            let { ranges } = spectrum;
+            let range = ranges[elementIndex];
+            let signal = range.signals[signalIndex];
+            if (!signal.diaIDs) signal.diaIDs = [];
+            signal.diaIDs.push(diaId);
+          } else {
+            const axis = link.axis as 'x' | 'y';
+            const signal = spectrum.zones[elementIndex].signals[signalIndex];
+            if (!signal[axis].diaIDs) signal[axis].diaIDs = [];
+            signal[axis].diaIDs?.push(diaId);
+          }
+        }
+      }
+    }
+    result.push({
+      score,
+      assignment: spectraResult,
+    });
+  }
+  return result;
+}
+
+function getSourceOfPartials(
+  store: StoreAssignments,
+  infoByAtomType: InfoByAtomType,
+  currentAtoms: CurrentAtoms,
+) {
+  return store.nSolutions > 0
+    ? store.solutions.elements.map((e) => {
+        let currentAssignment = e.assignment;
+        for (const atom of currentAtoms) {
+          currentAssignment[atom] = fillPartial(infoByAtomType[atom].nSources);
+        }
+        return currentAssignment;
+      })
+    : initializePartials(infoByAtomType, currentAtoms);
+}
+
+function initializePartials(
+  infoByAtomType: InfoByAtomType,
+  currentAtoms: CurrentAtoms,
+) {
+  const partial: Partial = {};
+  const atomsType = Object.keys(infoByAtomType) as CurrentAtoms;
+  for (const atom of atomsType) {
+    const value = currentAtoms.includes(atom) ? null : '*';
+    partial[atom] = fillPartial(infoByAtomType[atom].nSources, value);
+  }
+  return [partial];
+}
+
+function fillPartial(nSources: number, value: string | null = null) {
+  const partial: Array<string | null> = new Array(nSources);
+  for (let i = 0; i < nSources; i++) {
+    partial[i] = value;
+  }
+  return partial;
+}

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;
+}