fix: integral in fixed mode for integrals and ranges

close #1131
cheminfo · Jun 17, 2021 · eaf7d4a · eaf7d4a
1 parent 1369194
commit eaf7d4a
Show file tree

Hide file tree

Showing 3 changed files with 71 additions and 64 deletions.
diff --git a/src/component/reducer/actions/IntegralsActions.ts b/src/component/reducer/actions/IntegralsActions.ts
@@ -18,7 +18,7 @@ function handleChangeIntegralSum(draft: Draft<State>, value) {
   if (draft.activeSpectrum?.id) {
     const { index, id } = draft.activeSpectrum;
     (draft.data[index] as Datum1D).integrals.options.sum = value;
-    updateIntegralIntegrals(draft.data[index] as Datum1D);
+    updateIntegralIntegrals(draft.data[index] as Datum1D, true);
 
     if (!draft.integralsYDomains) {
       draft.integralsYDomains[id] = draft.yDomains[id];

diff --git a/src/component/reducer/actions/RangesActions.ts b/src/component/reducer/actions/RangesActions.ts
@@ -182,7 +182,7 @@ function handleChangeRangeSum(draft: Draft<State>, value) {
   if (draft.activeSpectrum?.id) {
     const { index } = draft.activeSpectrum;
     (draft.data[index] as Datum1D).ranges.options.sum = value;
-    updateIntegralRanges(draft.data[index]);
+    updateIntegralRanges(draft.data[index], true);
   }
 }
 function handleAddRange(draft: Draft<State>, action) {

diff --git a/src/data/data1d/Spectrum1D.ts b/src/data/data1d/Spectrum1D.ts
@@ -272,41 +272,37 @@ export function lookupPeak(data, options) {
   return null;
 }
 
-export function updateIntegralIntegrals(datum) {
-  updateRelatives(datum.integrals, 'integral', integralCountingCondition);
+export function updateIntegralIntegrals(datum, forceCalculateIntegral = false) {
+  updateRelatives(
+    datum.integrals,
+    'integral',
+    integralCountingCondition,
+    forceCalculateIntegral,
+  );
 }
 
 export function changeIntegralsRealtive(datum, newIntegral) {
   const index = datum.integrals.values.findIndex(
     (integral) => integral.id === newIntegral.id,
   );
   if (index !== -1) {
-    if (datum.integrals.options.isSumConstant) {
-      const ratio = datum.integrals.values[index].absolute / newIntegral.value;
-      const { values, sum } = datum.integrals.values.reduce(
-        (acc, integral, index) => {
-          const newIntegralValue = integral.absolute / ratio;
-          acc.sum += newIntegralValue;
-          acc.values[index] = {
-            ...integral,
-            integral: newIntegralValue,
-          };
-
-          return acc;
-        },
-        { values: [], sum: 0 },
-      );
-
-      datum.integrals.values = values;
-      datum.integrals.options.sum = sum;
-    } else {
-      datum.integrals.values[index].integral = newIntegral.value;
-      datum.integrals.options.sum = getSum(
-        datum.integrals.values,
-        'integral',
-        integralCountingCondition,
-      );
-    }
+    const ratio = datum.integrals.values[index].absolute / newIntegral.value;
+    const { values, sum } = datum.integrals.values.reduce(
+      (acc, integral, index) => {
+        const newIntegralValue = integral.absolute / ratio;
+        acc.sum += newIntegralValue;
+        acc.values[index] = {
+          ...integral,
+          integral: newIntegralValue,
+        };
+
+        return acc;
+      },
+      { values: [], sum: 0 },
+    );
+
+    datum.integrals.values = values;
+    datum.integrals.options.sum = sum;
   }
 }
 
@@ -326,27 +322,47 @@ function rangeCountingCondition(range) {
   return range.signal && checkSignalKinds(range, SignalKindsToInclude);
 }
 
-function updateRelatives(data, storageKey, countingCondition) {
+function updateRelatives(
+  data,
+  storageKey,
+  countingCondition,
+  forceCalculateIntegral = false,
+) {
   const { values, options } = data;
-  if (data.options.isSumConstant) {
-    const currentSum = getSum(values, 'absolute', countingCondition);
 
-    const factor = currentSum > 0 ? options.sum / currentSum : 0.0;
-    data.values = data.values.map((value) => {
-      return {
-        ...value,
-        ...(countingCondition(value) && {
-          [storageKey]: value.absolute * factor,
-        }),
-      };
-    });
+  const currentSum = getSum(values, 'absolute', countingCondition);
+
+  let factor = 0;
+  if (data.options.isSumConstant || forceCalculateIntegral) {
+    factor = currentSum > 0 ? options.sum / currentSum : 0.0;
   } else {
-    data.options.sum = getSum(values, storageKey, countingCondition);
+    if (data.values?.[0]) {
+      const { [storageKey]: inetgral, absolute } = data.values[0];
+      factor = (inetgral ? inetgral : options.sum) / absolute;
+    }
+  }
+
+  data.values = data.values.map((value) => {
+    return {
+      ...value,
+      ...(countingCondition(value) && {
+        [storageKey]: value.absolute * factor,
+      }),
+    };
+  });
+
+  if (!data.options.isSumConstant && !forceCalculateIntegral) {
+    data.options.sum = getSum(data.values, storageKey, countingCondition);
   }
 }
 
-export function updateIntegralRanges(datum) {
-  updateRelatives(datum.ranges, 'integral', rangeCountingCondition);
+export function updateIntegralRanges(datum, forceCalculateIntegral = false) {
+  updateRelatives(
+    datum.ranges,
+    'integral',
+    rangeCountingCondition,
+    forceCalculateIntegral,
+  );
 }
 
 export function detectRange(datum, options) {
@@ -513,25 +529,16 @@ export function changeRangesRealtive(datum, newRange) {
     (range) => range.id === newRange.id,
   );
   if (index !== -1) {
-    if (datum.ranges.options.isSumConstant) {
-      const ratio = datum.ranges.values[index].absolute / newRange.value;
-      datum.ranges.options.sum =
-        (newRange.value / datum.ranges.values[index].integral) *
-        datum.ranges.options.sum;
-      datum.ranges.values = datum.ranges.values.map((range) => {
-        return {
-          ...range,
-          integral: range.absolute / ratio,
-        };
-      });
-    } else {
-      datum.ranges.values[index].integral = newRange.value;
-      datum.ranges.options.sum = getSum(
-        datum.ranges.values,
-        'integral',
-        rangeCountingCondition,
-      );
-    }
+    const ratio = datum.ranges.values[index].absolute / newRange.value;
+    datum.ranges.options.sum =
+      (newRange.value / datum.ranges.values[index].integral) *
+      datum.ranges.options.sum;
+    datum.ranges.values = datum.ranges.values.map((range) => {
+      return {
+        ...range,
+        integral: range.absolute / ratio,
+      };
+    });
   }
 }