nmr-processing 7.1.0 → 7.2.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/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';

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,8 +94,6 @@ export interface PredictOptions {
 
 export interface Predictions {
   [key: string]: Prediction1D | undefined;
-  H?: Prediction1D;
-  C?: Prediction1D;
 }
 
 type GroupDiastereotopicAtomIDsWithAtomInfo = GroupDiastereotopicAtomIDs & {