Improve usage of status writer for settings and view in SimulationTim…

…eSeriesMatrix (#424)

Co-authored-by: Ruben Thoms <[email protected]>

frontend/src/modules/SimulationTimeSeriesMatrix/settings.tsx

@@ -5,6 +5,7 @@ import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { Parameter, ParameterIdent, ParameterType } from "@framework/EnsembleParameters";
 import { EnsembleSet } from "@framework/EnsembleSet";
 import { ModuleFCProps } from "@framework/Module";
+import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { MultiEnsembleSelect } from "@framework/components/MultiEnsembleSelect";
 import { ParameterListFilter } from "@framework/components/ParameterListFilter";
@@ -39,6 +40,7 @@ import {
     VisualizationModeEnumToStringMapping,
 } from "./state";
 import { EnsembleVectorListsHelper } from "./utils/ensemblesVectorListHelper";
+import { joinStringArrayToHumanReadableString } from "./utils/stringUtils";
 
 enum StatisticsType {
     INDIVIDUAL = "Individual",
@@ -47,6 +49,7 @@ enum StatisticsType {
 
 export function settings({ moduleContext, workbenchSession }: ModuleFCProps<State>) {
     const ensembleSet = useEnsembleSet(workbenchSession);
+    const statusWriter = useSettingsStatusWriter(moduleContext);
 
     // Store state/values
     const [resampleFrequency, setResamplingFrequency] = moduleContext.useStoreState("resamplingFrequency");
@@ -125,19 +128,33 @@ export function settings({ moduleContext, workbenchSession }: ModuleFCProps<Stat
         setStatisticsType(computedStatisticsType);
     }
 
+    // Set warning for selected vectors not existing in a selected ensemble
+    for (const ensembleIdent of selectedEnsembleIdents) {
+        const nonExistingVectors = selectedVectorNames.filter(
+            (vector) => !ensembleVectorListsHelper.isVectorInEnsemble(ensembleIdent, vector)
+        );
+        if (nonExistingVectors.length === 0) {
+            continue;
+        }
+
+        const ensembleStr = ensembleSet.findEnsemble(ensembleIdent)?.getDisplayName() ?? ensembleIdent.toString();
+        const vectorArrayStr = joinStringArrayToHumanReadableString(nonExistingVectors);
+        statusWriter.addWarning(`Vector ${vectorArrayStr} does not exist in ensemble ${ensembleStr}`);
+    }
+
     React.useEffect(
         function propagateVectorSpecsToView() {
             const newVectorSpecifications: VectorSpec[] = [];
-            for (const ensemble of selectedEnsembleIdents) {
+            for (const ensembleIdent of selectedEnsembleIdents) {
                 for (const vector of selectedVectorNames) {
-                    if (!ensembleVectorListsHelper.isVectorInEnsemble(ensemble, vector)) {
+                    if (!ensembleVectorListsHelper.isVectorInEnsemble(ensembleIdent, vector)) {
                         continue;
                     }
 
                     newVectorSpecifications.push({
-                        ensembleIdent: ensemble,
+                        ensembleIdent: ensembleIdent,
                         vectorName: vector,
-                        hasHistoricalVector: ensembleVectorListsHelper.hasHistoricalVector(ensemble, vector),
+                        hasHistoricalVector: ensembleVectorListsHelper.hasHistoricalVector(ensembleIdent, vector),
                     });
                 }
             }

frontend/src/modules/SimulationTimeSeriesMatrix/utils/stringUtils.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility function to make a display friendly string from an array of strings.
+ *
+ * Example: ["a", "b", "c"] -> "a, b and c"
+ */
+export function joinStringArrayToHumanReadableString(stringArray: string[]): string {
+    if (stringArray.length === 0) return "";
+    if (stringArray.length === 1) return stringArray[0];
+
+    return stringArray.slice(0, -1).join(", ") + " and " + stringArray[stringArray.length - 1];
+}

frontend/src/modules/SimulationTimeSeriesMatrix/view.tsx

@@ -25,7 +25,6 @@ export const view = ({ moduleContext, workbenchSession, workbenchSettings }: Mod
     const wrapperDivSize = useElementSize(wrapperDivRef);
 
     const ensembleSet = useEnsembleSet(workbenchSession);
-
     const statusWriter = useViewStatusWriter(moduleContext);
 
     // Store values
@@ -68,20 +67,26 @@ export const view = ({ moduleContext, workbenchSession, workbenchSettings }: Mod
         vectorSpecificationsWithHistoricalData?.some((vec) => vec.hasHistoricalVector) ?? false
     );
 
+    // Get fetching status from queries
     const isQueryFetching =
         vectorDataQueries.some((query) => query.isFetching) ||
         vectorStatisticsQueries.some((query) => query.isFetching) ||
         historicalVectorDataQueries.some((query) => query.isFetching);
 
     statusWriter.setLoading(isQueryFetching);
 
-    const hasQueryError =
-        vectorDataQueries.some((query) => query.isError) ||
-        vectorStatisticsQueries.some((query) => query.isError) ||
-        historicalVectorDataQueries.some((query) => query.isError);
-    if (hasQueryError) {
-        statusWriter.addError("One or more queries have an error state.");
-        return <ContentError>One or more queries have an error state.</ContentError>;
+    // Get error/warning status from queries
+    const hasRealizationsQueryError = vectorDataQueries.some((query) => query.isError);
+    const hasStatisticsQueryError = vectorStatisticsQueries.some((query) => query.isError);
+    const hasHistoricalVectorQueryError = historicalVectorDataQueries.some((query) => query.isError);
+    if (hasRealizationsQueryError) {
+        statusWriter.addError("One or more realization data queries have an error state.");
+    }
+    if (hasStatisticsQueryError) {
+        statusWriter.addError("One or more statistics data queries have an error state.");
+    }
+    if (hasHistoricalVectorQueryError) {
+        statusWriter.addWarning("One or more historical data queries have an error state.");
     }
 
     // Map vector specifications and queries with data
@@ -114,12 +119,25 @@ export const view = ({ moduleContext, workbenchSession, workbenchSettings }: Mod
     // Create parameter color scale helper
     const doColorByParameter =
         colorRealizationsByParameter &&
+        visualizationMode === VisualizationMode.INDIVIDUAL_REALIZATIONS &&
         parameterIdent !== null &&
         selectedEnsembles.some((ensemble) => ensemble.getParameters().hasParameter(parameterIdent));
     const ensemblesParameterColoring = doColorByParameter
         ? new EnsemblesContinuousParameterColoring(selectedEnsembles, parameterIdent, parameterColorScale)
         : null;
 
+    // Set warning for ensembles without selected parameter when coloring is enabled
+    if (doColorByParameter && ensemblesParameterColoring) {
+        const ensemblesWithoutParameter = selectedEnsembles.filter(
+            (ensemble) => !ensemblesParameterColoring.hasParameterForEnsemble(ensemble.getIdent())
+        );
+        for (const ensemble of ensemblesWithoutParameter) {
+            statusWriter.addWarning(
+                `Ensemble ${ensemble.getDisplayName()} does not have parameter ${ensemblesParameterColoring.getParameterDisplayName()}`
+            );
+        }
+    }
+
     // Callback function for ensemble display name
     function makeEnsembleDisplayName(ensembleIdent: EnsembleIdent): string {
         const ensembleNameCount = selectedEnsembles.filter(
@@ -193,16 +211,20 @@ export const view = ({ moduleContext, workbenchSession, workbenchSettings }: Mod
         subplotBuilder.addHistoryTraces(loadedVectorSpecificationsAndHistoricalData);
     }
 
-    // TODO: Keep uirevision?
+    const doRenderContentError = hasRealizationsQueryError || hasStatisticsQueryError;
     const plotData = subplotBuilder.createPlotData();
     return (
         <div className="w-full h-full" ref={wrapperDivRef}>
-            <Plot
-                key={plotData.length} // Note: To trigger re-render and remove legends when plotData is empty
-                data={plotData}
-                layout={subplotBuilder.createPlotLayout()}
-                config={{ scrollZoom: true }}
-            />
+            {doRenderContentError ? (
+                <ContentError>One or more queries have an error state.</ContentError>
+            ) : (
+                <Plot
+                    key={plotData.length} // Note: Temporary to trigger re-render and remove legends when plotData is empty
+                    data={plotData}
+                    layout={subplotBuilder.createPlotLayout()}
+                    config={{ scrollZoom: true }}
+                />
+            )}
         </div>
     );
 };

frontend/tests/unit-tests/SimulationTimeSeriesMatrixUtils.test.ts

@@ -0,0 +1,10 @@
+import { joinStringArrayToHumanReadableString } from "@modules/SimulationTimeSeriesMatrix/utils/stringUtils";
+
+describe("Test of utility functions for SimulationTimeSeriesMatrix module", () => {
+    test("Test join string array to human readable string", () => {
+        expect(joinStringArrayToHumanReadableString(["a", "b", "c"])).toBe("a, b and c");
+        expect(joinStringArrayToHumanReadableString(["a"])).toBe("a");
+        expect(joinStringArrayToHumanReadableString([])).toBe("");
+        expect(joinStringArrayToHumanReadableString(["a", "b"])).toBe("a and b");
+    });
+});