nmr-processing 3.3.3 → 4.0.0

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

package/src/peaks/peaksToRanges.ts

@@ -1,5 +1,4 @@
 import type { DataXY } from 'cheminfo-types';
-import type { GSDPeak } from 'ml-gsd';
 import { xyIntegration } from 'ml-spectra-processing';
 
 import type { MakeMandatory } from '../types/MakeMandatory';
@@ -92,22 +91,20 @@ const assignSignal = (
     delta: NaN,
     nbPeaks: 1,
     kind: 'signal',
-    startX: peak.x - peak.shape.width,
-    stopX: peak.x + peak.shape.width,
+    startX: peak.x - peak.width,
+    stopX: peak.x + peak.width,
     observe: frequency,
     nucleus,
     integralData: {
-      from: peak.x - peak.shape.width * 3,
-      to: peak.x + peak.shape.width * 3,
+      from: peak.x - peak.width * 3,
+      to: peak.x + peak.width * 3,
       value: 0,
     },
     peaks: [
       {
         x: peak.x,
         intensity: peak.y,
-        shape: {
-          width: peak.shape.width,
-        },
+        width: peak.width,
       },
     ],
   };
@@ -178,9 +175,7 @@ export function peaksToRanges(
             peaksO.push({
               x: peakR.x,
               y: peakR.intensity,
-              shape: {
-                width: peakR.shape.width,
-              },
+              width: peakR.width,
             });
             signal.mask.splice(j, 1);
             signal.mask2.splice(j, 1);
@@ -251,7 +246,7 @@ export function peaksToRanges(
           ...peak,
         };
         delete newResult.intensity;
-        return newResult as GSDPeak;
+        return newResult as NMRPeak1D;
       });
     }
     if (signal.nmrJs) {
@@ -307,24 +302,22 @@ function detectSignals(
       if (peak.kind) signal1D.kind = peak.kind;
       signals.push(signal1D);
     } else {
-      let tmp = peak.x + peak.shape.width;
+      let tmp = peak.x + peak.width;
       signal1D.stopX = Math.max(signal1D.stopX, tmp);
       signal1D.startX = Math.min(signal1D.startX, tmp);
       signal1D.nbPeaks++;
       signal1D.peaks.push({
         x: peak.x,
         intensity: peak.y,
-        shape: {
-          width: peak.shape.width,
-        },
+        width: peak.width,
       });
       signal1D.integralData.from = Math.min(
         signal1D.integralData.from,
-        peak.x - peak.shape.width * 3,
+        peak.x - peak.width * 3,
       );
       signal1D.integralData.to = Math.max(
         signal1D.integralData.to,
-        peak.x + peak.shape.width * 3,
+        peak.x + peak.width * 3,
       );
       if (peak.kind) signal1D.kind = peak.kind;
     }
@@ -372,5 +365,5 @@ function detectSignals(
  * @private
  */
 function computeArea(peak: Peak1DIntern) {
-  return Math.abs(peak.intensity * peak.shape.width * 1.57); // todo add an option with this value: 1.772453851
+  return Math.abs(peak.intensity * peak.width * 1.57); // todo add an option with this value: 1.772453851
 }

package/src/peaks/util/determineRealTop.ts

@@ -1,10 +1,8 @@
 import LM from 'ml-levenberg-marquardt';
-import { gaussian2D } from 'ml-peak-shape-generator';
+import { Gaussian2D } from 'ml-peak-shape-generator';
 
 import type { MPFPeak } from '../../types/MPFPeak';
 
-const { fct: gaussian2DFct } = gaussian2D;
-
 const direction8X = [-1, -1, -1, 0, 0, 1, 1, 1];
 const direction8Y = [-1, 0, 1, -1, 1, -1, 0, 1];
 const direction16X = [-2, -2, -2, -2, -2, -1, -1, 0, 0, 1, 1, 2, 2, 2, 2, 2];
@@ -142,6 +140,7 @@ function fitGaussian(
 }
 
 function paramGaussian2D(intervalX: number, intervalY: number, nCols: number) {
+  const gaussian2D = new Gaussian2D();
   return (p: number[]) => {
     return (t: number) => {
       let nL = p.length / 5;
@@ -149,13 +148,12 @@ function paramGaussian2D(intervalX: number, intervalY: number, nCols: number) {
       let xIndex = t % nCols;
       let yIndex = (t - xIndex) / nCols;
       for (let i = 0; i < nL; i++) {
+        gaussian2D.fwhm = {x: p[i + 3 * nL], y: p[i + 4 * nL]};
         result +=
           p[i + 2 * nL] *
-          gaussian2DFct(
+          gaussian2D.fct(
             (xIndex - p[i]) * intervalX,
             (yIndex - p[i + nL]) * intervalY,
-            p[i + 3 * nL],
-            p[i + 4 * nL],
           );
       }
       return result;