Minor refactoring and fix bugs/issues with atoms

Issues/bugs with atoms due to incorrect import/initialization in loadModule and registerModule
equinor · Dec 19, 2024 · 70fb156 · 70fb156
1 parent 9b94e94
commit 70fb156
Show file tree

Hide file tree

Showing 14 changed files with 119 additions and 122 deletions.
diff --git a/backend_py/primary/primary/routers/timeseries/router.py b/backend_py/primary/primary/routers/timeseries/router.py
@@ -234,6 +234,12 @@ async def get_statistical_vector_data_per_sensitivity(
                 sens_case_realization_mask = pc.and_(requested_realizations_mask, sens_case_realization_mask)
             table = vector_table.filter(sens_case_realization_mask)
 
+            if table.num_rows == 0 and requested_realizations_mask is not None:
+                raise HTTPException(
+                    status_code=404,
+                    detail="The combination of realizations to include and sensitivity case realizations results in no valid realizations",
+                )
+
             statistics = compute_vector_statistics(table, vector_name, service_stat_funcs_to_compute)
             if not statistics:
                 raise HTTPException(status_code=404, detail="Could not compute statistics")

diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/interfaces.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/interfaces.ts
@@ -13,7 +13,7 @@ import { VectorSpec } from "./typesAndEnums";
 export type SettingsToViewInterface = {
     vectorSpecification: VectorSpec | null;
     resamplingFrequency: Frequency_api | null;
-    selectedSensitivityNames: string[] | null;
+    selectedSensitivityNames: string[];
     showStatistics: boolean;
     showRealizations: boolean;
     showHistorical: boolean;

diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/loadModule.tsx b/frontend/src/modules/SimulationTimeSeriesSensitivity/loadModule.tsx
@@ -1,11 +1,14 @@
 import { ModuleRegistry } from "@framework/ModuleRegistry";
 
 import { Interfaces, settingsToViewInterfaceInitialization } from "./interfaces";
+import { MODULE_NAME } from "./registerModule";
 import { Settings } from "./settings/settings";
+import { settingsToViewInterfaceEffects } from "./view/atoms/interfaceEffects";
 import { View } from "./view/view";
 
-const module = ModuleRegistry.initModule<Interfaces>("SimulationTimeSeriesSensitivity", {
+const module = ModuleRegistry.initModule<Interfaces>(MODULE_NAME, {
     settingsToViewInterfaceInitialization,
+    settingsToViewInterfaceEffects,
 });
 
 module.viewFC = View;

diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/queryHooks.tsx b/frontend/src/modules/SimulationTimeSeriesSensitivity/queryHooks.tsx
diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/registerModule.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/registerModule.ts
@@ -2,14 +2,16 @@ import { ModuleCategory, ModuleDevState } from "@framework/Module";
 import { ModuleDataTagId } from "@framework/ModuleDataTags";
 import { ModuleRegistry } from "@framework/ModuleRegistry";
 import { SyncSettingKey } from "@framework/SyncSettings";
-import { Interfaces } from "@modules/3DViewer/interfaces";
 
 import { channelDefs } from "./channelDefs";
+import { Interfaces } from "./interfaces";
+
+export const MODULE_NAME = "SimulationTimeSeriesSensitivity";
 
 const description = "Plotting of simulation time series data for ensembles with design matrices.";
 
 ModuleRegistry.registerModule<Interfaces>({
-    moduleName: "SimulationTimeSeriesSensitivity",
+    moduleName: MODULE_NAME,
     defaultTitle: "Simulation time series per sensitivity",
     category: ModuleCategory.MAIN,
     devState: ModuleDevState.PROD,

diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/atoms/baseAtoms.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/atoms/baseAtoms.ts
@@ -5,6 +5,13 @@ import { atomWithCompare } from "@framework/utils/atomUtils";
 import { atom } from "jotai";
 import { isEqual } from "lodash";
 
+function areEnsembleIdentsEqual(a: EnsembleIdent | null, b: EnsembleIdent | null) {
+    if (a === null) {
+        return b === null;
+    }
+    return a.equals(b);
+}
+
 export const syncedEnsembleIdentsAtom = atom<EnsembleIdent[] | null>(null);
 export const syncedVectorNameAtom = atom<string | null>(null);
 
@@ -13,7 +20,14 @@ export const showStatisticsAtom = atom<boolean>(true);
 export const showRealizationsAtom = atom<boolean>(false);
 export const showHistoricalAtom = atom<boolean>(true);
 
-export const userSelectedEnsembleIdentAtom = atom<EnsembleIdent | null>(null);
-export const userSelectedVectorNameAtom = atom<string | null>(null);
-export const userSelectedVectorTagAtom = atom<string | null>(null);
+export const userSelectedEnsembleIdentAtom = atomWithCompare<EnsembleIdent | null>(null, areEnsembleIdentsEqual);
+export const userSelectedVectorNameAndTagAtom = atomWithCompare<{ name: string | null; tag: string | null }>(
+    {
+        name: null,
+        tag: null,
+    },
+    isEqual
+);
+
+// Note: Default value of null, to detect uninitialized state, and select all sensitivities on first render
 export const userSelectedSensitivityNamesAtom = atomWithCompare<string[] | null>(null, isEqual);
diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/atoms/derivedAtoms.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/atoms/derivedAtoms.ts
@@ -11,8 +11,7 @@ import {
     syncedVectorNameAtom,
     userSelectedEnsembleIdentAtom,
     userSelectedSensitivityNamesAtom,
-    userSelectedVectorNameAtom,
-    userSelectedVectorTagAtom,
+    userSelectedVectorNameAndTagAtom,
 } from "./baseAtoms";
 import { vectorListQueryAtom } from "./queryAtoms";
 
@@ -35,27 +34,29 @@ export const availableSensitivityNamesAtom = atom<string[]>((get) => {
     const ensemble = selectedEnsembleIdent ? ensembleSet.findEnsemble(selectedEnsembleIdent) : null;
     const ensembleSensitivityNames = ensemble?.getSensitivities()?.getSensitivityNames() ?? [];
 
-    return ensembleSensitivityNames;
+    return [...ensembleSensitivityNames];
 });
 
 export const selectedSensitivityNamesAtom = atom<string[]>((get) => {
     const userSelectedSensitivityNames = get(userSelectedSensitivityNamesAtom);
     const availableSensitivityNames = get(availableSensitivityNamesAtom);
 
-    // If userSelectedSensitivityNames is empty, do not override it
-    if (!userSelectedSensitivityNames || userSelectedSensitivityNames.length === 0) {
+    // If userSelectedSensitivityNames is empty, do not override it (i.e. deselect all)
+    if (userSelectedSensitivityNames && userSelectedSensitivityNames.length === 0) {
         return [];
     }
 
     // Fixup invalid sensitivity names
-    // - If no valid sensitivity names are selected, the change can be due to new available sensitivity names
+    // - If user selected sensitivity names is null, the module is considered uninitialized
+    // - If user selected sensitivity names fixup results in empty array, it is due to new available sensitivity
+    //   names, and all are selected.
     const fixedUpSensitivityNames =
-        userSelectedSensitivityNames?.filter((sens) => availableSensitivityNames.includes(sens)) ?? [];
-    if (fixedUpSensitivityNames.length === 0) {
-        return availableSensitivityNames;
+        userSelectedSensitivityNames?.filter((sens) => availableSensitivityNames.includes(sens)) ?? null;
+    if (!fixedUpSensitivityNames || fixedUpSensitivityNames.length === 0) {
+        return [...availableSensitivityNames];
     }
 
-    return fixedUpSensitivityNames;
+    return [...fixedUpSensitivityNames];
 });
 
 export const availableVectorNamesAtom = atom<string[]>((get) => {
@@ -77,10 +78,9 @@ export const vectorSelectorDataAtom = atom((get) => {
 /**
  * Atom that handles vector name and tag in synch with fixup
  */
-const fixedUpVectorNameAndTagAtom = atom<{ name: string | null; tag: string | null }>((get) => {
+const selectedVectorNameAndTagAtom = atom<{ name: string | null; tag: string | null }>((get) => {
     const syncedVectorName = get(syncedVectorNameAtom);
-    const userSelectedVectorName = get(userSelectedVectorNameAtom);
-    const userSelectedVectorTag = get(userSelectedVectorTagAtom);
+    const userSelectedVectorNameAndTag = get(userSelectedVectorNameAndTagAtom);
     const availableVectorNames = get(availableVectorNamesAtom);
 
     // Override with synced vector name if available
@@ -89,22 +89,23 @@ const fixedUpVectorNameAndTagAtom = atom<{ name: string | null; tag: string | nu
     }
 
     // If vector name is fixed up, adjust tag as well
+    const userSelectedVectorName = userSelectedVectorNameAndTag.name;
     const fixedUpVectorName = fixupVectorName(userSelectedVectorName, availableVectorNames);
     if (fixedUpVectorName !== userSelectedVectorName) {
         return { name: fixedUpVectorName, tag: fixedUpVectorName };
     }
 
-    return { name: userSelectedVectorName, tag: userSelectedVectorTag };
+    return { name: userSelectedVectorName, tag: userSelectedVectorNameAndTag.tag };
 });
 
-export const selectedVectorNameAtom = atom<string | null>((get) => {
-    const fixedUpVectorName = get(fixedUpVectorNameAndTagAtom).name;
-    return fixedUpVectorName;
+const selectedVectorNameAtom = atom<string | null>((get) => {
+    const userSelectedVectorNameAndTag = get(selectedVectorNameAndTagAtom);
+    return userSelectedVectorNameAndTag.name;
 });
 
 export const selectedVectorTagAtom = atom<string | null>((get) => {
-    const fixedUpVectorTag = get(fixedUpVectorNameAndTagAtom).tag;
-    return fixedUpVectorTag;
+    const userSelectedVectorNameAndTag = get(selectedVectorNameAndTagAtom);
+    return userSelectedVectorNameAndTag.tag;
 });
 
 export const selectedVectorNameHasHistoricalAtom = atom<boolean>((get) => {

diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/settings.tsx b/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/settings.tsx
@@ -28,8 +28,7 @@ import {
     syncedVectorNameAtom,
     userSelectedEnsembleIdentAtom,
     userSelectedSensitivityNamesAtom,
-    userSelectedVectorNameAtom,
-    userSelectedVectorTagAtom,
+    userSelectedVectorNameAndTagAtom,
 } from "./atoms/baseAtoms";
 import {
     availableSensitivityNamesAtom,
@@ -51,8 +50,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
     const setSyncedEnsembleIdents = useSetAtom(syncedEnsembleIdentsAtom);
     const setSyncedVectorName = useSetAtom(syncedVectorNameAtom);
     const setUserSelectedEnsembleIdent = useSetAtom(userSelectedEnsembleIdentAtom);
-    const setUserSelectedVectorName = useSetAtom(userSelectedVectorNameAtom);
-    const setUserSelectedVectorTag = useSetAtom(userSelectedVectorTagAtom);
+    const setUserSelectedVectorNameAndTag = useSetAtom(userSelectedVectorNameAndTagAtom);
     const setUserSelectedSensitivityNamesAtom = useSetAtom(userSelectedSensitivityNamesAtom);
     const selectedEnsembleIdent = useAtomValue(selectedEnsembleIdentAtom);
     const vectorsListQuery = useAtomValue(vectorListQueryAtom);
@@ -101,8 +99,9 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
         setResamplingFrequency(newFreq);
     }
     function handleVectorSelectChange(selection: SmartNodeSelectorSelection) {
-        setUserSelectedVectorName(selection.selectedNodes[0] ?? null);
-        setUserSelectedVectorTag(selection.selectedTags[0]?.text ?? null);
+        const userSelectedVectorName = selection.selectedNodes[0] ?? null;
+        const userSelectedVectorTag = selection.selectedTags[0]?.text ?? null;
+        setUserSelectedVectorNameAndTag({ name: userSelectedVectorName, tag: userSelectedVectorTag });
     }
     function handleShowHistorical(event: React.ChangeEvent<HTMLInputElement>) {
         setShowHistorical(event.target.checked);

diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/view/atoms/baseAtoms.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/view/atoms/baseAtoms.ts
@@ -5,7 +5,7 @@ import { atom } from "jotai";
 
 export const vectorSpecificationAtom = atom<VectorSpec | null>(null);
 export const resamplingFrequencyAtom = atom<Frequency_api | null>(Frequency_api.MONTHLY);
-export const selectedSensitivityNamesAtom = atom<string[] | null>(null);
+export const selectedSensitivityNamesAtom = atom<string[]>([]);
 export const showStatisticsAtom = atom<boolean>(true);
 export const showRealizationsAtom = atom<boolean>(false);
 export const showHistoricalAtom = atom<boolean>(true);

diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/view/atoms/derivedAtoms.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/view/atoms/derivedAtoms.ts
@@ -1,7 +1,11 @@
 import { atom } from "jotai";
 
 import { userSelectedActiveTimestampUtcMsAtom } from "./baseAtoms";
-import { statisticalVectorSensitivityDataQueryAtom } from "./queryAtoms";
+import {
+    historicalVectorDataQueryAtom,
+    statisticalVectorSensitivityDataQueryAtom,
+    vectorDataQueryAtom,
+} from "./queryAtoms";
 
 export const activeTimestampUtcMsAtom = atom<number | null>((get) => {
     const userSelectedActiveTimestampUtcMs = get(userSelectedActiveTimestampUtcMsAtom);
@@ -15,3 +19,15 @@ export const activeTimestampUtcMsAtom = atom<number | null>((get) => {
     }
     return userSelectedActiveTimestampUtcMs;
 });
+
+export const queryIsFetchingAtom = atom((get) => {
+    const vectorDataQuery = get(vectorDataQueryAtom);
+    const statisticalVectorSensitivityDataQuery = get(statisticalVectorSensitivityDataQueryAtom);
+    const historicalVectorDataQuery = get(historicalVectorDataQueryAtom);
+
+    return (
+        vectorDataQuery.isFetching ||
+        statisticalVectorSensitivityDataQuery.isFetching ||
+        historicalVectorDataQuery.isFetching
+    );
+});
diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/view/atoms/queryAtoms.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/view/atoms/queryAtoms.ts
@@ -4,6 +4,7 @@ import { ValidEnsembleRealizationsFunctionAtom } from "@framework/GlobalAtoms";
 import { encodeAsUintListStr } from "@lib/utils/queryStringUtils";
 import {
     resamplingFrequencyAtom,
+    showHistoricalAtom,
     showStatisticsAtom,
     vectorSpecificationAtom,
 } from "@modules/SimulationTimeSeriesSensitivity/view/atoms/baseAtoms";
@@ -90,6 +91,7 @@ export const statisticalVectorSensitivityDataQueryAtom = atomWithQuery((get) =>
 
 export const historicalVectorDataQueryAtom = atomWithQuery((get) => {
     const vectorSpecification = get(vectorSpecificationAtom);
+    const showHistorical = get(showHistoricalAtom);
     const resampleFrequency = get(resamplingFrequencyAtom);
 
     const query = {
@@ -109,7 +111,7 @@ export const historicalVectorDataQueryAtom = atomWithQuery((get) => {
             ),
         staleTime: STALE_TIME,
         gcTime: CACHE_TIME,
-        enabled: !!vectorSpecification,
+        enabled: !!(vectorSpecification && showHistorical),
     };
 
     return query;

diff --git a/...src/modules/SimulationTimeSeriesSensitivity/view/hooks/useMakeViewStatusWriterMessages.ts b/...src/modules/SimulationTimeSeriesSensitivity/view/hooks/useMakeViewStatusWriterMessages.ts
@@ -0,0 +1,34 @@
+import { ViewStatusWriter } from "@framework/StatusWriter";
+
+import { useAtomValue } from "jotai";
+
+import { showHistoricalAtom, showStatisticsAtom } from "../atoms/baseAtoms";
+import {
+    historicalVectorDataQueryAtom,
+    statisticalVectorSensitivityDataQueryAtom,
+    vectorDataQueryAtom,
+} from "../atoms/queryAtoms";
+
+export function useMakeViewStatusWriterMessages(statusWriter: ViewStatusWriter) {
+    const vectorDataQuery = useAtomValue(vectorDataQueryAtom);
+    const statisticalVectorSensitivityDataQuery = useAtomValue(statisticalVectorSensitivityDataQueryAtom);
+    const historicalVectorDataQuery = useAtomValue(historicalVectorDataQueryAtom);
+    const showStatistics = useAtomValue(showStatisticsAtom);
+    const showHistorical = useAtomValue(showHistoricalAtom);
+
+    const isAnyQueryFetching =
+        vectorDataQuery.isFetching ||
+        statisticalVectorSensitivityDataQuery.isFetching ||
+        historicalVectorDataQuery.isFetching;
+    statusWriter.setLoading(isAnyQueryFetching);
+
+    if (vectorDataQuery.isError) {
+        statusWriter.addError("Realization data query has error state.");
+    }
+    if (showStatistics && statisticalVectorSensitivityDataQuery.isError) {
+        statusWriter.addError("Statistics data per sensitivity query has error state.");
+    }
+    if (showHistorical && historicalVectorDataQuery.isError) {
+        statusWriter.addWarning("Historical data query has error state.");
+    }
+}