feat(LogicalControls): change to distinct and async computation

src/components/computing-status/use-all-computing-status.ts

@@ -15,6 +15,7 @@
     getSecurityAnalysisRunningStatus,
     getSensitivityAnalysisRunningStatus,
     getShortCircuitAnalysisRunningStatus,
+    getLogicalControlsRunningStatus,
     getStateEstimationRunningStatus,
     getVoltageInitRunningStatus,
 } from '../utils/running-status';
@@ -32,7 +33,7 @@
 import { fetchLoadFlowComputationInfos, fetchLoadFlowStatus } from '../../services/study/loadflow';
 import { OptionalServicesNames } from '../utils/optional-services';
 import { useOptionalServiceStatus } from '../../hooks/use-optional-service-status';
-import { fetchStateEstimationStatus } from '../../services/study/state-estimation';
+import { fetchLogicalControlsStatus, fetchStateEstimationStatus } from '../../services/study/state-estimation';
 import { fetchDynamicSecurityAnalysisStatus } from '../../services/study/dynamic-security-analysis';
 import { fetchDynamicMarginCalculationStatus } from '../../services/study/dynamic-margin-calculation';
 import { NotificationType } from 'types/notification-types';
@@ -76,6 +77,10 @@
     NotificationType.STATE_ESTIMATION_STATUS,
     NotificationType.STATE_ESTIMATION_FAILED,
 ];
+const logicalControlsStatusInvalidations = [
+    NotificationType.LOGICAL_CONTROLS_STATUS,
+    NotificationType.LOGICAL_CONTROLS_FAILED,
+];
 const pccMinStatusInvalidations = [NotificationType.PCC_MIN_STATUS, NotificationType.PCC_MIN_FAILED];
 
 // status completions
@@ -113,6 +118,10 @@
     NotificationType.STATE_ESTIMATION_RESULT,
     NotificationType.STATE_ESTIMATION_FAILED,
 ];
+const logicalControlsStatusCompletions = [
+    NotificationType.LOGICAL_CONTROLS_RESULT,
+    NotificationType.LOGICAL_CONTROLS_FAILED,
+];
 const pccMinStatusCompletions = [NotificationType.PCC_MIN_RESULT, NotificationType.PCC_MIN_FAILED];
 
 // result invalidations
@@ -123,6 +132,7 @@
 export const dynamicMarginCalculationResultInvalidations = [NotificationType.DYNAMIC_MARGIN_CALCULATION_RESULT];
 export const voltageInitResultInvalidations = [NotificationType.VOLTAGE_INIT_RESULT];
 export const stateEstimationResultInvalidations = [NotificationType.STATE_ESTIMATION_RESULT];
+export const logicalControlsResultInvalidations = [NotificationType.LOGICAL_CONTROLS_RESULT];
 export const pccMinResultInvalidations = [NotificationType.PCC_MIN_RESULT];
 
 // this hook loads all current computation status into redux then keeps them up to date according to notifications
@@ -268,6 +278,19 @@
         stateEstimationAvailability
     );
 
+    useComputingStatus(
+        studyUuid,
+        currentNodeUuid,
+        currentRootNetworkUuid,
+        fetchLogicalControlsStatus,
+        logicalControlsStatusInvalidations,
+        logicalControlsStatusCompletions,
+        getLogicalControlsRunningStatus,
+        ComputingType.LOGICAL_CONTROLS,
+        undefined,
+        stateEstimationAvailability // logical controls are computed by the state estimation server
+    );
+
     useComputingStatus(
         studyUuid,
         currentNodeUuid,

src/components/result-view-tab.tsx

@@ -23,6 +23,7 @@
 import { useSelector } from 'react-redux';
 import { Box, Paper, Tab, Tabs } from '@mui/material';
 import { StateEstimationResultTab } from './results/stateestimation/state-estimation-result-tab';
+import { LogicalControlsResultTab } from './results/logicalcontrols/logical-controls-result-tab';
 import DynamicSecurityAnalysisResultTab from './results/dynamic-security-analysis/dynamic-security-analysis-result-tab';
 import { ComputingType, type MuiStyles, PARAM_DEVELOPER_MODE, usePrevious } from '@gridsuite/commons-ui';
 import { useParameterState } from './dialogs/parameters/use-parameters-state';
@@ -194,6 +195,18 @@
         );
     }, [studyUuid, currentNode, currentRootNetworkUuid]);
 
+    const renderLogicalControlsResult = useMemo(() => {
+        return (
+            <Paper sx={styles.analysisResult}>
+                <LogicalControlsResultTab
+                    studyUuid={studyUuid}
+                    nodeUuid={currentNode?.id}
+                    currentRootNetworkUuid={currentRootNetworkUuid}
+                />
+            </Paper>
+        );
+    }, [studyUuid, currentNode, currentRootNetworkUuid]);
+
     const renderPccMinResult = useMemo(() => {
         return (
             <Paper sx={styles.analysisResult}>
@@ -262,6 +275,13 @@
                 displayed: isDeveloperMode && stateEstimationAvailability === OptionalServicesStatus.Up,
                 renderResult: renderStateEstimationResult,
             },
+            {
+                id: 'LogicalControls',
+                computingType: [ComputingType.LOGICAL_CONTROLS],
+                // logical controls are computed by the state estimation server
+                displayed: isDeveloperMode && stateEstimationAvailability === OptionalServicesStatus.Up,
+                renderResult: renderLogicalControlsResult,
+            },
             {
                 id: 'PccMin',
                 computingType: [ComputingType.PCC_MIN],
@@ -288,6 +308,7 @@
         renderVoltageInitResult,
         stateEstimationAvailability,
         renderStateEstimationResult,
+        renderLogicalControlsResult,
         pccMinAvailability,
         renderPccMinResult,
     ]);

src/components/results/logicalcontrols/logical-controls-result-tab.tsx

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { FunctionComponent, useMemo } from 'react';
+import type { UUID } from 'node:crypto';
+import { useSelector } from 'react-redux';
+import { ComputingType, RunningStatus } from '@gridsuite/commons-ui';
+import { AppState } from 'redux/reducer.type';
+import { useNodeData } from 'components/use-node-data';
+import { fetchLogicalControlsResult } from '../../../services/study/state-estimation';
+import { logicalControlsResultInvalidations } from '../../computing-status/use-all-computing-status';
+import { LogicalControlsResult } from './logical-controls-result';
+
+interface LogicalControlsResultTabProps {
+    studyUuid: UUID;
+    nodeUuid: UUID;
+    currentRootNetworkUuid: UUID;
+}
+
+export const LogicalControlsResultTab: FunctionComponent<LogicalControlsResultTabProps> = ({
+    studyUuid,
+    nodeUuid,
+    currentRootNetworkUuid,
+}) => {
+    const logicalControlsStatus = useSelector(
+        (state: AppState) => state.computingStatus[ComputingType.LOGICAL_CONTROLS]
+    );
+
+    const { result: logicalControlsResult, isLoading: isLoadingResult } = useNodeData({
+        studyUuid,
+        nodeUuid,
+        rootNetworkUuid: currentRootNetworkUuid,
+        fetcher: fetchLogicalControlsResult,
+        invalidations: logicalControlsResultInvalidations,
+    });
+
+    const isComputationDone =
+        logicalControlsStatus === RunningStatus.SUCCEED || logicalControlsStatus === RunningStatus.FAILED;
+    const isRunning =
+        logicalControlsStatus === RunningStatus.RUNNING || logicalControlsStatus === RunningStatus.PRELOADING;
+
+    const result = useMemo(
+        () => (isComputationDone && logicalControlsResult ? logicalControlsResult : undefined),
+        [isComputationDone, logicalControlsResult]
+    );
+
+    return (
+        <LogicalControlsResult
+            result={result}
+            isLoadingResult={isRunning || isLoadingResult}
+            exportCsvResetKey={`${studyUuid}-${nodeUuid}-${currentRootNetworkUuid}`}
+        />
+    );
+};

src/components/results/stateestimation/logicalcontrols/logical-controls-result.tsx → src/components/results/logicalcontrols/logical-controls-result.tsx

@@ -93,7 +93,6 @@ export const LogicalControlsResult: FunctionComponent<LogicalControlsResultProps
 
             {subTabIndex === BALANCES_TAB_INDEX && (
                 <LogicalControlsTable
-                    resultAvailable={!!result}
                     rows={balances}
                     columnDefs={columnDefs}
                     isLoadingResult={isLoadingResult}
@@ -103,7 +102,6 @@ export const LogicalControlsResult: FunctionComponent<LogicalControlsResultProps
             )}
             {subTabIndex === NON_ZERO_MEASUREMENTS_ON_DISCONNECTED_TAB_INDEX && (
                 <LogicalControlsTable
-                    resultAvailable={!!result}
                     rows={nonZeroMeasurementsOnDisconnected}
                     columnDefs={columnDefs}
                     isLoadingResult={isLoadingResult}
@@ -113,7 +111,6 @@ export const LogicalControlsResult: FunctionComponent<LogicalControlsResultProps
             )}
             {subTabIndex === ZERO_MEASUREMENTS_ON_CONNECTED_TAB_INDEX && (
                 <LogicalControlsTable
-                    resultAvailable={!!result}
                     rows={zeroMeasurementsOnConnected}
                     columnDefs={columnDefs}
                     isLoadingResult={isLoadingResult}
@@ -123,7 +120,6 @@ export const LogicalControlsResult: FunctionComponent<LogicalControlsResultProps
             )}
             {subTabIndex === ORIGIN_EXTREMITY_DEVIATIONS_TAB_INDEX && (
                 <LogicalControlsTable
-                    resultAvailable={!!result}
                     rows={originExtremityDeviations}
                     columnDefs={columnDefs}
                     isLoadingResult={isLoadingResult}
@@ -133,7 +129,6 @@ export const LogicalControlsResult: FunctionComponent<LogicalControlsResultProps
             )}
             {subTabIndex === OUT_OF_BOUNDS_MEASUREMENTS_TAB_INDEX && (
                 <LogicalControlsTable
-                    resultAvailable={!!result}
                     rows={outOfBoundsMeasurements}
                     columnDefs={columnDefs}
                     isLoadingResult={isLoadingResult}
@@ -143,7 +138,6 @@ export const LogicalControlsResult: FunctionComponent<LogicalControlsResultProps
             )}
             {subTabIndex === VOLTAGE_DEVIATIONS_TAB_INDEX && (
                 <LogicalControlsTable
-                    resultAvailable={!!result}
                     rows={voltageDeviations}
                     columnDefs={columnDefs}
                     isLoadingResult={isLoadingResult}

src/components/results/stateestimation/logicalcontrols/logical-controls-table.tsx → src/components/results/logicalcontrols/logical-controls-table.tsx

@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { FunctionComponent, Key, useEffect, useMemo, useRef } from 'react';
+import { FunctionComponent, Key, useMemo, useRef } from 'react';
 import { useIntl } from 'react-intl';
 import { useSelector } from 'react-redux';
 import { Box } from '@mui/material';
 import LinearProgress from '@mui/material/LinearProgress';
 import { AgGridReact } from 'ag-grid-react';
 import {
+    ComputingType,
     DefaultCellRenderer,
     getNoRowsMessage,
     RESULTS_LOADING_DELAY,
-    RunningStatus,
     TableType,
     useIntlResultStatusMessages,
     useOpenLoaderShortWait,
@@ -26,7 +26,6 @@
 import { ColDef } from 'ag-grid-community';
 
 interface LogicalControlsTableProps {
-    resultAvailable: boolean;
     rows: unknown[];
     isLoadingResult: boolean;
     columnDefs: ColDef[];
@@ -35,7 +34,6 @@
 }
 
 export const LogicalControlsTable: FunctionComponent<LogicalControlsTableProps> = ({
-    resultAvailable,
     rows,
     isLoadingResult,
     columnDefs,
@@ -45,6 +43,7 @@
     const intl = useIntl();
     const gridRef = useRef<AgGridReact>(null);
     const language = useSelector((state: AppState) => state[PARAM_COMPUTED_LANGUAGE]);
+    const computationStatus = useSelector((state: AppState) => state.computingStatus[ComputingType.LOGICAL_CONTROLS]);
 
     const tableNameFormatted = intl.formatMessage({ id: tableName });
 
@@ -53,8 +52,6 @@
         delay: RESULTS_LOADING_DELAY,
     });
 
-    const messages = useIntlResultStatusMessages(intl, true);
-
     const defaultColDef = useMemo(
         () => ({
             filter: false,
@@ -70,22 +67,8 @@
         []
     );
 
-    let status = RunningStatus.IDLE;
-    if (isLoadingResult) {
-        status = RunningStatus.RUNNING;
-    } else if (resultAvailable) {
-        status = RunningStatus.SUCCEED;
-    }
-    const overlayNoRowsTemplate = getNoRowsMessage(messages, rows, status, !isLoadingResult);
-
-    // The grid only re-evaluates the no-rows overlay on row data changes. Let's force it
-    // to have a correct updated msg on the tab where the computation starts.
-    useEffect(() => {
-        const api = gridRef.current?.api;
-        if (api?.getDisplayedRowCount() === 0) {
-            api.showNoRowsOverlay();
-        }
-    }, [overlayNoRowsTemplate]);
+    const messages = useIntlResultStatusMessages(intl, true);
+    const overlayNoRowsTemplate = getNoRowsMessage(messages, rows, computationStatus, !isLoadingResult);
 
     return (
         <>
@@ -98,10 +81,11 @@
                 rows={rows}
                 overlayNoRowsTemplate={overlayNoRowsTemplate}
                 skipColumnHeaders={false}
-                computationType={TableType.StateEstimation}
+                computationType={TableType.LogicalControls}
                 computationSubType={tableName}
                 exportCsvResetKey={exportCsvResetKey}
                 language={language}
+                withTooltip
             />
         </>
     );