nmr-processing 3.3.4 → 5.0.0

package/src/assignment/get1HAssignments.ts

@@ -0,0 +1,116 @@
+import { Molecule } from 'openchemlib';
+import { addDiastereotopicMissingChirality } from 'openchemlib-utils';
+
+import { NMRRange } from '..';
+import {
+  predictProton,
+  PredictProtonOptions,
+} from '../prediction/predictProton';
+import { MakeMandatory } from '../types/MakeMandatory';
+import type { NMRSignal1D } from '../types/NMRSignal1D';
+
+import { buildAssignments, RestrictionByCS } from './utils/buildAssignments';
+import generateID from './utils/generateID';
+
+export type NMRSignal1DWithAtomsAndDiaIDs = MakeMandatory<
+  NMRSignal1D,
+  'atoms' | 'diaIDs' | 'nbAtoms'
+>;
+
+function checkAtomsAndDiaIDs(
+  signals: NMRSignal1D[],
+): asserts signals is NMRSignal1DWithAtomsAndDiaIDs[] {
+  for (const signal of signals) {
+    if (!signal.atoms) throw new Error('signal has not atoms property');
+    if (!signal.diaIDs) throw new Error('signal has not diaIDs property');
+    if (!signal.nbAtoms) throw new Error('signal has not nbAtoms property');
+  }
+}
+
+export type NMRRangeWithIntegration = MakeMandatory<NMRRange, 'integration'>;
+
+function checkForIntegration(
+  ranges: NMRRange[],
+): asserts ranges is NMRRangeWithIntegration[] {
+  for (let range of ranges) {
+    if (range.integration === undefined) {
+      throw new Error('ranges has not integration property');
+    }
+  }
+}
+
+export interface Get1HAssignmentsOptions {
+  restrictionByCS?: Partial<RestrictionByCS>;
+  /**
+   * min score to accept an assignment
+   * @default 1
+   */
+  minScore?: number;
+  /**
+   * maximal number of assignments to return
+   * @default 10
+   */
+  maxSolutions?: number;
+  /**
+   * number of allowed unassignment signals
+   * @default 0
+   */
+  nbAllowedUnAssigned?: number;
+  /**
+   * time limit in miliseconds to finish the assignment procedure.
+   * @default 6000
+   */
+  timeout?: number;
+  /**
+   * prediction options
+   */
+  predictionOptions?: PredictProtonOptions;
+}
+
+export interface Targets {
+  [key: string]: NMRRangeWithIntegration;
+}
+
+export async function get1HAssignments(
+  ranges: NMRRange[],
+  molecule: Molecule,
+  options: Get1HAssignmentsOptions = {},
+) {
+  let {
+    restrictionByCS,
+    minScore = 1,
+    maxSolutions = 10,
+    nbAllowedUnAssigned = 0,
+    timeout = 6000,
+    predictionOptions = {},
+  } = options;
+
+  if (!molecule) {
+    throw new Error('It is needed a OCL molecule instance to assign');
+  }
+
+  molecule.addImplicitHydrogens();
+  addDiastereotopicMissingChirality(molecule);
+
+  const { joinedSignals } = await predictProton(molecule, predictionOptions);
+
+  checkForIntegration(ranges);
+  checkAtomsAndDiaIDs(joinedSignals);
+
+  const targets: Targets = {};
+  for (const range of ranges) {
+    const { id = generateID() } = range;
+    targets[id] = JSON.parse(JSON.stringify(range));
+  }
+
+  return buildAssignments({
+    restrictionByCS,
+    timeout,
+    minScore,
+    nbAllowedUnAssigned,
+    maxSolutions,
+    targets,
+    joinedSignals,
+    useIntegrationRestriction: true,
+  });
+}

package/src/assignment/utils/buildAssignments.ts

@@ -0,0 +1,155 @@
+import treeSet from 'ml-tree-set';
+
+import {
+  Targets,
+  NMRSignal1DWithAtomsAndDiaIDs,
+} from '../get1HAssignments';
+
+import { createMapPossibleAssignments } from './createMapPossibleAssignments';
+import { exploreTreeRec } from './exploreTreeRec';
+import type { SolutionAssignment } from './exploreTreeRec';
+
+const comparator = (a: SolutionAssignment, b: SolutionAssignment) => {
+  return b.score - a.score;
+};
+
+export interface RestrictionByCS {
+  chemicalShiftRestriction: boolean;
+  tolerance: number;
+  useChemicalShiftScore: boolean;
+}
+
+export interface BuildAssignmentsProps {
+  restrictionByCS?: Partial<RestrictionByCS>;
+  timeout: number;
+  minScore: number;
+  useIntegrationRestriction: boolean;
+  nbAllowedUnAssigned: number;
+  maxSolutions: number;
+  targets: Targets;
+  joinedSignals: NMRSignal1DWithAtomsAndDiaIDs[];
+}
+
+export interface Signals1DAssignment extends NMRSignal1DWithAtomsAndDiaIDs {
+  diaIDIndex: number;
+  allHydrogens: number;
+  error?: number;
+}
+
+export interface Predictions1Dassignments {
+  [key: string]: Signals1DAssignment;
+}
+
+export interface StoreAssignments1D {
+  solutions: treeSet;
+  nSolutions: number;
+}
+
+export async function buildAssignments(props: BuildAssignmentsProps) {
+  const {
+    restrictionByCS = {},
+    useIntegrationRestriction,
+    timeout,
+    minScore,
+    nbAllowedUnAssigned,
+    maxSolutions,
+    targets,
+    joinedSignals,
+  } = props;
+
+  const {
+    tolerance = 1,
+    useChemicalShiftScore = false,
+    chemicalShiftRestriction = true,
+  } = restrictionByCS;
+
+  let date = new Date();
+  let timeStart = date.getTime();
+
+  let store: StoreAssignments1D = {
+    solutions: new treeSet(comparator),
+    nSolutions: 0,
+  };
+
+  let nSources = joinedSignals.length;
+  const predictions: Predictions1Dassignments = {};
+
+  for (let prediction of joinedSignals) {
+    const diaID = prediction.diaIDs[0];
+    const index = prediction.atoms[0];
+    predictions[diaID] = {
+      ...prediction,
+      diaIDIndex: index,
+      allHydrogens: prediction.nbAtoms,
+    };
+  }
+
+  const possibleAssignmentMap = createMapPossibleAssignments({
+    restrictionByCS: {
+      tolerance,
+      useChemicalShiftScore,
+      chemicalShiftRestriction,
+    },
+    useIntegrationRestriction,
+    predictions,
+    targets,
+  });
+
+  const diaIDPeerPossibleAssignment = Object.keys(possibleAssignmentMap);
+
+  let partial = fillPartial(nSources);
+
+  store = {
+    solutions: new treeSet(comparator),
+    nSolutions: 0,
+  };
+
+  exploreTreeRec(
+    {
+      nSources,
+      restrictionByCS: {
+        tolerance,
+        useChemicalShiftScore,
+        chemicalShiftRestriction,
+      },
+      timeout,
+      timeStart,
+      targets,
+      predictions,
+      maxSolutions,
+      lowerBoundScore: minScore,
+      nbAllowedUnAssigned,
+      possibleAssignmentMap,
+      diaIDPeerPossibleAssignment,
+      useIntegrationRestriction,
+    },
+    0,
+    partial,
+    store,
+  );
+
+  const assignments = [];
+  for (const solution of store.solutions.elements) {
+    const { assignment, score } = solution;
+    const currentAssignment = JSON.parse(JSON.stringify(targets));
+    for (let i = 0; i < assignment.length; i++) {
+      let range = currentAssignment[assignment[i]];
+      if (!range.diaIDs) range.diaIDs = [];
+      if (assignment[i]) range.diaIDs.push(diaIDPeerPossibleAssignment[i]);
+    }
+    assignments.push({
+      score,
+      assignment: Object.values(currentAssignment),
+    });
+  }
+
+  return assignments;
+}
+
+function fillPartial(nSources: number, value = null) {
+  const partial = new Array(nSources);
+  for (let i = 0; i < nSources; i++) {
+    partial[i] = value;
+  }
+  return partial;
+}

package/src/assignment/utils/createMapPossibleAssignments.ts

@@ -0,0 +1,76 @@
+import { MakeMandatory } from '../../types/MakeMandatory';
+import type { Targets } from '../get1HAssignments';
+
+import type { RestrictionByCS, Predictions1Dassignments } from './buildAssignments';
+
+type RestrictionByCSMandatory = MakeMandatory<
+  RestrictionByCS,
+  'chemicalShiftRestriction' | 'tolerance' | 'useChemicalShiftScore'
+>;
+
+interface CreateMapPossibleAssignments {
+  predictions: Predictions1Dassignments;
+  restrictionByCS: RestrictionByCSMandatory;
+  targets: Targets;
+  useIntegrationRestriction: boolean;
+}
+
+export interface PossibleAssignmentMap {
+  [key: string]: string[];
+}
+export function createMapPossibleAssignments(
+  props: CreateMapPossibleAssignments,
+) {
+  const { restrictionByCS, predictions, targets, useIntegrationRestriction } =
+    props;
+
+  const { tolerance: toleranceCS, chemicalShiftRestriction } = restrictionByCS;
+
+  let errorAbs = Math.abs(toleranceCS);
+  const expandMap: PossibleAssignmentMap = {};
+  for (const diaID in predictions) {
+    let prediction = predictions[diaID];
+    if (prediction.error) prediction.error = Math.abs(prediction.error);
+    expandMap[diaID] = [];
+
+    if (targets) {
+      for (const targetID in targets) {
+        let target = targets[targetID];
+        const { nbAtoms } = prediction;
+        const { integration } = target;
+
+        const couldBeAssigned = useIntegrationRestriction
+          ? integration > 0
+            ? nbAtoms - integration < 1
+            : true
+          : true;
+
+        if (couldBeAssigned) {
+          if (
+            !chemicalShiftRestriction ||
+            typeof prediction.delta === 'undefined'
+          ) {
+            // Chemical shift is not a restriction
+            expandMap[diaID].push(targetID);
+          } else {
+            let error = errorAbs;
+            if (prediction.error) {
+              error = Math.max(error, prediction.error);
+            }
+            const delta =
+              target.signals && target.signals.length > 0
+                ? target.signals[0].delta
+                : (target.to + target.from) / 2;
+
+            let distAfterLimit = Math.abs(prediction.delta - delta - errorAbs);
+            if (distAfterLimit < 4 * errorAbs) {
+              expandMap[diaID].push(targetID);
+            }
+          }
+        }
+      }
+    }
+    expandMap[diaID].push('*');
+  }
+  return expandMap;
+}

package/src/assignment/utils/exploreTreeRec.ts

@@ -0,0 +1,138 @@
+import type { Targets } from '../get1HAssignments';
+
+import type {
+  RestrictionByCS,
+  StoreAssignments1D,
+  Predictions1Dassignments,
+} from './buildAssignments';
+import type { PossibleAssignmentMap } from './createMapPossibleAssignments';
+import { partialScore } from './partialScore';
+
+export interface ExploreTreeRecProps {
+  nSources: number;
+  restrictionByCS: RestrictionByCS;
+  timeout: number;
+  timeStart: number;
+  maxSolutions: number;
+  targets: Targets;
+  useIntegrationRestriction: boolean;
+  predictions: Predictions1Dassignments;
+  lowerBoundScore: number;
+  nbAllowedUnAssigned: number;
+  possibleAssignmentMap: PossibleAssignmentMap;
+  diaIDPeerPossibleAssignment: string[];
+}
+export function exploreTreeRec(
+  props: ExploreTreeRecProps,
+  currentIndex: number,
+  partial: Array<string | null>,
+  store: StoreAssignments1D,
+) {
+  const {
+    nSources,
+    restrictionByCS,
+    timeout,
+    timeStart,
+    maxSolutions,
+    targets,
+    predictions,
+    lowerBoundScore,
+    nbAllowedUnAssigned,
+    possibleAssignmentMap,
+    useIntegrationRestriction,
+    diaIDPeerPossibleAssignment,
+  } = props;
+
+  const currentDate = new Date();
+  if (currentDate.getTime() - timeStart > timeout) {
+    new Error('timeout expired');
+    return store;
+  }
+
+  const diaID = diaIDPeerPossibleAssignment[currentIndex];
+  const possibleAssignments = possibleAssignmentMap[diaID];
+  for (let targetID of possibleAssignments) {
+    partial[currentIndex] = targetID;
+    let score = partialScore(partial, {
+      useIntegrationRestriction,
+      diaIDPeerPossibleAssignment,
+      nbAllowedUnAssigned,
+      restrictionByCS,
+      predictions,
+      targets,
+    });
+
+    if (score === 0) {
+      if (targetID === '*') {
+        partial[currentIndex] = null;
+      }
+      continue;
+    }
+
+    if (currentIndex === nSources - 1 && score >= lowerBoundScore) {
+      addSolution(store, { predictions, partial, score, maxSolutions });
+    } else if (currentIndex < nSources - 1) {
+      exploreTreeRec(
+        {
+          nSources,
+          restrictionByCS,
+          timeout,
+          timeStart,
+          maxSolutions,
+          targets,
+          predictions,
+          lowerBoundScore,
+          nbAllowedUnAssigned,
+          possibleAssignmentMap,
+          useIntegrationRestriction,
+          diaIDPeerPossibleAssignment,
+        },
+        currentIndex + 1,
+        JSON.parse(JSON.stringify(partial)),
+        store,
+      );
+    }
+  }
+}
+
+export interface SolutionAssignment {
+  assignment: string[];
+  score: number;
+}
+
+interface AddSolutionProps {
+  score: number;
+  maxSolutions: number;
+  partial: Array<string | null>;
+  predictions: Predictions1Dassignments;
+}
+
+function addSolution(store: StoreAssignments1D, props: AddSolutionProps) {
+  let { score, maxSolutions, partial, predictions } = props;
+  score /= doubleAssignmentPenalty(partial, predictions);
+  store.nSolutions++;
+  let solution: SolutionAssignment = {
+    assignment: JSON.parse(JSON.stringify(partial)),
+    score: score,
+  };
+
+  if (store.nSolutions >= maxSolutions) {
+    if (solution.score > store.solutions.last().score) {
+      store.solutions.pollLast();
+      store.solutions.add(solution);
+    }
+  } else {
+    store.solutions.add(solution);
+    store.nSolutions++;
+  }
+}
+
+function doubleAssignmentPenalty(
+  partial: Array<string | null>,
+  predictions: Predictions1Dassignments,
+) {
+  const nbSources = Object.keys(predictions).length;
+  let assignments = new Set(partial);
+  let nbDoubleAssignment = nbSources - assignments.size;
+  return nbDoubleAssignment > 0 ? 2 * nbDoubleAssignment : 1;
+}

package/src/assignment/utils/generateID.ts

@@ -0,0 +1,11 @@
+const BASE62 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+const LENGTH = 8;
+
+export default function generateID() {
+  let id = '';
+  for (let i = 0; i < LENGTH; i++) {
+    id += BASE62.charAt(Math.floor(Math.random() * 62));
+  }
+  return id;
+}

package/src/assignment/utils/partialScore.ts

@@ -0,0 +1,128 @@
+import { Targets } from '../get1HAssignments';
+
+import type {
+  Predictions1Dassignments,
+  RestrictionByCS,
+} from './buildAssignments';
+
+interface PartialScoreOptions {
+  restrictionByCS: RestrictionByCS;
+  /**
+   * number of allowed unassignment signals
+   * @default 0
+   */
+  useIntegrationRestriction: boolean;
+  nbAllowedUnAssigned: number;
+  diaIDPeerPossibleAssignment: string[];
+  predictions: Predictions1Dassignments;
+  targets: Targets;
+}
+
+export function partialScore(
+  partial: Array<string | null>,
+  options: PartialScoreOptions,
+) {
+  const {
+    useIntegrationRestriction,
+    diaIDPeerPossibleAssignment,
+    nbAllowedUnAssigned,
+    restrictionByCS,
+    predictions,
+    targets,
+  } = options;
+  const { useChemicalShiftScore } = restrictionByCS;
+  let countStars = 0;
+  let totalPartial = partial.length;
+  let partialInverse: {
+    [key: string]: string[];
+  } = {};
+  let activeDomainOnPrediction: number[] = [];
+
+  for (let i = 0; i < partial.length; i++) {
+    const targetID = partial[i];
+    if (targetID && targetID !== '*') {
+      activeDomainOnPrediction.push(i);
+      if (!partialInverse[targetID]) {
+        partialInverse[targetID] = [];
+      }
+      partialInverse[targetID].push(diaIDPeerPossibleAssignment[i]);
+    }
+    if (targetID === '*') countStars++;
+  }
+  if (countStars > nbAllowedUnAssigned) return 0;
+
+  const activeDomainOnTarget = Object.keys(partialInverse);
+
+  if (activeDomainOnTarget.length === 0) {
+    return 0;
+  }
+
+  if (useIntegrationRestriction) {
+    for (let targetID of activeDomainOnTarget) {
+      let targetToSource = partialInverse[targetID];
+      let total = 0;
+      for (const diaID of targetToSource) {
+        const prediction = predictions[diaID];
+        total += prediction.allHydrogens;
+      }
+
+      const { integration } = targets[targetID];
+      if (total - integration >= 0.5) {
+        return 0;
+      }
+    }
+  }
+
+  //chemical shift score
+  let chemicalShiftScore = useChemicalShiftScore
+    ? chemicalShiftScoring(partial, options)
+    : 1;
+
+  const penaltyByStarts = countStars / totalPartial;
+
+  return chemicalShiftScore - penaltyByStarts;
+}
+
+function chemicalShiftScoring(
+  partial: Array<string | null>,
+  options: PartialScoreOptions,
+) {
+  const { tolerance } = options.restrictionByCS;
+  const { diaIDPeerPossibleAssignment, predictions, targets } = options;
+
+  let chemicalShiftScore = 0;
+  let count = 0;
+  for (let index = 0; index < partial.length; index++) {
+    const targetID = partial[index];
+    if (targetID && targetID !== '*') {
+      count++;
+      let diaID = diaIDPeerPossibleAssignment[index];
+      let source = predictions[diaID];
+      let target = targets[targetID];
+      let error = tolerance;
+      if (source.error) {
+        error = Math.max(source.error, tolerance);
+      }
+      if (typeof source.delta === 'undefined') {
+        // Chemical shift is not a restriction
+        chemicalShiftScore += 1;
+      } else {
+        const delta =
+          target.signals && target.signals.length > 0
+            ? target.signals[0].delta
+            : (target.to + target.from) / 2;
+        let diff = Math.abs(source.delta - delta);
+        if (diff < error) {
+          chemicalShiftScore += 1;
+        } else {
+          diff = Math.abs(diff - error);
+          chemicalShiftScore += (-0.25 / error) * diff + 1;
+        }
+      }
+    }
+  }
+  if (count > 0) {
+    chemicalShiftScore /= count;
+  }
+  return chemicalShiftScore;
+}

package/src/index.ts

@@ -1,9 +1,3 @@
-/**
- * @typedef {Object} DataXY
- * @property {Array<Number>} x Array of x values
- * @property {Array<Number>} y Array of y values
- */
-
 export * from './constants/gyromagneticRatio';
 export * from './constants/impurities';
 export * from './constants/couplingPatterns';
@@ -17,6 +11,9 @@ export * from './prediction/predictHSQC';
 export * from './prediction/predictHMBC';
 export * from './prediction/predictAll';
 
+export * from './assignment/get1HAssignments';
+export * from './assignment/get13CAssignments';
+
 export * from './ranges/rangesToACS';
 export * from './ranges/rangesToXY';
 

package/src/peaks/peaksFilterImpurities.ts

@@ -66,7 +66,7 @@ function checkImpurity(
   while (i--) {
     j = peakList.length;
     while (j--) {
-      tolerance = error + peakList[j].shape.width;
+      tolerance = error + peakList[j].width;
       difference = Math.abs(impurity[i].shift - peakList[j].x);
       if (difference < tolerance) {
         // && (impurity[i].multiplicity === '' || (impurity[i].multiplicity.indexOf(peakList[j].multiplicity)) { // some impurities has multiplicities like 'bs' but at presents it is unsupported