nmr-processing 9.7.8 → 9.7.9-pre.1690349439

package/src/assignment/utils/addSolution.ts

@@ -0,0 +1,45 @@
+import {
+  Predictions1Dassignments,
+  StoreAssignments,
+} from './oneDimensionalAssignment/buildAssignments';
+
+export interface SolutionAssignment {
+  assignment: string[];
+  score: number;
+}
+
+interface AddSolutionProps {
+  score: number;
+  maxSolutions: number;
+  partial: Array<string | null>;
+  predictions: Predictions1Dassignments;
+}
+
+export function addSolution(store: StoreAssignments, props: AddSolutionProps) {
+  const { score, maxSolutions, partial, predictions } = props;
+  store.nSolutions++;
+  const solution: SolutionAssignment = {
+    assignment: JSON.parse(JSON.stringify(partial)),
+    score: score / doubleAssignmentPenalty(partial, predictions),
+  };
+
+  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;
+  const assignments = new Set(partial);
+  const nbDoubleAssignment = nbSources - assignments.size;
+  return nbDoubleAssignment > 0 ? 2 * nbDoubleAssignment : 1;
+}

package/src/assignment/utils/{getAssignment → generalAssignment}/buildAssignments.ts

@@ -12,7 +12,7 @@ import { predictCarbon } from '../../../prediction/predictCarbon';
 import { predictProton } from '../../../prediction/predictProton';
 import { MakeMandatory } from '../../../utilities/MakeMandatory';
 import { SpectraDataWithIds } from '../../nmrAssigment';
-import { StoreAssignments } from '../buildAssignments';
+import { StoreAssignments } from '../oneDimensionalAssignment/buildAssignments';
 
 import {
   createMapPossibleAssignment,
@@ -30,18 +30,14 @@ const comparator = (a: AssignmentSolution, b: AssignmentSolution) => {
 const predictor = { H: predictProton, C: predictCarbon };
 
 export type AtomTypes = 'H' | 'C';
-export type CurrentAtoms = Array<AtomTypes>;
-export interface Partial {
-  [key: string]: Array<string | null>;
-}
+export type CurrentAtoms = AtomTypes[];
+export type Partial = Record<string, Array<string | null>>;
 
-export interface DiaIDPeerPossibleAssignment {
-  [key: string]: string[];
-}
+export type DiaIDPeerPossibleAssignment = Record<string, string[]>;
 
 export interface RestrictionByCS {
   chemicalShiftRestriction: boolean;
-  tolerance: { [key: string]: number };
+  tolerance: Record<string, number>;
   useChemicalShiftScore: boolean;
 }
 
@@ -51,10 +47,10 @@ export interface BuildAssignmentInput {
   restrictionByCS: RestrictionByCS;
   timeout: number;
   minScore: number;
-  nbAllowedUnAssigned?: { [key: string]: number };
+  nbAllowedUnAssigned?: Record<string, number>;
   maxSolutions: number;
   correlations: Values;
-  assignmentOrder: Array<Array<AtomTypes>>;
+  assignmentOrder: AtomTypes[][];
   predictions: {
     H?: NMRSignal1D[];
     C?: NMRSignal1D[];
@@ -80,7 +76,7 @@ function checkNMRSignal1D(
     'atoms',
   ];
   for (const signal of signals) {
-    for (let key of keys) {
+    for (const key of keys) {
       if (!signal[key]) throw new Error(`property ${key} does not exist`);
     }
   }
@@ -93,21 +89,18 @@ export interface Prediction extends NMRSignal1DFromPrediction {
   pathLength: number[];
 }
 
-export interface Predictions {
-  [key: string]: Prediction;
-}
+export type Predictions = Record<string, Prediction>;
 
-export interface PredictionsByAtomType {
-  [key: string]: Predictions;
-}
+export type PredictionsByAtomType = Record<string, Predictions>;
 
-export interface InfoByAtomType {
-  [key: string]: {
+export type InfoByAtomType = Record<
+  string,
+  {
     nSources: number;
     currentIndex: number;
     nbAllowedUnAssigned: number;
-  };
-}
+  }
+>;
 
 export const getAllHydrogens = {
   C: (m: Molecule, i: number) => m.getAllHydrogens(i),
@@ -130,7 +123,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
     targets,
   } = props;
 
-  let lowerBoundScore = minScore;
+  const lowerBoundScore = minScore;
 
   let store: StoreAssignments = {
     solutions: new TreeSet(comparator),
@@ -141,7 +134,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
     pathLength: true,
   });
 
-  let infoByAtomType: InfoByAtomType = {};
+  const infoByAtomType: InfoByAtomType = {};
   const predictions: PredictionsByAtomType = {};
   let possibleAssignmentMap: MapPossibleAssignments = {};
   let diaIDPeerPossibleAssignment: DiaIDPeerPossibleAssignment = {};
@@ -150,7 +143,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
     for (const atomType of atomTypesToPredict) {
       const options = predictionOptions[atomType];
       const predictedSignals = inputPrediction[atomType];
-      let { joinedSignals } = predictedSignals
+      const { joinedSignals } = predictedSignals
         ? { joinedSignals: predictedSignals }
         : await predictor[atomType](molecule, options);
 
@@ -159,7 +152,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
       if (!predictions[atomType]) predictions[atomType] = {};
 
       let totalHydrogens = 0;
-      for (let prediction of joinedSignals) {
+      for (const prediction of joinedSignals) {
         const diaID = prediction.diaIDs[0];
         const index = prediction.atoms[0];
         const allHydrogens = getAllHydrogens[atomType](molecule, index);
@@ -172,7 +165,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
           pathLength: pathLengthMatrix[index] as number[],
         };
       }
-      for (let diaID in predictions[atomType]) {
+      for (const diaID in predictions[atomType]) {
         predictions[atomType][diaID].allHydrogens *= 100 / totalHydrogens;
       }
       infoByAtomType[atomType] = {
@@ -195,7 +188,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
       );
     }
 
-    let sourceOfPartials = getSourceOfPartials(
+    const sourceOfPartials = getSourceOfPartials(
       store,
       infoByAtomType,
       atomTypesToPredict,
@@ -208,7 +201,7 @@ export async function buildAssignments(props: BuildAssignmentInput) {
 
     const timeStart = Date.now();
 
-    for (let partial of sourceOfPartials) {
+    for (const partial of sourceOfPartials) {
       exploreTree(
         {
           currentAtomTypes: atomTypesToPredict,
@@ -252,7 +245,7 @@ function annotateSpectraData(input: AnnotateSpectraDataInput) {
   for (const atomType of atomTypes) {
     const targetByAtomType = targets[atomType];
     for (const targetId in targetByAtomType) {
-      let target = targetByAtomType[targetId];
+      const target = targetByAtomType[targetId];
       for (const link of target.link) {
         const signalId = link.signal.id;
         if (mapSignalId[signalId]) continue;
@@ -262,7 +255,7 @@ function annotateSpectraData(input: AnnotateSpectraDataInput) {
   }
 
   const result = [];
-  for (let solution of solutions.elements) {
+  for (const solution of solutions.elements) {
     const spectraResult = JSON.parse(
       JSON.stringify(spectra),
     ) as SpectraDataWithIds[];
@@ -279,15 +272,15 @@ function annotateSpectraData(input: AnnotateSpectraDataInput) {
         const target = targetByAtomType[targetID];
         const diaId = diaIDPeerPossibleAssignment[atomType][index];
 
-        for (let link of target.link) {
+        for (const link of target.link) {
           const { spectrumIndex, elementIndex, signalIndex } =
             mapSignalId[link.signal.id];
           const spectrum = spectraResult[spectrumIndex];
 
           if (isSpectraData1D(spectrum)) {
-            let { ranges } = spectrum;
-            let range = ranges[elementIndex];
-            let signal = range.signals[signalIndex];
+            const { ranges } = spectrum;
+            const range = ranges[elementIndex];
+            const signal = range.signals[signalIndex];
             if (!signal.diaIDs) signal.diaIDs = [];
             if (signal.diaIDs.includes(diaId)) continue;
             signal.diaIDs.push(diaId);
@@ -316,7 +309,7 @@ function getSourceOfPartials(
 ) {
   return store.nSolutions > 0
     ? store.solutions.elements.map((e) => {
-        let currentAssignment = e.assignment;
+        const currentAssignment = e.assignment;
         for (const atom of currentAtoms) {
           currentAssignment[atom] = fillPartial(infoByAtomType[atom].nSources);
         }

package/src/assignment/utils/{getAssignment → generalAssignment}/checkIDs.ts

@@ -11,8 +11,8 @@ import type {
 import { isSpectraData1D } from './isSpectraData1D';
 
 export function checkIDs(input: SpectraData[] = []): SpectraDataWithIds[] {
-  let inputClone = JSON.parse(JSON.stringify(input)) as SpectraData[];
-  let spectra: SpectraDataWithIds[] = [];
+  const inputClone = JSON.parse(JSON.stringify(input)) as SpectraData[];
+  const spectra: SpectraDataWithIds[] = [];
   for (const spectraData of inputClone) {
     if (!('info' in spectraData)) {
       throw new Error(
@@ -22,10 +22,10 @@ export function checkIDs(input: SpectraData[] = []): SpectraDataWithIds[] {
 
     const { info, id } = spectraData;
     if (isSpectraData1D(spectraData)) {
-      let ranges = addIDs(spectraData.ranges) as NMRRangeWithIds[];
+      const ranges = addIDs(spectraData.ranges) as NMRRangeWithIds[];
       spectra.push({ id, info, ranges });
     } else {
-      let data = addIDs(spectraData.zones) as NMRZoneWithIds[];
+      const data = addIDs(spectraData.zones) as NMRZoneWithIds[];
       spectra.push({ id, info, zones: data });
     }
   }
@@ -37,7 +37,7 @@ export function hasIDs(
 ): asserts data is NMRRangeWithIds[] | NMRZoneWithIds[] {
   for (const element of data) {
     if (!element.id) throw new Error('A range/zone has not an ID');
-    for (let signal of element.signals || []) {
+    for (const signal of element.signals || []) {
       if (!signal.id) throw new Error('A signal has not an ID');
     }
   }
@@ -46,7 +46,7 @@ export function hasIDs(
 export function addIDs<T extends NMRRange[] | NMRZone[]>(data: T) {
   for (const element of data) {
     if (!element.id) element.id = generateID();
-    for (let signal of element.signals || []) {
+    for (const signal of element.signals || []) {
       if (!signal.id) signal.id = generateID();
     }
   }

package/src/assignment/utils/{getAssignment → generalAssignment}/createMapPossibleAssignment.ts

@@ -1,6 +1,6 @@
 import { getCorrelationDelta } from 'nmr-correlation';
 
-import { PossibleAssignmentMap } from '../createMapPossibleAssignments';
+import { PossibleAssignmentMap } from '../oneDimensionalAssignment/createMapPossibleAssignments';
 
 import {
   AtomTypes,
@@ -9,12 +9,8 @@ import {
 } from './buildAssignments';
 import { TargetsByAtomType } from './getTargetsAndCorrelations';
 
-export interface PossibleAssignments {
-  [key: string]: string[];
-}
-export interface MapPossibleAssignments {
-  [key: string]: PossibleAssignmentMap;
-}
+export type PossibleAssignments = Record<string, string[]>;
+export type MapPossibleAssignments = Record<string, PossibleAssignmentMap>;
 export interface CreateMapPossibleAssignmentOptions {
   restrictionByCS: RestrictionByCS;
   predictions: PredictionsByAtomType;
@@ -31,17 +27,17 @@ export function createMapPossibleAssignment(
   const atomTypes = Object.keys(predictions) as AtomTypes[];
 
   for (const atomType of atomTypes) {
-    let errorAbs = toleranceCS[atomType];
-    let predictionByAtomType = predictions[atomType];
-    let targetByAtomType = targets[atomType];
+    const errorAbs = toleranceCS[atomType];
+    const predictionByAtomType = predictions[atomType];
+    const targetByAtomType = targets[atomType];
     if (!expandMap[atomType]) expandMap[atomType] = {};
     for (const diaID in predictionByAtomType) {
-      let prediction = predictionByAtomType[diaID];
+      const prediction = predictionByAtomType[diaID];
       expandMap[atomType][diaID] = [];
 
       if (targetByAtomType) {
         for (const targetID in targetByAtomType) {
-          let target = targetByAtomType[targetID];
+          const target = targetByAtomType[targetID];
           const { nbAtoms, protonsCount: protonsCountFromPrediction } =
             prediction;
           const { integration, protonsCount } = target;
@@ -63,11 +59,11 @@ export function createMapPossibleAssignment(
               // Chemical shift is not a restriction
               expandMap[atomType][diaID].push(targetID);
             } else {
-              let targetDelta = getCorrelationDelta(target);
+              const targetDelta = getCorrelationDelta(target);
               if (targetDelta === undefined) {
                 throw new Error(`Correlation has not delta`);
               }
-              let distAfterLimit = Math.abs(
+              const distAfterLimit = Math.abs(
                 prediction.delta - targetDelta - errorAbs,
               );
 

package/src/assignment/utils/{getAssignment → generalAssignment}/exploreTree.ts

@@ -1,4 +1,4 @@
-import { StoreAssignments } from '../buildAssignments';
+import { StoreAssignments } from '../oneDimensionalAssignment/buildAssignments';
 
 import {
   RestrictionByCS,
@@ -73,10 +73,10 @@ export function exploreTree(
     const diaID = diaIDPeerPossibleAssignment[atomType][currentIndex];
     const possibleAssignments = possibleAssignmentMap[atomType][diaID];
 
-    for (let targetID of possibleAssignments) {
+    for (const targetID of possibleAssignments) {
       partial[atomType][currentIndex] = targetID;
 
-      let score = partialScore(partial, {
+      const score = partialScore(partial, {
         diaIDPeerPossibleAssignment,
         infoByAtomTypes,
         restrictionByCS,
@@ -126,11 +126,10 @@ export interface AssignmentSolution {
 }
 
 function addSolution(store: StoreAssignments, props: AddSolutionOptions) {
-  let { score, maxSolutions, partial, predictions } = props;
-  score /= doubleAssignmentPenalty(partial, predictions);
-  let solution: AssignmentSolution = {
+  const { score, maxSolutions, partial, predictions } = props;
+  const solution: AssignmentSolution = {
     assignment: JSON.parse(JSON.stringify(partial)),
-    score,
+    score: score / doubleAssignmentPenalty(partial, predictions),
   };
 
   if (store.nSolutions >= maxSolutions) {
@@ -163,7 +162,7 @@ function doubleAssignmentPenalty(
   let nbDoubleAssignment = 0;
   for (const atomType in predictions) {
     const nbSources = Object.keys(predictions[atomType]).length;
-    let assignments = new Set(partial[atomType]);
+    const assignments = new Set(partial[atomType]);
     nbDoubleAssignment += nbSources - assignments.size;
   }
   return nbDoubleAssignment > 0 ? 2 * nbDoubleAssignment : 1;

package/src/assignment/utils/{getAssignment → generalAssignment}/formatData.ts

@@ -22,8 +22,8 @@ export type SpectraDataFormatted =
 export function formatData(
   input: SpectraDataWithIds[] = [],
 ): SpectraDataFormatted[] {
-  let inputClone = JSON.parse(JSON.stringify(input)) as SpectraDataWithIds[];
-  let spectra: SpectraDataFormatted[] = [];
+  const inputClone = JSON.parse(JSON.stringify(input)) as SpectraDataWithIds[];
+  const spectra: SpectraDataFormatted[] = [];
   for (const spectraData of inputClone) {
     const { id, info } = spectraData;
     if (isSpectraData1D(spectraData)) {
@@ -43,12 +43,12 @@ export function formatData(
 function rescaleIntegration(spectrum: SpectraData1DWithIds): NMRRangeWithIds[] {
   if (spectrum.info.nucleus !== '1H') return spectrum.ranges;
 
-  let totalIntegration = spectrum.ranges.reduce(
+  const totalIntegration = spectrum.ranges.reduce(
     (total, range) => (range.integration ? total + range.integration : total),
     0,
   );
 
-  for (let range of spectrum.ranges) {
+  for (const range of spectrum.ranges) {
     if (range.integration) {
       range.integration *= 100 / totalIntegration;
       if (range.signals) {
@@ -57,7 +57,7 @@ function rescaleIntegration(spectrum: SpectraData1DWithIds): NMRRangeWithIds[] {
             signal.integration ? total + signal.integration : total,
           0,
         );
-        for (let signal of range.signals) {
+        for (const signal of range.signals) {
           if (signal.integration) {
             signal.integration *= range.integration / totalSignalIntegration;
           } else {

package/src/assignment/utils/{getAssignment → generalAssignment}/getTargetsAndCorrelations.ts

@@ -12,11 +12,9 @@ export interface CorrelationWithIntegration
     'link' | 'atomType' | 'label' | 'attachment' | 'protonsCount'
   > {
   integration: number;
-  indirectLinks: Array<Link>;
-}
-export interface Targets {
-  [key: string]: CorrelationWithIntegration;
+  indirectLinks: Link[];
 }
+export type Targets = Record<string, CorrelationWithIntegration>;
 export interface TargetsByAtomType {
   H: Targets;
   C: Targets;
@@ -40,7 +38,7 @@ export function getTargetsAndCorrelations(
     tolerance,
   });
 
-  let targets: any = {};
+  const targets: any = {};
   for (const correlation of correlations) {
     if (correlation.pseudo) continue;
     const { id: targetID, atomType } = correlation;

package/src/assignment/utils/{getAssignment → generalAssignment}/getWorkFlow.ts

@@ -8,10 +8,7 @@ import { AtomTypes } from './buildAssignments';
  * @param {*} justAssign
  */
 
-function getWorkFlow(
-  correlations: Values,
-  justAssign: Array<AtomTypes[]> = [],
-) {
+function getWorkFlow(correlations: Values, justAssign: AtomTypes[][] = []) {
   const experimentTypes = extractExperimentType(correlations);
 
   const { hasHSQC, types } = experimentTypes;
@@ -20,7 +17,7 @@ function getWorkFlow(
     return { assignmentOrder: justAssign, experimentTypes };
   }
 
-  const assignmentOrder: Array<AtomTypes[]> = [];
+  const assignmentOrder: AtomTypes[][] = [];
 
   if (hasHSQC) {
     assignmentOrder.push(['C'], ['H']);

package/src/assignment/utils/{getAssignment → generalAssignment}/groupCarbonTargetByIntegrationZone.ts

@@ -8,27 +8,27 @@ function groupCarbonTargetByIntegrationZone(
   targets: Targets,
   correlations: CorrelationWithIntegration[],
 ) {
-  let targetID = activeDomainOnTarget[0];
-  let { H: attachments = [] } = targets[targetID].attachment;
+  const targetID = activeDomainOnTarget[0];
+  const { H: attachments = [] } = targets[targetID].attachment;
 
-  let targetByIntegral = [
+  const 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;
+    const targetID = activeDomainOnTarget[i];
+    const target = targets[targetID];
+    const { H: attachments = [] } = target.attachment;
 
     let alone = true;
-    for (let group of targetByIntegral) {
+    for (const 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) {
+        for (const attachment of attachments) {
           group.attachments.add(attachment);
         }
         break;

package/src/assignment/utils/{getAssignment → generalAssignment}/partialScore.ts

@@ -14,7 +14,7 @@ import {
 import groupCarbonTargetByIntegrationZone from './groupCarbonTargetByIntegrationZone';
 
 export interface PartialScoreOptions {
-  diaIDPeerPossibleAssignment: { [key: string]: string[] };
+  diaIDPeerPossibleAssignment: Record<string, string[]>;
   restrictionByCS: RestrictionByCS;
   infoByAtomTypes: InfoByAtomType;
   correlations: CorrelationWithIntegration[];
@@ -22,13 +22,9 @@ export interface PartialScoreOptions {
   targets: TargetsByAtomType;
 }
 
-interface ObjectStringArray {
-  [key: string]: string[];
-}
+type ObjectStringArray = Record<string, string[]>;
 
-interface ObjectObjectStringArray {
-  [key: string]: ObjectStringArray;
-}
+type ObjectObjectStringArray = Record<string, ObjectStringArray>;
 
 export function partialScore(partial: Partial, props: PartialScoreOptions) {
   const {
@@ -43,8 +39,8 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
   const { tolerance: toleranceCS, useChemicalShiftScore } = restrictionByCS;
   let totalStarts = 0;
   let totalPartial = 0;
-  let partialInverse: ObjectObjectStringArray = {};
-  let activeDomainOnPrediction: { [key: string]: number[] } = {};
+  const partialInverse: ObjectObjectStringArray = {};
+  const activeDomainOnPrediction: Record<string, number[]> = {};
   const atomTypes = Object.keys(partial) as AtomTypes[];
   for (const atomType of atomTypes) {
     let countStars = 0;
@@ -89,11 +85,11 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
 
   const getPredictionByDiaID = getPrediction.bind({}, predictions);
   // check the integration
-  const targetByIntegral: {
+  const targetByIntegral: Array<{
     atomType: string;
     targetIDs: string[];
     integration: number;
-  }[] = [];
+  }> = [];
 
   for (const atomType in partial) {
     if (atomType === 'C' && activeDomainOnTarget[atomType].length > 0) {
@@ -105,7 +101,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
         ),
       );
     } else {
-      for (let targetID of activeDomainOnTarget[atomType]) {
+      for (const targetID of activeDomainOnTarget[atomType]) {
         targetByIntegral.push({
           atomType,
           targetIDs: [targetID],
@@ -120,8 +116,8 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
     if (integration === undefined || isNaN(integration)) continue;
 
     let total = 0;
-    for (let targetID of group.targetIDs) {
-      let targetToSource = partialInverse[atomType][targetID];
+    for (const targetID of group.targetIDs) {
+      const targetToSource = partialInverse[atomType][targetID];
       for (const diaID of targetToSource) {
         const { prediction, atomType: atomOfPrediction } =
           getPredictionByDiaID(diaID);
@@ -146,10 +142,10 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
         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];
+          const diaID = diaIDPeerPossibleAssignment[atomType][index];
+          const source = predictions[atomType][diaID];
+          const target = targetsPeerAtomType[targetID];
+          const error = toleranceCS[atomType];
           // if (source.error) {
           //   error = Math.max(source.error, toleranceCS);
           // }
@@ -183,7 +179,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
   let scoreOn2D = 0;
 
   if (howManyActived(activeDomainOnTarget) > 1) {
-    let andConstrains: { [key: string]: number } = {};
+    const andConstrains: Record<string, number> = {};
     let activeDomain: Array<{ index: number; atomType: AtomTypes }> = [];
 
     for (const atomType of Object.keys(
@@ -204,20 +200,20 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
           predictions[atomTypeJ][
             diaIDPeerPossibleAssignment[atomTypeJ][indexJ]
           ];
-        let pathLength = predictionI.pathLength[predictionJ.diaIDIndex];
-        let isPossible = pathLength < 5;
+        const pathLength = predictionI.pathLength[predictionJ.diaIDIndex];
+        const isPossible = pathLength < 5;
 
-        let partialI = partial[atomTypeI][indexI];
-        let partialJ = partial[atomTypeJ][indexJ];
+        const partialI = partial[atomTypeI][indexI];
+        const partialJ = partial[atomTypeJ][indexJ];
 
         if (!partialI || !partialJ) continue;
 
-        let keyOnTargertMap =
+        const keyOnTargertMap =
           partialI > partialJ
             ? `${partialJ} ${partialI}`
             : `${partialI} ${partialJ}`;
 
-        let areLinked = checkLinking(
+        const areLinked = checkLinking(
           {
             from: {
               targetID: partialI,
@@ -231,7 +227,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
           targets,
         );
 
-        let partialScore2D = isPossible
+        const partialScore2D = isPossible
           ? areLinked
             ? 1
             : 0
@@ -246,7 +242,7 @@ export function partialScore(partial: Partial, props: PartialScoreOptions) {
     }
 
     let sumAnd = 0;
-    for (let key in andConstrains) {
+    for (const key in andConstrains) {
       sumAnd += andConstrains[key];
     }
 
@@ -277,8 +273,8 @@ function checkLinking(
 ) {
   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];
+  const correlationI = correlations[from.atomType][from.targetID];
+  const 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;