nmr-processing 7.1.0 → 7.4.0

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

@@ -0,0 +1,308 @@
+import { getCorrelationDelta } from 'nmr-correlation';
+
+import {
+  AtomTypes,
+  InfoByAtomType,
+  Partial,
+  PredictionsByAtomType,
+  RestrictionByCS,
+} from './buildAssignments';
+import {
+  CorrelationWithIntegration,
+  TargetsByAtomType,
+} from './getTargetsAndCorrelations';
+import groupCarbonTargetByIntegrationZone from './groupCarbonTargetByIntegrationZone';
+
+export interface PartialScoreOptions {
+  diaIDPeerPossibleAssignment: { [key: string]: string[] };
+  restrictionByCS: RestrictionByCS;
+  infoByAtomTypes: InfoByAtomType;
+  correlations: CorrelationWithIntegration[];
+  predictions: PredictionsByAtomType;
+  targets: TargetsByAtomType;
+}
+
+interface ObjectStringArray {
+  [key: string]: string[];
+}
+
+interface ObjectObjectStringArray {
+  [key: string]: ObjectStringArray;
+}
+
+export function partialScore(partial: Partial, props: PartialScoreOptions) {
+  const {
+    diaIDPeerPossibleAssignment,
+    infoByAtomTypes,
+    restrictionByCS,
+    predictions,
+    targets,
+    correlations,
+  } = props;
+
+  const { tolerance: toleranceCS, useChemicalShiftScore } = restrictionByCS;
+  let totalStarts = 0;
+  let totalPartial = 0;
+  let partialInverse: ObjectObjectStringArray = {};
+  let activeDomainOnPrediction: { [key: string]: number[] } = {};
+  const atomTypes = Object.keys(partial) as AtomTypes[];
+  for (const atomType of atomTypes) {
+    let countStars = 0;
+    const { nbAllowedUnAssigned } = infoByAtomTypes[atomType];
+    const currentPartialInverse: ObjectStringArray = {};
+    const partialAssignment = partial[atomType] || [];
+    partialInverse[atomType] = currentPartialInverse;
+    activeDomainOnPrediction[atomType] = [];
+    totalPartial += partialAssignment.length;
+    for (let i = 0; i < partialAssignment.length; i++) {
+      const targetID = partialAssignment[i];
+      if (targetID && targetID !== '*') {
+        activeDomainOnPrediction[atomType].push(i);
+        if (!currentPartialInverse[targetID]) {
+          currentPartialInverse[targetID] = [];
+        }
+        currentPartialInverse[targetID].push(
+          diaIDPeerPossibleAssignment[atomType][i],
+        );
+      }
+      if (targetID === '*') countStars++;
+    }
+
+    if (countStars > nbAllowedUnAssigned) return 0;
+    totalStarts += countStars;
+  }
+
+  const activeDomainOnTarget: ObjectStringArray = {};
+  for (const atomType in partialInverse) {
+    activeDomainOnTarget[atomType] = Object.keys(partialInverse[atomType]);
+  }
+
+  const valuesActiveDomainOnTarget = Object.values(activeDomainOnTarget);
+  if (
+    valuesActiveDomainOnTarget.reduce(
+      (sum, e) => (e.length === 0 ? sum + 1 : sum),
+      0,
+    ) === valuesActiveDomainOnTarget.length
+  ) {
+    return 0;
+  }
+
+  const getPredictionByDiaID = getPrediction.bind({}, predictions);
+  // check the integration
+  const targetByIntegral: {
+    atomType: string;
+    targetIDs: string[];
+    integration: number;
+  }[] = [];
+
+  for (const atomType in partial) {
+    if (atomType === 'C' && activeDomainOnTarget[atomType].length > 0) {
+      targetByIntegral.push(
+        ...groupCarbonTargetByIntegrationZone(
+          activeDomainOnTarget[atomType],
+          targets[atomType],
+          correlations,
+        ),
+      );
+    } else {
+      for (let targetID of activeDomainOnTarget[atomType]) {
+        targetByIntegral.push({
+          atomType,
+          targetIDs: [targetID],
+          integration: targets.H[targetID].integration,
+        });
+      }
+    }
+  }
+  for (const group of targetByIntegral) {
+    const { integration, atomType } = group;
+
+    if (integration === undefined || isNaN(integration)) continue;
+
+    let total = 0;
+    for (let targetID of group.targetIDs) {
+      let targetToSource = partialInverse[atomType][targetID];
+      for (const diaID of targetToSource) {
+        const { prediction, atomType: atomOfPrediction } =
+          getPredictionByDiaID(diaID);
+        if (atomType === atomOfPrediction) total += prediction.allHydrogens;
+      }
+    }
+    if (total - integration >= 0.5) {
+      return 0;
+    }
+  }
+
+  //chemical shift score
+  let count = 1;
+  let chemicalShiftScore = 1;
+  if (useChemicalShiftScore) {
+    chemicalShiftScore = 0;
+    count = 0;
+    for (const atomType of Object.keys(partial) as AtomTypes[]) {
+      const partialPeerAtomType = partial[atomType];
+      const targetsPeerAtomType = targets[atomType];
+      for (let index = 0; index < partialPeerAtomType.length; index++) {
+        const targetID = partialPeerAtomType[index];
+        if (targetID && targetID !== '*') {
+          count++;
+          let diaID = diaIDPeerPossibleAssignment[atomType][index];
+          let source = predictions[atomType][diaID];
+          let target = targetsPeerAtomType[targetID];
+          let error = toleranceCS[atomType];
+          // if (source.error) {
+          //   error = Math.max(source.error, toleranceCS);
+          // }
+          if (typeof source.delta === 'undefined') {
+            // Chemical shift is not a restriction
+            chemicalShiftScore += 1;
+          } else {
+            const targetDelta = getCorrelationDelta(target);
+
+            if (targetDelta === undefined) {
+              throw new Error('correlation has not delta');
+            }
+
+            let diff = Math.abs(source.delta - targetDelta);
+            if (diff < error) {
+              //@TODO: check for a better discriminant
+              chemicalShiftScore += 1;
+            } else {
+              diff = Math.abs(diff - error);
+              chemicalShiftScore += (-0.25 / error) * diff + 1;
+            }
+          }
+        }
+      }
+    }
+    if (count > 0) {
+      chemicalShiftScore /= count;
+    }
+  }
+
+  let scoreOn2D = 0;
+
+  if (howManyActived(activeDomainOnTarget) > 1) {
+    let andConstrains: { [key: string]: number } = {};
+    let activeDomain: Array<{ index: number; atomType: AtomTypes }> = [];
+
+    for (const atomType of Object.keys(
+      activeDomainOnPrediction,
+    ) as AtomTypes[]) {
+      activeDomain = activeDomain.concat(
+        activeDomainOnPrediction[atomType].map((e) => ({ index: e, atomType })),
+      );
+    }
+
+    for (let i = 0; i < activeDomain.length; i++) {
+      const { atomType: atomTypeI, index: indexI } = activeDomain[i];
+      const predictionI =
+        predictions[atomTypeI][diaIDPeerPossibleAssignment[atomTypeI][indexI]];
+      for (let j = i + 1; j < activeDomain.length; j++) {
+        const { atomType: atomTypeJ, index: indexJ } = activeDomain[j];
+        const predictionJ =
+          predictions[atomTypeJ][
+            diaIDPeerPossibleAssignment[atomTypeJ][indexJ]
+          ];
+        let pathLength = predictionI.pathLength[predictionJ.diaIDIndex];
+        let isPossible = pathLength < 5;
+
+        let partialI = partial[atomTypeI][indexI];
+        let partialJ = partial[atomTypeJ][indexJ];
+
+        if (!partialI || !partialJ) continue;
+
+        let keyOnTargertMap =
+          partialI > partialJ
+            ? `${partialJ} ${partialI}`
+            : `${partialI} ${partialJ}`;
+
+        let areLinked = checkLinking(
+          {
+            from: {
+              targetID: partialI,
+              atomType: atomTypeI,
+            },
+            to: {
+              targetID: partialJ,
+              atomType: atomTypeJ,
+            },
+          },
+          targets,
+        );
+
+        let partialScore2D = isPossible
+          ? areLinked
+            ? 1
+            : 0
+          : !areLinked
+          ? 1
+          : 0;
+
+        andConstrains[keyOnTargertMap] = andConstrains[keyOnTargertMap]
+          ? Math.max(andConstrains[keyOnTargertMap], partialScore2D)
+          : partialScore2D;
+      }
+    }
+
+    let sumAnd = 0;
+    for (let key in andConstrains) {
+      sumAnd += andConstrains[key];
+    }
+
+    scoreOn2D =
+      sumAnd / ((activeDomain.length * (activeDomain.length - 1)) / 2);
+  }
+  const penaltyByStarts = totalStarts / totalPartial;
+  if (chemicalShiftScore === 0) return scoreOn2D - penaltyByStarts;
+
+  if (scoreOn2D === 0) return chemicalShiftScore - penaltyByStarts;
+  return (chemicalShiftScore + scoreOn2D) / 2 - penaltyByStarts;
+}
+
+interface CheckLinkingFromTo {
+  from: {
+    targetID: string;
+    atomType: AtomTypes;
+  };
+  to: {
+    targetID: string;
+    atomType: AtomTypes;
+  };
+}
+
+function checkLinking(
+  partials: CheckLinkingFromTo,
+  correlations: TargetsByAtomType,
+) {
+  const { from, to } = partials;
+  if (from.targetID === to.targetID) return true;
+  let correlationI = correlations[from.atomType][from.targetID];
+  let correlationJ = correlations[to.atomType][to.targetID];
+  for (const linkJ of correlationJ.link) {
+    for (const link of correlationI.link) {
+      if (link.signal.id === linkJ.signal.id) return true;
+    }
+  }
+  return false;
+}
+
+function getPrediction(predictions: PredictionsByAtomType, diaID: string) {
+  const atomTypes = Object.keys(predictions) as AtomTypes[];
+  for (const atomType of atomTypes) {
+    const predictionByAtomType = predictions[atomType];
+    if (!predictionByAtomType) throw new Error(`prediction by ${atomType}`);
+    if (predictionByAtomType[diaID]) {
+      return { atomType, prediction: predictionByAtomType[diaID] };
+    }
+  }
+  throw new Error(`There is not prediction for ${diaID}`);
+}
+
+function howManyActived(actived: ObjectStringArray) {
+  let sum = 0;
+  for (const atom in actived) {
+    sum += actived[atom].length;
+  }
+  return sum;
+}

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

@@ -0,0 +1,19 @@
+import { SpectraData } from '../../getAssignments';
+
+import { isSpectraData1D } from './isSpectraData1D';
+
+export function searchIndices(signalId: string, spectra: SpectraData[]) {
+  for (let spectrumIndex = 0; spectrumIndex < spectra.length; spectrumIndex++) {
+    const spectrum = spectra[spectrumIndex];
+    const data = isSpectraData1D(spectrum) ? spectrum.ranges : spectrum.zones;
+    for (let elementIndex = 0; elementIndex < data.length; elementIndex++) {
+      const signals = data[elementIndex].signals || [];
+      for (let signalIndex = 0; signalIndex < signals.length; signalIndex++) {
+        if (signalId === signals[signalIndex].id) {
+          return { spectrumIndex, signalIndex, elementIndex };
+        }
+      }
+    }
+  }
+  throw new Error(`There is not a signal with ${signalId} ID`);
+}

package/src/assignment/utils/partialScore.ts

@@ -2,11 +2,11 @@ import { Targets } from '../get1HAssignments';
 
 import type {
   Predictions1Dassignments,
-  RestrictionByCS,
+  RestrictionByCS1D,
 } from './buildAssignments';
 
 interface PartialScoreOptions {
-  restrictionByCS: RestrictionByCS;
+  restrictionByCS: RestrictionByCS1D;
   /**
    * number of allowed unassignment signals
    * @default 0

package/src/constants/gyromagneticRatio.ts

@@ -3,7 +3,31 @@
 
 // TODO: #13 can we have a better source and more digits ? @jwist
 
-export const gyromagneticRatio = {
+export type Nuclei =
+  | '1H'
+  | '2H'
+  | '3H'
+  | '3He'
+  | '7Li'
+  | '13C'
+  | '14N'
+  | '15N'
+  | '17O'
+  | '19F'
+  | '23Na'
+  | '27Al'
+  | '29Si'
+  | '31P'
+  | '57Fe'
+  | '63Cu'
+  | '67Zn'
+  | '129Xe';
+
+type GyromagneticRatio = {
+  [key in Nuclei]: number;
+};
+
+export const GYROMAGNETIC_RATIO: GyromagneticRatio = {
   '1H': 267.52218744e6,
   '2H': 41.065e6,
   '3H': 285.3508e6,

package/src/index.ts

@@ -14,6 +14,7 @@ export * from './prediction/predictAllSpectra';
 
 export * from './assignment/get1HAssignments';
 export * from './assignment/get13CAssignments';
+export * from './assignment/getAssignments';
 
 export * from './ranges/rangesToACS';
 export * from './ranges/rangesToXY';
@@ -24,6 +25,7 @@ export * from './signals/signals2DToZ';
 
 export * from './utilities/resurrect';
 export * from './utilities/rangeFromSignal';
+export * from './utilities/getFrequency';
 
 export * from './xy/xyAutoPeaksPicking';
 export * from './xy/xyAutoRangesPicking';

package/src/ml-tree-set.d.ts

@@ -3,7 +3,7 @@ declare module 'ml-tree-set' {
   type Elements = any;
   export default class TreeSet {
     public length: number;
-    public elements: Array<Elements>;
+    public elements: Array<w>;
 
     public constructor(comparator: Comparator);
 

package/src/peaks/peaksToRanges.ts

@@ -242,6 +242,7 @@ export function peaksToRanges(
       delta: signal.delta,
       kind: signal.kind || 'signal',
       multiplicity: signal.multiplicity,
+      integration: signal.integralData.value,
     };
     if (keepPeaks) {
       signalResult.peaks = signal.peaks.map((peak) => {

package/src/prediction/utils/predict2D.ts

@@ -94,12 +94,10 @@ export interface PredictOptions {
 
 export interface Predictions {
   [key: string]: Prediction1D | undefined;
-  H?: Prediction1D;
-  C?: Prediction1D;
 }
 
 type GroupDiastereotopicAtomIDsWithAtomInfo = GroupDiastereotopicAtomIDs & {
-  atomInfo: PathInfo;
+  pathInfo: PathInfo;
 };
 
 type PredictHMBCOptionsWithFromTo = MakeMandatory<
@@ -141,7 +139,7 @@ export async function predict2D(
 
   let diaIDs = getGroupedDiastereotopicAtomIDs(molecule);
 
-  const paths = getPathsInfo(molecule, {
+  const pathsInfo = getPathsInfo(molecule, {
     fromLabel: from,
     toLabel: to,
     minLength,
@@ -152,7 +150,9 @@ export async function predict2D(
   for (let diaID of diaIDs) {
     diaIDswithAtomInfo.push({
       ...diaID,
-      atomInfo: JSON.parse(JSON.stringify(paths[diaID.atoms[0]])) as PathInfo,
+      pathInfo: JSON.parse(
+        JSON.stringify(pathsInfo[diaID.atoms[0]]),
+      ) as PathInfo,
     });
   }
 
@@ -194,26 +194,25 @@ export async function predict2D(
       signalsByDiaID[axis][signal.diaIDs[0]] = signal;
     }
   }
-
   let group: { [key: string]: NMRSignal2D } = {};
   for (const diaID of diaIDswithAtomInfo) {
-    const atom = diaID.atomInfo;
-    if (atom.paths.length < 1) continue;
+    const pathInfo = diaID.pathInfo;
+    if (pathInfo.paths.length < 1) continue;
 
-    if (!signalsByDiaID.x[atom.oclID]) continue;
+    if (!signalsByDiaID.x[pathInfo.oclID]) continue;
 
-    const currentPaths = atom.paths;
+    const currentPaths = pathInfo.paths;
     for (const path of currentPaths) {
-      if (!signalsByDiaID.y[paths[path.to].oclID]) continue;
+      if (!signalsByDiaID.y[pathsInfo[path.to].oclID]) continue;
 
       let fromToDiaID: { [key: string]: AtomInfo } = {
-        x: atom,
-        y: paths[path.to],
+        x: pathInfo,
+        y: pathsInfo[path.to],
       };
 
       const key = `${fromToDiaID.x.oclID}-${fromToDiaID.y.oclID}`;
 
-      if (key === `${atom.oclID}-${atom.oclID}` || group[key]) {
+      if (key === `${pathInfo.oclID}-${pathInfo.oclID}` || group[key]) {
         continue;
       }
 
@@ -228,12 +227,13 @@ export async function predict2D(
       }
 
       signal.peaks = [peak];
-
       group[key] = signal as NMRSignal2D;
     }
   }
 
-  if (includeDiagonal) addSelftCorrelation(group, { paths, signalsByDiaID });
+  if (includeDiagonal) {
+    addSelftCorrelation(group, { paths: pathsInfo, signalsByDiaID });
+  }
 
   // clusterize signals by distance
   const joinedSignals = Object.values(group);

package/src/signals/signals2DToZ.ts

@@ -26,6 +26,7 @@ interface Signals2DToZOptions {
    * @default 0.02
    */
   width?: number | XYNumber;
+  factor?: number | XYNumber;
 }
 
 export interface Peak2DSeries {
@@ -38,7 +39,13 @@ export function signals2DToZ(
   signals: NMRSignal2D[],
   options: Signals2DToZOptions = {},
 ) {
-  let { from = -1, to = 12, nbPoints = 512, width = 0.02 } = options;
+  let {
+    from = -1,
+    to = 12,
+    nbPoints = 512,
+    width = 0.02,
+    factor = 3,
+  } = options;
 
   const peaks = signals.reduce<Peak2DSeries>(
     (acc, { x, y }) => {
@@ -51,7 +58,8 @@ export function signals2DToZ(
   );
 
   width = ensureXYNumber(width);
-  return generateSpectrum2D(peaks, {
+
+  return generateSpectrum2D(mergeClosePeaks(peaks), {
     generator: {
       from: ensureXYNumber(from),
       to: ensureXYNumber(to),
@@ -59,11 +67,27 @@ export function signals2DToZ(
     },
     peaks: {
       width,
+      factor,
     },
   });
 }
 
-function ensureXYNumber(input: number | XYNumber): XYNumber {
-  let result = typeof input !== 'object' ? { x: input, y: input } : input;
-  return result;
+function ensureXYNumber(input: number | XYNumber) {
+  return typeof input !== 'object' ? { x: input, y: input } : { ...input };
+}
+
+function mergeClosePeaks(peaksIn: Peak2DSeries) {
+  let peaks = JSON.parse(JSON.stringify(peaksIn));
+  for (let i = 0; i < peaks.x.length; i++) {
+    for (let j = i + 1; j < peaks.x.length; j++) {
+      if (peaks.x[i] === peaks.x[j] && peaks.y[i] === peaks.y[j]) {
+        peaks.z[i] += peaks.z[j];
+        peaks.x.splice(j, 1);
+        peaks.y.splice(j, 1);
+        peaks.z.splice(j, 1);
+        j--;
+      }
+    }
+  }
+  return peaks;
 }

package/src/utilities/getFrequency.ts

@@ -0,0 +1,47 @@
+import { GYROMAGNETIC_RATIO, Nuclei } from '../constants/gyromagneticRatio';
+
+export interface ObjervedNucleusData {
+  /**
+   * nucleus to use as reference in the calculation of frequency
+   */
+  nucleus: Nucleus;
+  /**
+   * frequency of the reference nucleus
+   */
+  frequency: number;
+}
+
+//Literal type is extends string and when union it with string we lose the autocomplete and to solve this we distinguish string
+type Nucleus = Nuclei | (string & Record<never, never>);
+
+/**
+ * calculate the frequency of a nucleus with respect to a reference nucleus
+ */
+export function getFrequency(
+  /**
+   * nucleus to calculate the frequency
+   */
+  nucleus: Nucleus,
+  observedNucleusData: ObjervedNucleusData,
+) {
+  const { nucleus: obsNucleus, frequency } = observedNucleusData;
+
+  checkExistence(nucleus, obsNucleus);
+
+  return (
+    (frequency * GYROMAGNETIC_RATIO[nucleus as Nuclei]) /
+    GYROMAGNETIC_RATIO[obsNucleus as Nuclei]
+  );
+}
+
+function checkExistence(...nucleus: Nucleus[]) {
+  let nuclei: string[] = [];
+  for (const n of nucleus) {
+    if (!(n in GYROMAGNETIC_RATIO)) {
+      nuclei.push(n);
+    }
+  }
+  if (nuclei.length !== 0) {
+    throw new Error(`${nuclei.join(' , ')} is not supported`);
+  }
+}