Verify node type before calling loadflow (#3021)

Signed-off-by: AAJELLAL <[email protected]>

Author: AAJELLAL

src/components/run-button-container.jsx

@@ -18,7 +18,7 @@ import { useDispatch, useSelector } from 'react-redux';
 
 import RunningStatus from './utils/running-status';
 
-import { PARAM_DEVELOPER_MODE } from '../utils/config-params';
+import { PARAM_DEVELOPER_MODE, PARAM_PROVIDER_DYNAFLOW } from '../utils/config-params';
 
 import { useSnackMessage, ComputingType } from '@gridsuite/commons-ui';
 import RunButton from './run-button';
@@ -32,7 +32,7 @@ import {
     startDynamicSimulation,
     stopDynamicSimulation,
 } from '../services/study/dynamic-simulation';
-import { startLoadFlow, stopLoadFlow } from '../services/study/loadflow';
+import { getLoadFlowProvider, startLoadFlow, stopLoadFlow } from '../services/study/loadflow';
 import { startSecurityAnalysis, stopSecurityAnalysis } from '../services/study/security-analysis';
 import { startShortCircuitAnalysis, stopShortCircuitAnalysis } from '../services/study/short-circuit-analysis';
 import { startVoltageInit, stopVoltageInit } from '../services/study/voltage-init';
@@ -41,6 +41,7 @@ import { OptionalServicesNames, OptionalServicesStatus } from './utils/optional-
 import { useOptionalServiceStatus } from '../hooks/use-optional-service-status';
 import { startDynamicSecurityAnalysis, stopDynamicSecurityAnalysis } from '../services/study/dynamic-security-analysis';
 import { useParameterState } from './dialogs/parameters/use-parameters-state';
+import { isSecurityModificationNode } from './graph/tree-node.type.js';
 
 const checkDynamicSimulationParameters = (studyUuid) => {
     return fetchDynamicSimulationParameters(studyUuid).then((params) => {
@@ -137,7 +138,25 @@ export function RunButtonContainer({ studyUuid, currentNode, currentRootNetworkU
         },
         [dispatch, snackError]
     );
-
+    //In DynaFlow, we need to verify that the current node is a security node before starting the computation.
+    const checkLoadFlowProvider = useCallback(
+        (studyUuid, handleComputation) => {
+            if (isSecurityModificationNode(currentNode)) {
+                handleComputation();
+                return;
+            }
+            getLoadFlowProvider(studyUuid).then((provider) => {
+                if (provider === PARAM_PROVIDER_DYNAFLOW) {
+                    snackError({
+                        headerId: 'LoadFlowDynaFlowError',
+                    });
+                } else {
+                    handleComputation();
+                }
+            });
+        },
+        [currentNode, snackError]
+    );
     const handleStartSecurityAnalysis = (contingencyListNames) => {
         startComputationAsync(
             ComputingType.SECURITY_ANALYSIS,
@@ -171,6 +190,26 @@ export function RunButtonContainer({ studyUuid, currentNode, currentRootNetworkU
             'DynamicSimulationRunError'
         );
     };
+    const handleStartLoadFlow = useCallback(
+        (withRatioTapChangers) => {
+            startComputationAsync(
+                ComputingType.LOAD_FLOW,
+                () => {
+                    dispatch(
+                        setComputingStatusParameters(ComputingType.LOAD_FLOW, {
+                            withRatioTapChangers: withRatioTapChangers,
+                        })
+                    );
+                },
+                () => startLoadFlow(studyUuid, currentNode?.id, currentRootNetworkUuid, withRatioTapChangers),
+                () => {},
+                null,
+                'startLoadFlowError',
+                () => {}
+            );
+        },
+        [currentNode?.id, currentRootNetworkUuid, dispatch, startComputationAsync, studyUuid]
+    );
 
     const runnables = useMemo(() => {
         function actionOnRunnables(type, fnStop) {
@@ -184,17 +223,7 @@ export function RunButtonContainer({ studyUuid, currentNode, currentRootNetworkU
             LOAD_FLOW_WITHOUT_RATIO_TAP_CHANGERS: {
                 messageId: 'LoadFlow',
                 startComputation() {
-                    startComputationAsync(
-                        ComputingType.LOAD_FLOW,
-                        () =>
-                            dispatch(
-                                setComputingStatusParameters(ComputingType.LOAD_FLOW, { withRatioTapChangers: false })
-                            ),
-                        () => startLoadFlow(studyUuid, currentNode?.id, currentRootNetworkUuid, false),
-                        () => {},
-                        null,
-                        'startLoadFlowError'
-                    );
+                    checkLoadFlowProvider(studyUuid, () => handleStartLoadFlow(false));
                 },
                 actionOnRunnable() {
                     actionOnRunnables(ComputingType.LOAD_FLOW, () => stopLoadFlow(studyUuid, currentNode?.id, false));
@@ -203,17 +232,7 @@ export function RunButtonContainer({ studyUuid, currentNode, currentRootNetworkU
             LOAD_FLOW_WITH_RATIO_TAP_CHANGERS: {
                 messageId: 'LoadFlowWithRatioTapChangers',
                 startComputation() {
-                    startComputationAsync(
-                        ComputingType.LOAD_FLOW,
-                        () =>
-                            dispatch(
-                                setComputingStatusParameters(ComputingType.LOAD_FLOW, { withRatioTapChangers: true })
-                            ),
-                        () => startLoadFlow(studyUuid, currentNode?.id, currentRootNetworkUuid, true),
-                        () => {},
-                        null,
-                        'startLoadFlowError'
-                    );
+                    checkLoadFlowProvider(studyUuid, () => handleStartLoadFlow(true));
                 },
                 actionOnRunnable() {
                     actionOnRunnables(ComputingType.LOAD_FLOW, () => stopLoadFlow(studyUuid, currentNode?.id, true));
@@ -370,7 +389,16 @@ export function RunButtonContainer({ studyUuid, currentNode, currentRootNetworkU
                 },
             },
         };
-    }, [dispatch, snackError, startComputationAsync, studyUuid, currentNode?.id, currentRootNetworkUuid]);
+    }, [
+        dispatch,
+        checkLoadFlowProvider,
+        studyUuid,
+        handleStartLoadFlow,
+        currentNode?.id,
+        currentRootNetworkUuid,
+        startComputationAsync,
+        snackError,
+    ]);
 
     // running status is refreshed more often, so we memoize it apart
     const getRunningStatus = useCallback(

src/services/study/loadflow.ts

@@ -38,6 +38,13 @@ export function getLoadFlowParameters(studyUuid: UUID) {
     return backendFetchJson(getLfParams);
 }
 
+export function getLoadFlowProvider(studyUuid: UUID) {
+    console.info('get load flow provider');
+    const getLfParams = getStudyUrl(studyUuid) + '/loadflow/provider';
+    console.debug(getLfParams);
+    return backendFetchText(getLfParams);
+}
+
 export function getLoadFlowParametersId(studyUuid: UUID) {
     console.info('get load flow parameters id');
     const getLoadFlowParametersIdUrl = getStudyUrl(studyUuid) + '/loadflow/parameters/id';

src/translations/en.json

@@ -349,6 +349,7 @@
     "SensitivityInDeltaA": "Sensitivity on branches in ΔA",
     "SensitivityAtNode": "Sensitivity at nodes",
     "LoadFlowError": "An error occurred when executing loadflow",
+    "LoadFlowDynaFlowError": "You must run DynaFlow from a security type node",
     "ShortCircuitAnalysis": "Short circuit analysis",
     "ShortCircuitAnalysisParameters": "Short circuit analysis parameters",
     "startShortCircuitError": "An error occurred while starting the short circuit analysis",

src/translations/fr.json

@@ -347,6 +347,7 @@
     "SensitivityInDeltaA": "Sensibilité au niveau des quadripôles en ΔA",
     "SensitivityAtNode": "Nœuds",
     "LoadFlowError": "Une erreur est survenue lors de l'exécution du calcul de répartition",
+    "LoadFlowDynaFlowError": "Vous devez lancer DynaFlow à partir d'un noeud de type sécurité",
     "ShortCircuitAnalysis": "Analyse de court-circuit",
     "ShortCircuitAnalysisParameters": "Paramètres de l'analyse de court-circuit",
     "startShortCircuitError": "Une erreur est survenue lors du lancement de l'analyse de court-circuit",

src/utils/config-params.ts

@@ -30,6 +30,7 @@ export const PARAM_SA_HIGH_VOLTAGE_ABSOLUTE_THRESHOLD = 'highVoltageAbsoluteThre
 
 // Param values
 export const PARAM_PROVIDER_OPENLOADFLOW = 'OpenLoadFlow';
+export const PARAM_PROVIDER_DYNAFLOW = 'DynaFlow';
 
 export const basemap_style_theme_key = (basemap: string) => basemap + 'Style';