add pcc min results and logs

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

@@ -109,6 +109,7 @@ export const dynamicSimulationResultInvalidations = [NotificationType.DYNAMIC_SI
 export const dynamicSecurityAnalysisResultInvalidations = [NotificationType.DYNAMIC_SECURITY_ANALYSIS_RESULT];
 export const voltageInitResultInvalidations = [NotificationType.VOLTAGE_INIT_RESULT];
 export const stateEstimationResultInvalidations = [NotificationType.STATE_ESTIMATION_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
 export const useAllComputingStatus = (studyUuid: UUID, currentNodeUuid: UUID, currentRootNetworkUuid: UUID): void => {

src/components/graph/tree-node.type.ts

@@ -60,6 +60,7 @@ export type NetworkModificationNodeData = AbstractNode & {
     sensitivityAnalysisResultUuid?: UUID;
     dynamicSimulationResultUuid?: UUID;
     stateEstimationResultUuid?: UUID;
+    pccMinResultUuid?: UUID;
     nodeBuildStatus?: NodeBuildStatus;
     nodeType?: NetworkModificationNodeType;
 };

src/components/result-view-tab.tsx

@@ -29,6 +29,7 @@ import { ComputingType, type MuiStyles, usePrevious } from '@gridsuite/commons-u
 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';
 
 const styles = {
     table: {
@@ -85,6 +86,7 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
     const voltageInitAvailability = useOptionalServiceStatus(OptionalServicesNames.VoltageInit);
     const shortCircuitAvailability = useOptionalServiceStatus(OptionalServicesNames.ShortCircuit);
     const stateEstimationAvailability = useOptionalServiceStatus(OptionalServicesNames.StateEstimation);
+    const pccMinAvailability = useOptionalServiceStatus(OptionalServicesNames.PccMin);
 
     const renderLoadFlowResult = useMemo(() => {
         return (
@@ -186,6 +188,18 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
         );
     }, [studyUuid, currentNode, currentRootNetworkUuid]);
 
+    const renderPccMinResult = useMemo(() => {
+        return (
+            <Paper sx={styles.analysisResult}>
+                <PccMinResultTab
+                    studyUuid={studyUuid}
+                    nodeUuid={currentNode?.id}
+                    currentRootNetworkUuid={currentRootNetworkUuid}
+                />
+            </Paper>
+        );
+    }, [currentNode?.id, currentRootNetworkUuid, studyUuid]);
+
     const services: IService[] = useMemo(() => {
         return [
             {
@@ -236,24 +250,32 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
                 displayed: enableDeveloperMode && stateEstimationAvailability === OptionalServicesStatus.Up,
                 renderResult: renderStateEstimationResult,
             },
+            {
+                id: 'PccMin',
+                computingType: [ComputingType.PCC_MIN],
+                displayed: enableDeveloperMode && pccMinAvailability === OptionalServicesStatus.Up,
+                renderResult: renderPccMinResult,
+            },
         ].filter(({ displayed }: IService) => displayed);
     }, [
-        sensitivityAnalysisUnavailability,
+        renderLoadFlowResult,
         securityAnalysisAvailability,
-        dynamicSimulationAvailability,
-        dynamicSecurityAnalysisAvailability,
-        voltageInitAvailability,
+        renderSecurityAnalysisResult,
+        sensitivityAnalysisUnavailability,
+        renderSensitivityAnalysisResult,
         shortCircuitAvailability,
-        stateEstimationAvailability,
+        renderShortCircuitAnalysisResult,
         enableDeveloperMode,
+        dynamicSimulationAvailability,
         renderDynamicSimulationResult,
+        dynamicSecurityAnalysisAvailability,
         renderDynamicSecurityAnalysisResult,
-        renderSecurityAnalysisResult,
-        renderSensitivityAnalysisResult,
-        renderShortCircuitAnalysisResult,
+        voltageInitAvailability,
         renderVoltageInitResult,
-        renderLoadFlowResult,
+        stateEstimationAvailability,
         renderStateEstimationResult,
+        pccMinAvailability,
+        renderPccMinResult,
     ]);
 
     const resultTabIndexRedirection = useMemo<ResultTabIndexRedirection>(

src/components/results/pccmin/pcc-min-result-tab.tsx

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2025, 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, SyntheticEvent, useMemo, useState } from 'react';
+import Tabs from '@mui/material/Tabs';
+import Tab from '@mui/material/Tab';
+import Box from '@mui/material/Box';
+import { FormattedMessage, useIntl } from 'react-intl/lib';
+import RunningStatus from 'components/utils/running-status';
+import { AppState } from 'redux/reducer';
+import { ComputingType, type MuiStyles } from '@gridsuite/commons-ui';
+import { useSelector } from 'react-redux';
+import GlassPane from '../common/glass-pane';
+
+import { ComputationReportViewer } from '../common/computation-report-viewer';
+import { useNodeData } from 'components/use-node-data';
+import { PccMinTabProps } from './pcc-min-result.type';
+import { fetchPccMinResult } from 'services/study/pcc-min';
+import { pccMinResultInvalidations } from 'components/computing-status/use-all-computing-status';
+import { pccMinResultColumnsDefinition } from './pcc-min-result-utils';
+import { PccMinResults } from './pcc-min-results';
+
+const styles = {
+    flexWrapper: {
+        display: 'flex',
+    },
+    flexElement: {
+        flexGrow: 0,
+    },
+    show: {
+        display: 'inherit',
+    },
+    hide: {
+        display: 'none',
+    },
+    emptySpace: {
+        flexGrow: 1,
+    },
+} as const satisfies MuiStyles;
+
+export const PccMinResultTab: FunctionComponent<PccMinTabProps> = ({ studyUuid, nodeUuid, currentRootNetworkUuid }) => {
+    const intl = useIntl();
+
+    const [tabIndex, setTabIndex] = useState(0);
+    const PccMinStatus = useSelector((state: AppState) => state.computingStatus[ComputingType.PCC_MIN]);
+
+    const { result: PccMinResult, isLoading: isLoadingResult } = useNodeData({
+        studyUuid,
+        nodeUuid,
+        rootNetworkUuid: currentRootNetworkUuid,
+        fetcher: fetchPccMinResult,
+        invalidations: pccMinResultInvalidations,
+    });
+
+    const pccMinColumns = useMemo(() => {
+        return pccMinResultColumnsDefinition(intl);
+    }, [intl]);
+
+    const handleTabChange = (_event: SyntheticEvent, newTabIndex: number) => {
+        setTabIndex(newTabIndex);
+    };
+
+    const result = useMemo(() => {
+        if (PccMinStatus !== RunningStatus.SUCCEED || !PccMinResult) {
+            return {};
+        }
+        return PccMinResult;
+    }, [PccMinStatus, PccMinResult]);
+
+    const renderReportViewer = () => {
+        return (
+            <GlassPane active={isLoadingResult}>
+                {(PccMinStatus === RunningStatus.SUCCEED || PccMinStatus === RunningStatus.FAILED) && (
+                    <ComputationReportViewer reportType={ComputingType.PCC_MIN} />
+                )}
+            </GlassPane>
+        );
+    };
+
+    return (
+        <>
+            <Box sx={styles.flexWrapper}>
+                <Tabs value={tabIndex} onChange={handleTabChange} sx={styles.flexElement}>
+                    <Tab label={<FormattedMessage id={'Results'} />} />
+                    <Tab label={<FormattedMessage id={'ComputationResultsLogs'} />} />
+                </Tabs>
+                <Box sx={styles.emptySpace}></Box>
+            </Box>
+
+            {tabIndex === 0 && (
+                <GlassPane active={isLoadingResult}>
+                    <PccMinResults
+                        result={result}
+                        isLoadingResult={isLoadingResult}
+                        columnDefs={pccMinColumns}
+                        tableName="Results"
+                    />
+                </GlassPane>
+            )}
+            {tabIndex === 1 && renderReportViewer()}
+        </>
+    );
+};

src/components/results/pccmin/pcc-min-result-utils.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2025, 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 { IntlShape } from 'react-intl';
+import { ColDef } from 'ag-grid-community';
+import { makeAgGridCustomHeaderColumn } from 'components/custom-aggrid/utils/custom-aggrid-header-utils';
+
+export const pccMinResultColumnsDefinition = (intl: IntlShape): ColDef[] => {
+    return [
+        makeAgGridCustomHeaderColumn({
+            headerName: intl.formatMessage({ id: 'Bus' }),
+            colId: 'busId',
+            field: 'busId',
+        }),
+        makeAgGridCustomHeaderColumn({
+            headerName: intl.formatMessage({ id: 'PccMinTri' }),
+            colId: 'pccMinTri',
+            field: 'pccMinTri',
+            context: { numeric: true, fractionDigits: 2 },
+        }),
+        makeAgGridCustomHeaderColumn({
+            headerName: intl.formatMessage({ id: 'IccMin' }),
+            colId: 'iccMinTri',
+            field: 'iccMinTri',
+            context: { numeric: true, fractionDigits: 2 },
+        }),
+        makeAgGridCustomHeaderColumn({
+            headerName: intl.formatMessage({ id: 'Contingency' }),
+            colId: 'limitingEquipment',
+            field: 'limitingEquipment',
+        }),
+        makeAgGridCustomHeaderColumn({
+            headerName: intl.formatMessage({ id: 'xOhm' }),
+            colId: 'x',
+            field: 'x',
+            context: { numeric: true, fractionDigits: 2 },
+        }),
+        makeAgGridCustomHeaderColumn({
+            headerName: intl.formatMessage({ id: 'rOhm' }),
+            colId: 'r',
+            field: 'r',
+            context: { numeric: true, fractionDigits: 2 },
+        }),
+    ];
+};

src/components/results/pccmin/pcc-min-result.type.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2025, 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 { ColDef } from 'ag-grid-community';
+import type { UUID } from 'node:crypto';
+
+export interface PccMinResult {
+    resultUuid: UUID;
+    writeTimeStamp: Date;
+    singlePccMinResultInfos: SinglePccMinResultInfos[];
+}
+export interface SinglePccMinResultInfos {
+    singlePccMinResultUuid: string;
+    busId: String;
+    pccMinTri: number;
+    limitingEquipment: String;
+    x: number;
+    r: number;
+}
+
+export interface PccMinTabProps {
+    studyUuid: UUID;
+    nodeUuid: UUID;
+    currentRootNetworkUuid: UUID;
+}
+
+export interface PccMinResultTableProps {
+    isLoadingResult: boolean;
+    columnDefs: ColDef<any>[];
+    tableName: string;
+}
+
+export interface PccMinResultStatusProps {
+    result: PccMinResult;
+}
+
+export interface PccMinResultProps extends PccMinResultTableProps, PccMinResultStatusProps {}