nmr-processing 7.1.0 → 7.2.0

package/src/assignment/utils/getAssignment/data/predictions.js

@@ -0,0 +1,34 @@
+const predictions = {
+  C: {
+    carbon1: {
+      delta: 49.2,
+      diaIDs: ['carbon1'],
+      allHydrogens: 2,
+      diaIDIndex: 0,
+      pathLength: [0, 1, 2, 1, 1],
+    },
+    carbon2: {
+      delta: 28,
+      diaIDs: ['carbon2'],
+      allHydrogens: 0,
+      diaIDIndex: 1,
+      pathLength: [1, 0, 1, 2, 2],
+    },
+    carbon3: {
+      delta: 26.3,
+      diaIDs: ['carbon3'],
+      allHydrogens: 0,
+      diaIDIndex: 2,
+      pathLegth: [2, 1, 0, 3, 3],
+    },
+    carbon4: {
+      delta: 120,
+      diaIDs: ['carbon4'],
+      allHydrogens: 2,
+      diaIDIndex: 3,
+      pathLength: [2, 1, 0, 3, 3],
+    },
+  },
+};
+
+export default predictions;

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

@@ -0,0 +1,171 @@
+import { StoreAssignments } from '../buildAssignments';
+
+import {
+  RestrictionByCS,
+  DiaIDPeerPossibleAssignment,
+  InfoByAtomType,
+  Partial,
+  CurrentAtoms,
+  PredictionsByAtomType,
+} from './buildAssignments';
+import { MapPossibleAssignments } from './createMapPossibleAssignment';
+import {
+  CorrelationWithIntegration,
+  TargetsByAtomType,
+} from './getTargetsAndCorrelations';
+import { partialScore } from './partialScore';
+
+export interface ExploreTreeRecOptions {
+  currentAtomTypes: CurrentAtoms;
+  restrictionByCS: RestrictionByCS;
+  timeout: number;
+  timeStart: number;
+  maxSolutions: number;
+  targets: TargetsByAtomType;
+  predictions: PredictionsByAtomType;
+  correlations: CorrelationWithIntegration[];
+  lowerBoundScore: number;
+  possibleAssignmentMap: MapPossibleAssignments;
+  diaIDPeerPossibleAssignment: DiaIDPeerPossibleAssignment;
+}
+
+interface AddSolutionOptions
+  extends Pick<ExploreTreeRecOptions, 'maxSolutions' | 'predictions'> {
+  partial: Partial;
+  score: number;
+}
+
+export function exploreTree(
+  props: ExploreTreeRecOptions,
+  infoByAtomTypes: InfoByAtomType,
+  partial: Partial,
+  store: StoreAssignments,
+) {
+  const {
+    currentAtomTypes,
+    restrictionByCS,
+    timeout,
+    timeStart,
+    maxSolutions,
+    targets,
+    predictions,
+    correlations,
+    lowerBoundScore,
+    possibleAssignmentMap,
+    diaIDPeerPossibleAssignment,
+  } = props;
+
+  const currentDate = new Date();
+  if (currentDate.getTime() - timeStart > timeout) {
+    new Error('timeout expired');
+    return store;
+  }
+
+  for (const atomType of currentAtomTypes) {
+    const { currentIndex, nSources } = infoByAtomTypes[atomType];
+
+    if (
+      currentIndex >= nSources - 1 &&
+      partial[atomType][currentIndex] !== null
+    ) {
+      continue;
+    }
+
+    const diaID = diaIDPeerPossibleAssignment[atomType][currentIndex];
+    const possibleAssignments = possibleAssignmentMap[atomType][diaID];
+
+    for (let targetID of possibleAssignments) {
+      partial[atomType][currentIndex] = targetID;
+
+      let score = partialScore(partial, {
+        diaIDPeerPossibleAssignment,
+        infoByAtomTypes,
+        restrictionByCS,
+        predictions,
+        correlations,
+        targets,
+      });
+
+      if (score === 0) {
+        continue;
+      }
+
+      if (
+        isLastOne(currentAtomTypes, infoByAtomTypes) &&
+        score >= lowerBoundScore
+      ) {
+        addSolution(store, { predictions, partial, score, maxSolutions });
+      } else {
+        const newInfo = JSON.parse(JSON.stringify(infoByAtomTypes));
+        newInfo[atomType].currentIndex += 1;
+        exploreTree(
+          {
+            currentAtomTypes,
+            restrictionByCS,
+            timeout,
+            timeStart,
+            maxSolutions,
+            targets,
+            predictions,
+            correlations,
+            lowerBoundScore,
+            possibleAssignmentMap,
+            diaIDPeerPossibleAssignment,
+          },
+          newInfo,
+          JSON.parse(JSON.stringify(partial)),
+          store,
+        );
+      }
+    }
+  }
+}
+
+export interface AssignmentSolution {
+  assignment: string[];
+  score: number;
+}
+
+function addSolution(store: StoreAssignments, props: AddSolutionOptions) {
+  let { score, maxSolutions, partial, predictions } = props;
+  score /= doubleAssignmentPenalty(partial, predictions);
+  let solution: AssignmentSolution = {
+    assignment: JSON.parse(JSON.stringify(partial)),
+    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 isLastOne(
+  currentAtomTypes: CurrentAtoms,
+  infoByAtomTypes: InfoByAtomType,
+) {
+  let lastOne = true;
+  for (const atomType of currentAtomTypes) {
+    const { currentIndex, nSources } = infoByAtomTypes[atomType];
+    lastOne = lastOne && currentIndex >= nSources - 1;
+  }
+  return lastOne;
+}
+
+function doubleAssignmentPenalty(
+  partial: Partial,
+  predictions: PredictionsByAtomType,
+) {
+  let nbDoubleAssignment = 0;
+  for (const atomType in predictions) {
+    const nbSources = Object.keys(predictions[atomType]).length;
+    let assignments = new Set(partial[atomType]);
+    nbDoubleAssignment += nbSources - assignments.size;
+  }
+  return nbDoubleAssignment > 0 ? 2 * nbDoubleAssignment : 1;
+}

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

@@ -0,0 +1,35 @@
+import {
+  NMRRangeWithIds,
+  NMRZoneWithIds,
+  SpectraData1DWithIds,
+  SpectraData2DWithIds,
+  SpectraDataWithIds,
+} from './checkIDs';
+import { isSpectraData1D } from './isSpectraData1D';
+
+interface SpectraData1DFormatted extends Omit<SpectraData1DWithIds, 'ranges'> {
+  ranges: { values: NMRRangeWithIds[] };
+}
+interface SpectraData2DFormatted extends Omit<SpectraData2DWithIds, 'zones'> {
+  zones: { values: NMRZoneWithIds[] };
+}
+
+export type SpectraDataFormatted =
+  | SpectraData1DFormatted
+  | SpectraData2DFormatted;
+
+export function formatData(
+  input: SpectraDataWithIds[] = [],
+): SpectraDataFormatted[] {
+  let inputClone = JSON.parse(JSON.stringify(input)) as SpectraDataWithIds[];
+  let spectra: SpectraDataFormatted[] = [];
+  for (const spectraData of inputClone) {
+    const { info } = spectraData;
+    if (isSpectraData1D(spectraData)) {
+      spectra.push({ info, ranges: { values: spectraData.ranges } });
+    } else {
+      spectra.push({ info, zones: { values: spectraData.zones } });
+    }
+  }
+  return spectra;
+}

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

@@ -0,0 +1,16 @@
+import { Values } from 'nmr-correlation';
+
+import type { CorrelationWithIntegration } from './getTargetsAndCorrelations';
+
+export function getIntegrationOfAttachedProtons(
+  target: CorrelationWithIntegration,
+  correlations: Values,
+) {
+  const { H: attachment = [] } = target.attachment;
+  let integration = 0;
+  for (const match of attachment) {
+    const correlation = correlations[match];
+    integration += Number(correlation.link[0].signal.integration);
+  }
+  return integration;
+}

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

@@ -0,0 +1,63 @@
+import { buildCorrelationData } from 'nmr-correlation';
+import type { Correlation, Link } from 'nmr-correlation';
+
+import { SpectraDataWithIds } from './checkIDs';
+import { formatData } from './formatData';
+import { getIntegrationOfAttachedProtons } from './getIntegrationOfAttachedProtons';
+
+export interface CorrelationWithIntegration
+  extends Pick<
+    Correlation,
+    'link' | 'atomType' | 'label' | 'attachment' | 'protonsCount'
+  > {
+  integration: number;
+  indirectLinks: Array<Link>;
+}
+export interface Targets {
+  [key: string]: CorrelationWithIntegration;
+}
+export interface TargetsByAtomType {
+  H: Targets;
+  C: Targets;
+}
+export interface TargetsAndCorrelations {
+  targets: TargetsByAtomType;
+  correlations: CorrelationWithIntegration[];
+}
+
+export function getTargetsAndCorrelations(
+  spectra: SpectraDataWithIds[],
+  options: any = {},
+): TargetsAndCorrelations {
+  //add indirect links, if a carbon C1 is attached to a proton H1 that correlating
+  //with carbon C2, so the carbon C1 and C2 are also correlating
+
+  const { tolerance = { C: 0.25, H: 0.05 } } = options;
+
+  const spectraData = formatData(spectra);
+  const { values: correlations } = buildCorrelationData(spectraData, {
+    tolerance,
+  });
+
+  let targets: any = {};
+  for (const correlation of correlations) {
+    if (correlation.pseudo) continue;
+    const { id: targetID, atomType } = correlation;
+    if (!targets[atomType]) targets[atomType] = {};
+    targets[atomType][targetID] = correlation;
+    if (atomType === 'H') {
+      targets[atomType][targetID].integration =
+        correlation.link[0].signal.integration;
+    } else {
+      targets[atomType][targetID].integration = getIntegrationOfAttachedProtons(
+        correlation,
+        correlations,
+      );
+    }
+  }
+
+  return {
+    targets,
+    correlations,
+  };
+}

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

@@ -0,0 +1,72 @@
+import { Values } from 'nmr-correlation';
+
+import { AtomTypes } from './buildAssignments';
+/**
+ * if hsqc is present in experimentTypes we can just predict 13C
+ * spectrum and try to assign the carbons first.
+ * @param {*} correlations
+ * @param {*} justAssign
+ */
+
+function getWorkFlow(
+  correlations: Values,
+  justAssign: Array<AtomTypes[]> = [],
+) {
+  const experimentTypes = extractExperimentType(correlations);
+
+  const { hasHSQC, types } = experimentTypes;
+
+  if (justAssign.length > 0) {
+    return { assignmentOrder: justAssign, experimentTypes };
+  }
+
+  const assignmentOrder: Array<AtomTypes[]> = [];
+
+  if (hasHSQC) {
+    assignmentOrder.push(['C'], ['H']);
+  } else {
+    assignmentOrder.push(
+      types.filter((type) => type === 'H' || type === 'C') as AtomTypes[],
+    );
+  }
+
+  return { assignmentOrder, experimentTypes };
+}
+
+export default getWorkFlow;
+
+interface ExperimentTypes {
+  types: string[];
+  hasProton: boolean;
+  hasCarbon: boolean;
+  hasHSQC: boolean;
+}
+
+function extractExperimentType(correlations: Values): ExperimentTypes {
+  const types: string[] = [];
+  for (const correlation of correlations) {
+    let experimentType: string = correlation.experimentType;
+    if (experimentType === '1d') {
+      experimentType = `${correlation.atomType.toUpperCase()}`;
+    }
+    if (!types.includes(experimentType)) {
+      types.push(experimentType);
+    }
+    for (const link of correlation.link) {
+      experimentType = link.experimentType;
+      if (experimentType === '1d') {
+        experimentType = `${link.atomType[0].toUpperCase()}`;
+      }
+      if (!types.includes(experimentType)) {
+        types.push(experimentType);
+      }
+    }
+  }
+
+  return {
+    types,
+    hasProton: types.includes('H'),
+    hasCarbon: types.includes('C'),
+    hasHSQC: types.includes('hsqc'),
+  };
+}

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

@@ -0,0 +1,55 @@
+import {
+  CorrelationWithIntegration,
+  Targets,
+} from './getTargetsAndCorrelations';
+
+function groupCarbonTargetByIntegrationZone(
+  activeDomainOnTarget: string[],
+  targets: Targets,
+  correlations: CorrelationWithIntegration[],
+) {
+  let targetID = activeDomainOnTarget[0];
+  let { H: attachments = [] } = targets[targetID].attachment;
+
+  let targetByIntegral = [
+    { targetIDs: [targetID], attachments: new Set<number>(attachments) },
+  ];
+
+  for (let i = 1; i < activeDomainOnTarget.length; i++) {
+    let targetID = activeDomainOnTarget[i];
+    let target = targets[targetID];
+    let { H: attachments = [] } = target.attachment;
+
+    let alone = true;
+    for (let group of targetByIntegral) {
+      const pertain = attachments.some((attachment: any) =>
+        group.attachments.has(attachment),
+      );
+      if (pertain) {
+        alone = false;
+        group.targetIDs.push(targetID);
+        for (let attachment of attachments) {
+          group.attachments.add(attachment);
+        }
+        break;
+      }
+    }
+    if (alone) {
+      targetByIntegral.push({
+        targetIDs: [targetID],
+        attachments: new Set<number>(attachments),
+      });
+    }
+  }
+  return targetByIntegral.map((t) => ({
+    atomType: 'C',
+    targetIDs: t.targetIDs,
+    integration: correlations
+      ? Array.from(t.attachments).reduce((sum, index) => {
+          return correlations[index].integration + sum;
+        }, 0)
+      : 0,
+  }));
+}
+
+export default groupCarbonTargetByIntegrationZone;

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

@@ -0,0 +1,7 @@
+import { SpectraData, SpectraData1D } from '../../getAssignments';
+
+export function isSpectraData1D(
+  spectrum: SpectraData,
+): spectrum is SpectraData1D {
+  return 'ranges' in spectrum;
+}