[Dynamic Margin Calculation] Functional implementation

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

@@ -7,6 +7,7 @@
 
 import { useComputingStatus } from './use-computing-status';
 import {
+    getDynamicMarginCalculationRunningStatus,
     getDynamicSecurityAnalysisRunningStatus,
     getDynamicSimulationRunningStatus,
     getLoadFlowRunningStatus,
@@ -28,11 +29,12 @@ import {
     fetchShortCircuitAnalysisStatus,
 } from '../../services/study/short-circuit-analysis';
 import { fetchVoltageInitStatus } from '../../services/study/voltage-init';
-import { fetchLoadFlowStatus, fetchLoadFlowComputationInfos } from '../../services/study/loadflow';
+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 { fetchDynamicSecurityAnalysisStatus } from '../../services/study/dynamic-security-analysis';
+import { fetchDynamicMarginCalculationStatus } from '../../services/study/dynamic-margin-calculation';
 import { NotificationType } from 'types/notification-types';
 import { fetchPccMinStatus } from 'services/study/pcc-min';
 
@@ -62,6 +64,10 @@ const dynamicSecurityAnalysisStatusInvalidations = [
     NotificationType.DYNAMIC_SECURITY_ANALYSIS_STATUS,
     NotificationType.DYNAMIC_SECURITY_ANALYSIS_FAILED,
 ];
+const dynamicMarginCalculationStatusInvalidations = [
+    NotificationType.DYNAMIC_MARGIN_CALCULATION_STATUS,
+    NotificationType.DYNAMIC_MARGIN_CALCULATION_FAILED,
+];
 const voltageInitStatusInvalidations = [NotificationType.VOLTAGE_INIT_STATUS, NotificationType.VOLTAGE_INIT_FAILED];
 const stateEstimationStatusInvalidations = [
     NotificationType.STATE_ESTIMATION_STATUS,
@@ -95,6 +101,10 @@ const dynamicSecurityAnalysisStatusCompletions = [
     NotificationType.DYNAMIC_SECURITY_ANALYSIS_RESULT,
     NotificationType.DYNAMIC_SECURITY_ANALYSIS_FAILED,
 ];
+const dynamicMarginCalculationStatusCompletions = [
+    NotificationType.DYNAMIC_MARGIN_CALCULATION_RESULT,
+    NotificationType.DYNAMIC_MARGIN_CALCULATION_FAILED,
+];
 const voltageInitStatusCompletions = [NotificationType.VOLTAGE_INIT_RESULT, NotificationType.VOLTAGE_INIT_FAILED];
 const stateEstimationStatusCompletions = [
     NotificationType.STATE_ESTIMATION_RESULT,
@@ -107,6 +117,7 @@ export const loadflowResultInvalidations = [NotificationType.LOADFLOW_RESULT];
 export const securityAnalysisResultInvalidations = [NotificationType.SECURITY_ANALYSIS_RESULT];
 export const dynamicSimulationResultInvalidations = [NotificationType.DYNAMIC_SIMULATION_RESULT];
 export const dynamicSecurityAnalysisResultInvalidations = [NotificationType.DYNAMIC_SECURITY_ANALYSIS_RESULT];
+export const dynamicMarginCalculationResultInvalidations = [NotificationType.DYNAMIC_MARGIN_CALCULATION_RESULT];
 export const voltageInitResultInvalidations = [NotificationType.VOLTAGE_INIT_RESULT];
 export const stateEstimationResultInvalidations = [NotificationType.STATE_ESTIMATION_RESULT];
 export const pccMinResultInvalidations = [NotificationType.PCC_MIN_RESULT];
@@ -117,6 +128,9 @@ export const useAllComputingStatus = (studyUuid: UUID, currentNodeUuid: UUID, cu
     const sensitivityAnalysisAvailability = useOptionalServiceStatus(OptionalServicesNames.SensitivityAnalysis);
     const dynamicSimulationAvailability = useOptionalServiceStatus(OptionalServicesNames.DynamicSimulation);
     const dynamicSecurityAnalysisAvailability = useOptionalServiceStatus(OptionalServicesNames.DynamicSecurityAnalysis);
+    const dynamicMarginCalculationAvailability = useOptionalServiceStatus(
+        OptionalServicesNames.DynamicMarginCalculation
+    );
     const voltageInitAvailability = useOptionalServiceStatus(OptionalServicesNames.VoltageInit);
     const shortCircuitAvailability = useOptionalServiceStatus(OptionalServicesNames.ShortCircuit);
     const stateEstimationAvailability = useOptionalServiceStatus(OptionalServicesNames.StateEstimation);
@@ -212,6 +226,19 @@ export const useAllComputingStatus = (studyUuid: UUID, currentNodeUuid: UUID, cu
         dynamicSecurityAnalysisAvailability
     );
 
+    useComputingStatus(
+        studyUuid,
+        currentNodeUuid,
+        currentRootNetworkUuid,
+        fetchDynamicMarginCalculationStatus,
+        dynamicMarginCalculationStatusInvalidations,
+        dynamicMarginCalculationStatusCompletions,
+        getDynamicMarginCalculationRunningStatus,
+        ComputingType.DYNAMIC_MARGIN_CALCULATION,
+        undefined,
+        dynamicMarginCalculationAvailability
+    );
+
     useComputingStatus(
         studyUuid,
         currentNodeUuid,

src/components/grid-layout/cards/diagrams/singleLineDiagram/single-line-diagram-content.tsx

@@ -5,7 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-import { useCallback, useLayoutEffect, useRef, useState, memo } from 'react';
+import { memo, useCallback, useLayoutEffect, useRef, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { RunningStatus } from '../../../../utils/running-status';
 import {
@@ -33,9 +33,9 @@ import {
     ComputingType,
     EquipmentType,
     mergeSx,
+    PARAM_DEVELOPER_MODE,
     snackWithFallback,
     useSnackMessage,
-    PARAM_DEVELOPER_MODE,
 } from '@gridsuite/commons-ui';
 import Box from '@mui/material/Box';
 import LinearProgress from '@mui/material/LinearProgress';
@@ -50,11 +50,11 @@ import { useParameterState } from 'components/dialogs/parameters/use-parameters-
 import { DiagramType, type SubstationDiagramParams, type VoltageLevelDiagramParams } from '../diagram.type';
 import { useEquipmentMenu } from '../../../../../hooks/use-equipment-menu';
 import useEquipmentDialogs from 'hooks/use-equipment-dialogs';
-import useComputationDebug from '../../../../../hooks/use-computation-debug';
 
 import GenericEquipmentPopover from 'components/tooltips/generic-equipment-popover';
 import { GenericEquipmentInfos } from 'components/tooltips/equipment-popover-type';
 import { GenericPopoverContent } from 'components/tooltips/generic-popover-content';
+import useDebugSubscription from '../../../../../hooks/computation-debug/use-debug-subscription';
 
 interface SingleLineDiagramContentProps {
     readonly showInSpreadsheet: (menu: { equipmentId: string | null; equipmentType: EquipmentType | null }) => void;
@@ -217,7 +217,7 @@ const SingleLineDiagramContent = memo(function SingleLineDiagramContent(props: S
     );
 
     // --- for running in debug mode --- //
-    const subscribeDebug = useComputationDebug({
+    const subscribeDebug = useDebugSubscription({
         studyUuid: studyUuid,
         nodeUuid: currentNode?.id!,
         rootNetworkUuid: currentRootNetworkUuid!,

src/components/parameters-tabs.tsx

@@ -47,6 +47,8 @@
 import type { UUID } from 'node:crypto';
 import {
     ComputingType,
+    DynamicMarginCalculationInline,
+    fetchDynamicMarginCalculationProviders,
     fetchSecurityAnalysisProviders,
     getSecurityAnalysisDefaultLimitReductions,
     LoadFlowParametersInline,
@@ -69,6 +71,11 @@
 } from 'services/study/short-circuit-analysis';
 import { useGetPccMinParameters } from './dialogs/parameters/use-get-pcc-min-parameters';
 import { useWorkspacePanelActions } from './workspace/hooks/use-workspace-panel-actions';
+import { fetchDefaultDynamicSecurityAnalysisProvider } from '../services/study/dynamic-security-analysis';
+import {
+    fetchDynamicMarginCalculationParameters,
+    updateDynamicMarginCalculationParameters,
+} from '../services/study/dynamic-margin-calculation';
 
 enum TAB_VALUES {
     lfParamsTabValue = 'LOAD_FLOW',
@@ -77,6 +84,7 @@
     shortCircuitParamsTabValue = 'SHORT_CIRCUIT',
     dynamicSimulationParamsTabValue = 'DYNAMIC_SIMULATION',
     dynamicSecurityAnalysisParamsTabValue = 'DYNAMIC_SECURITY_ANALYSIS',
+    dynamicMarginCalculationParamsTabValue = 'DYNAMIC_MARGIN_CALCULATION',
     voltageInitParamsTabValue = 'VOLTAGE_INITIALIZATION',
     stateEstimationTabValue = 'STATE_ESTIMATION',
     pccMinTabValue = 'PCC_MIN',
@@ -106,6 +114,9 @@
     const sensitivityAnalysisAvailability = useOptionalServiceStatus(OptionalServicesNames.SensitivityAnalysis);
     const dynamicSimulationAvailability = useOptionalServiceStatus(OptionalServicesNames.DynamicSimulation);
     const dynamicSecurityAnalysisAvailability = useOptionalServiceStatus(OptionalServicesNames.DynamicSecurityAnalysis);
+    const dynamicMarginCalculationAvailability = useOptionalServiceStatus(
+        OptionalServicesNames.DynamicMarginCalculation
+    );
     const voltageInitAvailability = useOptionalServiceStatus(OptionalServicesNames.VoltageInit);
     const shortCircuitAvailability = useOptionalServiceStatus(OptionalServicesNames.ShortCircuit);
     const stateEstimationAvailability = useOptionalServiceStatus(OptionalServicesNames.StateEstimation);
@@ -192,7 +203,7 @@
         ComputingType.SHORT_CIRCUIT,
         OptionalServicesStatus.Up,
         null,
-        null,
+        fetchDefaultDynamicSecurityAnalysisProvider,
         null,
         null,
         getShortCircuitParameters,
@@ -201,6 +212,24 @@
     );
     useParametersNotification(ComputingType.SHORT_CIRCUIT, OptionalServicesStatus.Up, shortCircuitParametersBackend);
 
+    const dynamicMarginCalculationParametersBackend = useParametersBackend(
+        user,
+        studyUuid,
+        ComputingType.DYNAMIC_MARGIN_CALCULATION,
+        dynamicMarginCalculationAvailability,
+        fetchDynamicMarginCalculationProviders,
+        null,
+        null,
+        null,
+        fetchDynamicMarginCalculationParameters,
+        updateDynamicMarginCalculationParameters
+    );
+    useParametersNotification(
+        ComputingType.DYNAMIC_MARGIN_CALCULATION,
+        dynamicMarginCalculationAvailability,
+        dynamicMarginCalculationParametersBackend
+    );
+
     const pccMinParameters = useGetPccMinParameters();
     const voltageInitParameters = useGetVoltageInitParameters();
     const useStateEstimationParameters = useGetStateEstimationParameters();
@@ -269,7 +298,8 @@
                         oldValue === TAB_VALUES.shortCircuitParamsTabValue ||
                         oldValue === TAB_VALUES.pccMinTabValue ||
                         oldValue === TAB_VALUES.dynamicSimulationParamsTabValue ||
-                        oldValue === TAB_VALUES.dynamicSecurityAnalysisParamsTabValue)) ||
+                        oldValue === TAB_VALUES.dynamicSecurityAnalysisParamsTabValue ||
+                        oldValue === TAB_VALUES.dynamicMarginCalculationParamsTabValue)) ||
                 oldValue === TAB_VALUES.stateEstimationTabValue
             ) {
                 return TAB_VALUES.securityAnalysisParamsTabValue;
@@ -331,6 +361,15 @@
                 return <DynamicSimulationParameters user={user} setHaveDirtyFields={setDirtyFields} />;
             case TAB_VALUES.dynamicSecurityAnalysisParamsTabValue:
                 return <DynamicSecurityAnalysisParameters user={user} setHaveDirtyFields={setDirtyFields} />;
+            case TAB_VALUES.dynamicMarginCalculationParamsTabValue:
+                return (
+                    <DynamicMarginCalculationInline
+                        studyUuid={studyUuid}
+                        setHaveDirtyFields={setDirtyFields}
+                        parametersBackend={dynamicMarginCalculationParametersBackend}
+                    />
+                );
+
             case TAB_VALUES.voltageInitParamsTabValue:
                 return (
                     <VoltageInitParametersInLine
@@ -370,6 +409,7 @@
         shortCircuitParametersBackend,
         pccMinParameters,
         user,
+        dynamicMarginCalculationParametersBackend,
         voltageInitParameters,
         useStateEstimationParameters,
         networkVisualizationsParameters,
@@ -435,6 +475,13 @@
                                     value={TAB_VALUES.dynamicSecurityAnalysisParamsTabValue}
                                 />
                             ) : null}
+                            {isDeveloperMode ? (
+                                <Tab
+                                    disabled={dynamicMarginCalculationAvailability !== OptionalServicesStatus.Up}
+                                    label={<FormattedMessage id="DynamicMarginCalculation" />}
+                                    value={TAB_VALUES.dynamicMarginCalculationParamsTabValue}
+                                />
+                            ) : null}
                             <Tab
                                 disabled={voltageInitAvailability !== OptionalServicesStatus.Up}
                                 label={<FormattedMessage id="VoltageInit" />}

src/components/result-view-tab.tsx

@@ -29,6 +29,7 @@ import { useParameterState } from './dialogs/parameters/use-parameters-state';
 import { IService } from './result-view-tab.type';
 import { CurrentTreeNode } from './graph/tree-node.type';
 import { PccMinResultTab } from './results/pccmin/pcc-min-result-tab';
+import DynamicMarginCalculationResultTab from './results/dynamic-margin-calculation/dynamic-margin-calculation-result-tab';
 
 const styles = {
     table: {
@@ -77,6 +78,9 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
     const sensitivityAnalysisUnavailability = useOptionalServiceStatus(OptionalServicesNames.SensitivityAnalysis);
     const dynamicSimulationAvailability = useOptionalServiceStatus(OptionalServicesNames.DynamicSimulation);
     const dynamicSecurityAnalysisAvailability = useOptionalServiceStatus(OptionalServicesNames.DynamicSecurityAnalysis);
+    const dynamicMarginCalculationAvailability = useOptionalServiceStatus(
+        OptionalServicesNames.DynamicMarginCalculation
+    );
     const voltageInitAvailability = useOptionalServiceStatus(OptionalServicesNames.VoltageInit);
     const shortCircuitAvailability = useOptionalServiceStatus(OptionalServicesNames.ShortCircuit);
     const stateEstimationAvailability = useOptionalServiceStatus(OptionalServicesNames.StateEstimation);
@@ -166,6 +170,18 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
         );
     }, [studyUuid, currentNode, currentRootNetworkUuid]);
 
+    const renderDynamicMarginCalculationResult = useMemo(() => {
+        return (
+            <Paper sx={styles.analysisResult}>
+                <DynamicMarginCalculationResultTab
+                    studyUuid={studyUuid}
+                    nodeUuid={currentNode?.id}
+                    currentRootNetworkUuid={currentRootNetworkUuid}
+                />
+            </Paper>
+        );
+    }, [studyUuid, currentNode, currentRootNetworkUuid]);
+
     const renderStateEstimationResult = useMemo(() => {
         return (
             <Paper sx={styles.analysisResult}>
@@ -228,6 +244,12 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
                 displayed: isDeveloperMode && dynamicSecurityAnalysisAvailability === OptionalServicesStatus.Up,
                 renderResult: renderDynamicSecurityAnalysisResult,
             },
+            {
+                id: 'DynamicMarginCalculation',
+                computingType: [ComputingType.DYNAMIC_MARGIN_CALCULATION],
+                displayed: isDeveloperMode && dynamicMarginCalculationAvailability === OptionalServicesStatus.Up,
+                renderResult: renderDynamicMarginCalculationResult,
+            },
             {
                 id: 'VoltageInit',
                 computingType: [ComputingType.VOLTAGE_INITIALIZATION],
@@ -260,6 +282,8 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
         renderDynamicSimulationResult,
         dynamicSecurityAnalysisAvailability,
         renderDynamicSecurityAnalysisResult,
+        dynamicMarginCalculationAvailability,
+        renderDynamicMarginCalculationResult,
         voltageInitAvailability,
         renderVoltageInitResult,
         stateEstimationAvailability,

src/components/results/dynamic-margin-calculation/dynamic-margin-calculation-result-logs.tsx

@@ -0,0 +1,46 @@
+/**
+ * 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 { ComputationReportViewer } from '../common/computation-report-viewer';
+import { memo, useMemo } from 'react';
+import { useSelector } from 'react-redux';
+import { AppState } from '../../../redux/reducer';
+import { ComputingType } from '@gridsuite/commons-ui';
+import RunningStatus from '../../utils/running-status';
+import { useIntlResultStatusMessages } from '../../utils/aggrid-rows-handler';
+import { useIntl } from 'react-intl';
+import Overlay from '../common/Overlay';
+
+const DynamicMarginCalculationResultLogs = memo(() => {
+    const dynamicMarginCalculationStatus = useSelector(
+        (state: AppState) => state.computingStatus[ComputingType.DYNAMIC_MARGIN_CALCULATION]
+    );
+
+    const intl = useIntl();
+    const messages = useIntlResultStatusMessages(intl);
+
+    const overlayMessage = useMemo(() => {
+        switch (dynamicMarginCalculationStatus) {
+            case RunningStatus.IDLE:
+                return messages.noCalculation;
+            case RunningStatus.RUNNING:
+                return messages.running;
+            case RunningStatus.FAILED:
+            case RunningStatus.SUCCEED:
+                return undefined;
+            default:
+                return messages.noCalculation;
+        }
+    }, [dynamicMarginCalculationStatus, messages]);
+    return (
+        <Overlay message={overlayMessage}>
+            <ComputationReportViewer reportType={ComputingType.DYNAMIC_MARGIN_CALCULATION} />
+        </Overlay>
+    );
+});
+
+export default DynamicMarginCalculationResultLogs;