A method and device for analyzing uncertainty of a nuclear power mechanism model

Abstract

The application discloses a kind of uncertainty analysis method and device for nuclear power mechanism model, wherein, method includes the following steps: step S1, according to the logical order of uncertainty analysis task, select functional module from function library to construct function flow;Step S2, each the input interface and output interface of the functional module are defined based on unified shared data model, business data is automatically transferred between function flows based on the shared data model, the reliability of business data transmission is guaranteed using intermediate storage and state management, and the business data state is updated in real time;Step S3, the trigger relationship between the functional modules of function flow is bound through event bus and each functional module is sequentially triggered, and the analysis task is automatically executed;Step S4, the function flow is decoupled, and is combined into service through API, to realize the reuse of functional module.The uncertainty analysis method provided by the application has high data continuity and high operation concentration.

Description

Technical Field

[0001] This invention relates to the field of uncertainty analysis technology for nuclear power software, and in particular to an uncertainty analysis method and apparatus for nuclear power mechanism models. Background Technology

[0002] In the safety analysis, design, and operational assessment of nuclear fuel in nuclear power plants, nuclear electrical mechanism models are widely used for accurate system modeling and simulation prediction. Furthermore, uncertainty analysis is often required for complex nuclear electrical mechanism models to assess the sensitivity of input parameters to output results and the propagation of uncertainty, ultimately evaluating the safety of the structural design based on the nuclear electrical mechanism model. Uncertainty analysis encompasses multiple aspects, including uncertainty measurement, sensitivity analysis, uncertainty propagation, and structural reliability optimization.

[0003] Traditional uncertainty analysis software is mostly function-oriented, with functions as the main body and analysis tasks as the workflow. It breaks down business into multiple independent functional interfaces according to task logic, and users need to frequently switch between multiple interfaces to complete a complete business process.

[0004] However, cross-interface operations require repeated data input, and the calls to business data by different functional entities are quite scattered, resulting in a discontinuity between business operations and business logic. Although existing technologies can connect functions, they still rely on multiple interface jumps and do not fundamentally solve the problems of data continuity and operation centralization. Summary of the Invention

[0005] In view of this, it is necessary to provide a method and apparatus for uncertainty analysis of nuclear electrical mechanism models, so as to effectively solve the problem that uncertainty analysis of nuclear electrical mechanism models relies on multiple interface jumps and cannot achieve data continuity and operation centralization.

[0006] This invention provides an uncertainty analysis method for nuclear electrical mechanism models, comprising the following steps:

[0007] Step S1: Select functional modules from the function library to construct a function flow according to the logical order of the uncertainty analysis task;

[0008] Step S2: Each of the functional modules defines input and output interfaces based on a unified shared data model. Business data is automatically transferred between functional flows based on the shared data model. Intermediate storage and status management are used to ensure the reliability of business data transfer and to update the status of business data in real time.

[0009] Step S3: Bind the triggering relationship between each functional module of the function flow through the event bus and trigger each functional module in sequence to automatically execute the analysis task;

[0010] Step S4: Decouple the functional flow and combine it into a service through API to realize the reuse of functional modules.

[0011] Preferably, step S1 specifically involves: pre-defining or customizing the function flow according to the logical order of the uncertainty analysis task;

[0012] The generation of the predefined function flow is specifically as follows: select functional modules that conform to the analysis task from the function library, configure a fixed execution order of functional modules according to the logical order of the analysis task, arrange the selected functional modules based on the execution order to form a standardized process, and obtain the predefined function flow;

[0013] The generation of the custom function flow is as follows: based on the user's real-time needs, a function module is manually selected from the function library, and the data interface compatibility between the selected function modules is automatically checked. If they are incompatible, the user is prompted to make adjustments or additions. If they are compatible, the custom function flow is generated based on the selected function modules.

[0014] Preferably, in step S2, each functional module defines its input and output interfaces based on a unified shared data model, specifically as follows:

[0015] The various analysis tasks are refined and broken down into standardized steps. Based on the shared data model, the input interface, output interface, and business rules of each standardized step are defined. Each standardized step is encapsulated as a functional module of a standardized interface and stored in the functional library.

[0016] Preferably, in step S2, the business data is automatically transferred between functional flows based on the shared data model, specifically as follows:

[0017] The shared data model defines the data transfer rules between functional modules, and business data is automatically transferred between functional flows based on these rules.

[0018] Preferably, in step S2, intermediate storage and state management are used to enhance the reliability of data transmission, specifically as follows:

[0019] Each functional flow is assigned a unique identifier in intermediate storage, and intermediate data during the execution of the functional flow is temporarily stored in the intermediate storage; if the functional flow is interrupted, historical data is reloaded according to the intermediate storage to ensure data continuity.

[0020] Preferably, the real-time update of business data status in step S2 specifically includes:

[0021] Real-time updates of data status are achieved through the collaboration of event-driven and state persistence. When the previous functional module completes its calculation, it will publish an event carrying the latest status. The event bus will broadcast the status event to relevant modules and the front-end interface. At the same time, the system uses a cache or database to store state snapshots in real time. Each functional flow is identified by a unique identifier. When the data status changes, the state snapshot in the cache or database is updated to ensure that the terminal can recover the data through the unique identifier. The front end listens for changes in data status and refreshes the interface progress and result display in real time.

[0022] Preferably, step S3 specifically comprises:

[0023] The event bus operates through a publish-subscribe mechanism, with the functional modules acting as event producers. Event types are defined and event content is standardized based on task logic. During the execution of the functional flow, after the previous functional module completes data processing, it encapsulates the result data into an event and publishes the event carrying the result data to a specified message topic. Downstream modules of the functional modules subscribe to relevant message topics as consumers, listen to the events, and trigger subsequent operations. When the downstream modules execute, they directly extract the required data from the events, ensuring the real-time data transmission and flow continuity between the functional modules of the functional flow.

[0024] Preferably, in step S4, the functional flow is decoupled, specifically by:

[0025] The functional flow is broken down into fine-grained modules based on task logic, and the responsibility boundaries of each fine-grained module are defined through domain-driven design. Standardized API interfaces are defined for each fine-grained module, and interface documentation is generated. The fine-grained modules communicate with each other through APIs or event buses, and the data storage of each fine-grained module is isolated. The fine-grained modules are packaged into independent services using Docker containerization technology, and communication strategies are managed through a service mesh.

[0026] Preferably, in step S4, the service is combined via API, specifically as follows:

[0027] The API addresses and health status of each functional module are managed through a service registry, and services are automatically registered when a functional module starts. Callers can dynamically discover target services by service name, orchestrate target services by predefining the module call order through configuration files, or generate call chains in real time using a workflow engine and orchestrate target services based on the call chains.

[0028] The present invention also provides an uncertainty analysis apparatus for a nuclear electrical mechanism model, comprising a memory and a processor, wherein the memory stores a computer program, and the computer program, when executed by the processor, implements the uncertainty analysis method for the nuclear electrical mechanism model.

[0029] Compared with existing technologies, the beneficial effects of this invention are as follows: The uncertainty analysis method for nuclear power mechanism models presented in this invention allows the system to automatically execute analysis tasks after the user completes the function flow configuration, ensuring data continuity and achieving efficient reuse of functional modules without manual intervention, significantly improving the software's business continuity and operational efficiency. First, users can directly select functional modules from the function library to construct function flows without multiple interface jumps; a complete uncertainty analysis business process can be completed within a single interface, improving business operation efficiency. Functional modules can be selected or adjusted as needed, avoiding redundant function interference. Second, through a shared data model and event-driven mechanism, business data is transmitted in real time, reducing repetitive input and ensuring data continuity; the use of intermediate storage and event bus ensures recovery after process interruption, improving data integrity. Finally, the decoupled design of functional modules, using API calls to functional modules, enables reuse across business requirements, supports custom business processes, and reduces development and maintenance costs. Through the above design, this invention achieves deep integration of business, data, and operations, providing enterprises with an efficient, flexible, and user-friendly uncertainty analysis solution. Attached Figure Description

[0030] The accompanying drawings, which are included to provide a further understanding of the invention and form part of this application, illustrate exemplary embodiments of the invention and, together with their description, serve to explain the invention and do not constitute an undue limitation thereof. In the drawings:

[0031] Figure 1 is a flowchart of an embodiment of an uncertainty analysis method for nuclear electrical mechanism models provided by the present invention;

[0032] Figure 2 for Figure 1 A schematic diagram of the thermal-hydraulic analysis model of the pressurized water reactor nuclear fuel assembly in the embodiment shown;

[0033] Figure 3 for Figure 1 A schematic diagram of the three-dimensional power partitioning model of the fuel rod in the embodiment shown;

[0034] Figure 4 yes Figure 1 The diagram shows an embodiment of the uncertainty analysis software architecture. Detailed Implementation

[0035] Preferred embodiments of the present invention will now be described in detail with reference to the accompanying drawings, which form part of this application and are used together with the embodiments of the present invention to illustrate the principles of the present invention, but are not intended to limit the scope of the present invention.

[0036] Example 1

[0037] Preferred embodiments of the present invention will now be described in detail with reference to the accompanying drawings, which form part of this application and are used together with the embodiments of the present invention to illustrate the principles of the present invention, but are not intended to limit the scope of the present invention.

[0038] Please see Figure 1 This embodiment provides an uncertainty analysis method for a nuclear electromechanical model, comprising the following steps:

[0039] Step S1: Select functional modules from the function library to construct a function flow according to the logical order of the uncertainty analysis task;

[0040] Step S2: Each of the functional modules defines input and output interfaces based on a unified shared data model. Business data is automatically transferred between functional flows based on the shared data model. Intermediate storage and status management are used to ensure the reliability of business data transfer and to update the status of business data in real time.

[0041] Step S3: Bind the triggering relationship between each functional module of the function flow through the event bus and trigger each functional module in sequence to automatically execute the analysis task;

[0042] Step S4: Decouple the functional flow and combine it into a service through API to realize the reuse of functional modules.

[0043] This invention designs an automatic uncertainty analysis system for nuclear power mechanism models. It adopts a modular architecture and a business-driven function flow mechanism to realize custom configuration of the function flow for uncertainty analysis of nuclear power mechanism models, automated execution of analysis tasks, data continuity management, and improved reusability of function modules.

[0044] This embodiment proposes an uncertainty analysis method for nuclear power mechanism models, specifically targeting typical nuclear power systems such as nuclear fuel models. Through standardized functional modules and event-driven mechanisms, it realizes an uncertainty analysis process that allows for customized configuration of functional flows and automated execution of analysis tasks.

[0045] Figure 2 and Figure 3 Examples of models constructed using this method are shown below.

[0046] Using the thermal-hydraulic analysis of nuclear fuel assemblies as the modeling object for nuclear electrical mechanism models, such as Figure 2 The figure shows a simplified thermal-hydraulic analysis model of the AFA3G pressurized water reactor fuel assembly based on a 5×5 array structure. This model was established using a three-dimensional solid geometric reconstruction method, with the main body discretized using a regular hexahedral mesh. The total mesh count reaches millions, effectively balancing computational accuracy and efficiency requirements.

[0047] based on Figure 3The three-dimensional power partitioning model of the fuel rod shown employs a radially layered thermo-hydraulic coupling method, dividing the fuel rod cross-section into three thermally differentiated regions: core region A, transition region B, and edge region C. Figure 3 As shown.

[0048] The AFA3G pressurized water reactor nuclear fuel assembly thermal-hydraulic analysis model integrates 15 parameters. The input parameters include 14 important parameters covering the coolant inlet velocity, power factors in regions A, B, and C, and the output parameter is the coolant pressure drop.

[0049] The automatic uncertainty analysis system for nuclear power mechanism models adopts a shared data model and event-driven mechanism to ensure the continuity of data flow and the real-time response of the system. It supports users to select or combine analysis processes as needed, and can also call predefined analysis templates to realize the custom configuration of function flow, automated execution of analysis tasks, analysis process failure rollback and efficient reuse of function modules. It is widely applicable to scenarios such as nuclear power model design verification and reliability assessment.

[0050] An automated uncertainty analysis architecture for nuclear power mechanism models, such as Figure 4 As shown below, the specific steps will be explained in detail.

[0051] Specifically, step S1 involves: generating the function flow in a predefined or custom manner according to the logical order of the uncertainty analysis task;

[0052] The generation of the predefined function flow is specifically as follows: select functional modules that conform to the analysis task from the function library, configure a fixed execution order of functional modules according to the logical order of the analysis task, arrange the selected functional modules based on the execution order to form a standardized process, and obtain the predefined function flow;

[0053] The generation of the custom function flow is as follows: based on the user's real-time needs, a function module is manually selected from the function library, and the data interface compatibility between the selected function modules is automatically checked. If they are incompatible, the user is prompted to make adjustments or additions. If they are compatible, the custom function flow is generated based on the selected function modules.

[0054] Each task requirement corresponds to a single user interface. This interface dynamically loads optional functional modules to form a functional flow. For example, in the "Nuclear Fuel Uncertainty Research" interface, users can select functional modules from the function library according to the business logic sequence to construct the functional flow. The functional flow is predefined or dynamically generated by the functional modules according to the task logic. Users select or adjust the functional flow through drop-down menus, tabs, or flowcharts.

[0055] A predefined function flow is a standardized process formed based on the analysis task, with a fixed execution order of functional modules pre-configured. The specific implementation steps are as follows: Select functional modules that conform to the task logic from the function library, arrange the functional modules in logical order, and form a predefined function flow.

[0056] like Figure 4 As shown, this embodiment creates a "Nuclear Fuel Uncertainty Study" task based on the analysis task requirements and configures a fixed execution order for the functional modules. The "Nuclear Fuel Uncertainty Analysis" first calls the uncertainty measurement module to measure the uncertainty of the nuclear fuel parameter data and determine the uncertainty of the nuclear fuel model's input parameters. Next, it calls the sensitivity analysis module to perform sensitivity analysis on the nuclear fuel input parameters, measuring the impact of the input parameters on the nuclear fuel model and filtering the input parameters. Then, it calls the uncertainty propagation module to analyze the uncertainty propagation of the nuclear fuel model and calculate its uncertainty. Next, it calls the structural reliability analysis module to measure the reliability of the nuclear fuel model using structural reliability analysis tools. Finally, it calls the structural reliability optimization design module to perform structural reliability optimization design, optimizing the reliability of the nuclear fuel model by optimizing the input parameter data.

[0057] Predefined process configuration information is stored in a database or configuration file. This includes module order, data interfaces, and event triggering rules. Users can then directly call the predefined template. For example, the nuclear fuel uncertainty analysis process can be encapsulated as a predefined template, "Nuclear Fuel Uncertainty Analysis Process." If a similar model is encountered, the "Nuclear Fuel Uncertainty Analysis Process" template can be directly called for reuse.

[0058] After the predefined function flow is generated, an event bus is used to automatically trigger the predefined function flow, and a shared data model is used to realize the data transfer between functional modules.

[0059] For example, the "Nuclear Fuel Uncertainty Analysis" uses an event bus to automatically trigger predefined processes. After the uncertainty measurement module completes its calculations, the sensitivity analysis module is automatically triggered. After the sensitivity analysis module completes its calculations, the uncertainty propagation module is automatically triggered. Therefore, in the predefined processes, the event bus binds the triggering relationships between all functional modules. The "Nuclear Fuel Uncertainty Analysis" uses a shared data model to implement data transfer between functional modules. The calculation results of the uncertainty measurement module are automatically used as input to the sensitivity analysis module. Simultaneously, the calculation results of the sensitivity analysis module are also automatically used as input to the uncertainty propagation module. In the predefined processes, all data interactions between functional modules are implemented using the shared data model described above.

[0060] The core idea of ​​dynamic function flow generation is to flexibly combine functional modules according to real-time user needs, generating customized processes that adapt to personalized or temporary business objectives. First, users autonomously select functional modules from the function library; for example, skipping the "Sensitivity Analysis Function Module" and directly selecting the "Uncertainty Propagation Function Module." Real-time compatibility verification automatically checks the data interface compatibility between modules. If verification fails, the system prompts the user to adjust modules or supplement missing data interfaces. Function flow generation and execution generate temporary function flow configurations, binding them to the event bus and data transmission rules. If the user needs to save the current function flow, such as a "custom nuclear fuel optimization process," they can store its configuration in the database. Dynamic execution and monitoring occur during execution, with the event bus triggering real-time collaboration between modules. If a module fails to execute, the event bus triggers a rollback mechanism, reverting to the previous state.

[0061] Specifically, in step S2, each functional module defines input and output interfaces based on a unified shared data model, as follows:

[0062] The various analysis tasks are refined and broken down into standardized steps. Based on the shared data model, the input interface, output interface, and business rules of each standardized step are defined. Each standardized step is encapsulated as a functional module of a standardized interface and stored in the functional library.

[0063] First, the analysis task is broken down and standardized to refine business requirements. Taking "nuclear fuel uncertainty analysis" as an example, its requirements are broken down into standardized steps. After the standardized steps are broken down, the input and output data interfaces and business rules for each step are defined. Finally, these are encapsulated as standardized interface functional modules and stored in the function library. "Nuclear fuel uncertainty analysis" can be broken down into standard interface functional modules of different granularities according to business requirements. For example: uncertainty measurement functional module, sensitivity analysis functional module, uncertainty propagation functional module, structural reliability analysis functional module, and structural reliability optimization design functional module. These standard interface functional modules are saved in the function library.

[0064] The software architecture of the automatic uncertainty analysis system for nuclear power mechanism models ensures the continuity of business data. Business data is automatically transferred between functional flows, avoiding duplicate data input. In the automatic uncertainty analysis system for nuclear power mechanism models, the automatic transfer of business data between functional flows is achieved through the following mechanisms.

[0065] Specifically, in step S2, business data is automatically transferred between functional flows based on the shared data model, specifically as follows:

[0066] The shared data model defines the data transfer rules between functional modules, and business data is automatically transferred between functional flows based on these rules.

[0067] Analysis-driven software architecture ensures the continuity of business data, enabling automatic data transfer between functional flows and avoiding redundant data entry. In this architecture, the automatic transfer of business data between functional flows is achieved through a shared data model and event-driven mechanisms. The shared data model defines data transfer rules between modules, and an event bus binds the triggering relationships between modules.

[0068] All functional modules define input and output interfaces based on a unified shared data model, ensuring data format consistency across different modules. A loosely coupled communication mechanism between modules is achieved through an event bus. For example, when the sensitivity analysis module completes data processing, it proactively publishes an event carrying the results. The uncertainty propagation module listens for the corresponding event and automatically triggers execution, directly extracting the required data from the event without manual intervention. This mechanism guarantees real-time data transfer and workflow continuity between modules.

[0069] Specifically, step S2 utilizes intermediate storage and state management to enhance the reliability of data transmission, specifically as follows:

[0070] Each functional flow is assigned a unique identifier in intermediate storage, and intermediate data during the execution of the functional flow is temporarily stored in the intermediate storage; if the functional flow is interrupted, historical data is reloaded according to the intermediate storage to ensure data continuity.

[0071] The system leverages intermediate storage and state management to enhance the reliability of data transmission. Each business process instance is assigned a unique identifier, a Session ID, and intermediate data generated during execution is temporarily stored in this intermediate storage. If a process is interrupted due to user pauses or system failures, historical data can be reloaded based on the Session ID upon resumption, ensuring data continuity. For example, in the "Nuclear Fuel Uncertainty Analysis" process, the results from the "Sensitivity Analysis Module" are both transmitted to downstream modules via the event bus and cached; even if the process is paused midway, the user can directly restore the data from the cache upon restarting, avoiding redundant operations. This design combines the efficiency of event-driven processing with the fault tolerance of intermediate storage, ultimately achieving seamless automatic transmission of business data and full-process automation.

[0072] Specifically, the real-time update of business data status in step S2 includes:

[0073] Real-time updates of data status are achieved through the collaboration of event-driven and state persistence. When the previous functional module completes its calculation, it will publish an event carrying the latest status. The event bus will broadcast the status event to relevant modules and the front-end interface. At the same time, the system uses a cache or database to store state snapshots in real time. Each functional flow is identified by a unique identifier. When the data status changes, the state snapshot in the cache or database is updated to ensure that the terminal can recover the data through the unique identifier. The front end listens for changes in data status and refreshes the interface progress and result display in real time.

[0074] The real-time update mechanism is achieved through a combination of event-driven and state persistence. When a module completes its calculations, it publishes an event carrying the latest state, such as `{"step": "PropagationModeling", "status": "Completed","data": {...}}`. The event bus broadcasts this state to relevant modules and the front-end interface. Simultaneously, the system uses a cache or database to store state snapshots in real time, with each functional flow instance identified by a unique Session ID. Each time the state changes, the corresponding record in the cache or database is updated, ensuring data recovery via the Session ID after an interruption. The front-end listens for state changes via WebSocket or long polling, refreshing the interface progress and results display in real time. For example, after the "Propagation Modeling module" completes, an event triggers a state update for session:12345 in Redis, and the front-end interface synchronously displays the result and prepares to start the next module.

[0075] Specifically, the data status includes: process status, data content, status markers, and abnormal status; the process status is the current execution step and progress; the data content includes the original input data, intermediate calculation results, and final output; the status markers include the model execution status and the dependencies between modules; and the abnormal status includes error codes, logs, and interruption recovery points.

[0076] In a software architecture based on analysis tasks, the real-time update mechanism is implemented in the following ways: Data status encompasses dynamic information during the execution of business processes, specifically including four dimensions: First, process status, including the current execution step and progress, such as the current execution step being "Sensitivity Analysis in Progress" and the progress being "Step 3 / 5"; second, data content, including raw input data, intermediate calculation results, and final output, such as JSON format data of sensitivity analysis results; third, status markers, such as the success or failure status of module execution, and the dependencies between modules, such as "Reliability Optimization Design" depending on the results of "Reliability Analysis"; and fourth, abnormal status, including error codes, logs, and interruption recovery points. For example, in the "Core Uncertainty Analysis" process, the data status may record the current step as "Structural Reliability Analysis," the intermediate data containing propagation modeling results, and mark "Optimization Design Pending Execution."

[0077] Specifically, step S3 is as follows:

[0078] The event bus operates through a publish-subscribe mechanism, with the functional modules acting as event producers. Event types are defined and event content is standardized based on task logic. During the execution of the functional flow, after the previous functional module completes data processing, it encapsulates the result data into an event and publishes the event carrying the result data to a specified message topic. Downstream modules of the functional modules subscribe to relevant message topics as consumers, listen to the events, and trigger subsequent operations. When the downstream modules execute, they directly extract the required data from the events, ensuring the real-time data transmission and flow continuity between the functional modules of the functional flow.

[0079] The functional flow triggers subsequent steps via an event bus, updating data status in real time to automate the execution of analysis tasks. Data from incomplete processes is temporarily stored in a cache or database for later functional flow invocation. In the automated uncertainty analysis system for nuclear electrical mechanism models, automated execution of analysis tasks is achieved through event bus generation, data status definition, and a real-time update mechanism.

[0080] The event bus relies on mature message middleware technology, with its core function being to provide a loosely coupled communication framework between modules. First, event types are defined according to business logic, and event content is standardized, including metadata such as data payload, timestamps, and process identifiers. The event bus operates through a publish-subscribe mechanism: functional modules act as event producers, encapsulating the results into events after completing their tasks and publishing them to designated message topics; downstream modules act as consumers, subscribing to relevant topics, listening for events, and triggering subsequent operations. To ensure reliability, the event bus requires message persistence, retry mechanisms, and dead-letter queues. Kafka ensures no message loss through persistent storage. Taking a nuclear power analysis tool as an example, after the "sensitivity analysis module" completes its calculations, it publishes an event containing nuclear fuel parameters and process IDs to the Kafka "analysis-results" topic. The downstream "propagation modeling module" subscribes to this topic and automatically starts its calculations, achieving seamless integration.

[0081] The real-time update mechanism is achieved through a combination of event-driven processing and state persistence. Once a module completes its calculations, it publishes an event carrying the latest state, and the event bus broadcasts the state to relevant modules and the front-end interface. Simultaneously, the system uses a cache or database to store state snapshots in real time, with each process instance identified by a unique Session ID. Each time the state changes, the corresponding record in the cache or database is updated, ensuring data recovery via the Session ID after interruption. The front-end listens for state changes through long polling and refreshes the interface progress and result display in real time. For example, after the "propagation modeling module" completes, an event triggers a state update for session:12345 in Redis, and the front-end interface synchronously displays the result and prepares to start the next module.

[0082] This mechanism combines the efficient communication of the event bus with the fault tolerance of intermediate storage, ensuring not only the continuity of business data and the traceability of operations, but also supporting the high availability requirements of complex scenarios, ultimately achieving full-process automation and real-time response to user operations.

[0083] In the backend implementation, it is necessary to decouple the functional flow modules and combine services through APIs to achieve efficient reuse of functional modules. In the automatic uncertainty analysis system for nuclear power mechanism models, efficient reuse of functional flow modules is achieved through decoupling and service composition.

[0084] Specifically, in step S4, the functional flow is decoupled, which specifically involves:

[0085] The functional flow is broken down into fine-grained modules based on task logic, and the responsibility boundaries of each fine-grained module are defined through domain-driven design. Standardized API interfaces are defined for each fine-grained module, and interface documentation is generated. The fine-grained modules communicate with each other through APIs or event buses, and the data storage of each fine-grained module is isolated. The fine-grained modules are packaged into independent services using Docker containerization technology, and communication strategies are managed through a service mesh.

[0086] The core goal of decoupling is to reduce direct dependencies between modules, making them independent and reusable services. First, functional flows are broken down into fine-grained modules based on business logic, such as a "sensitivity analysis module" and an "uncertainty propagation module." Domain-Driven Design (DDD) is used to clearly define the responsibilities and boundaries of each module, such as input, output, and processing logic. Next, standardized API interfaces are defined for each module, specifying request parameters, response formats, and error codes. OpenAPI / Swagger is used to generate interface documentation, ensuring transparent calling rules. Modules communicate via APIs or event buses, prohibiting direct access to each other's internal state, and data storage is also isolated. Finally, Docker containerization technology is used to package modules as independent services, supporting on-demand deployment and horizontal scaling. Communication strategies, such as circuit breaking and rate limiting, are managed through the service mesh Istio. For example, the "sensitivity analysis module" is encapsulated as an independent service, providing the ` / analyze-sensitivity` interface; other modules only need to call this API without needing to understand its internal implementation.

[0087] Specifically, in step S4, services are combined via APIs, which involves managing the API addresses and health status of each functional module through a service registry center and automatically registering services when a functional module starts. The caller dynamically discovers the target service by service name, orchestrates the target service by predefining the module call order through a configuration file, or generates a call chain in real time using a workflow engine and orchestrates the target service based on the call chain.

[0088] The goal of service composition is to dynamically integrate decoupled modules into a complete business function flow. First, the API addresses and health status of modules are managed through a service registry. Modules are automatically registered upon startup, and callers dynamically discover targets using service names. Service orchestration is divided into two methods: static orchestration, which predefines the module call order through configuration files and is suitable for standardized processes; and dynamic orchestration, which uses a workflow engine to generate call chains in real time, supporting conditional branches and loop logic.

[0089] API calls can be made synchronously via HTTP / RPC or asynchronously via an event bus. For example, in "Nuclear Fuel Uncertainty Analysis," the backend first calls the ` / analyze-sensitivity` interface, and then triggers ` / model-propagation` execution via a Kafka event. To ensure reliability, a retry mechanism and distributed transaction management must be implemented. If the process fails, compensation logic is triggered to roll back the data.

[0090] By decoupling and combining APIs, the system can flexibly respond to complex business needs while ensuring high availability and maintainability, ultimately reducing development and maintenance costs.

[0091] In summary, in this embodiment, the user accesses the uncertainty analysis auxiliary analysis tool interface, creates a "Nuclear Fuel Uncertainty Analysis" task based on business needs, and customizes the function flow as "Uncertainty Measurement Module - Sensitivity Analysis Module - Uncertainty Propagation Module - Structural Reliability Analysis Module - Structural Reliability Optimization Design Module". The system automatically executes the analysis task for "Nuclear Fuel Uncertainty Analysis" through a continuous flow of business data. First, it performs sensitivity analysis on the nuclear fuel data; then, it measures uncertainty; next, it models uncertainty propagation, calculates the structural reliability of the nuclear fuel model data, and finally optimizes the nuclear fuel model data to increase its reliability.

[0092] This invention presents an automated uncertainty analysis system for nuclear power mechanism models. After the user completes the function flow configuration, the system automatically executes analysis tasks, ensuring data continuity and achieving efficient reuse of functional modules without manual intervention, significantly improving the software's business continuity and operational efficiency. Users can complete the entire uncertainty analysis business process within a single interface without switching between multiple interfaces, improving business operation efficiency. Functional modules can be selected or adjusted as needed, avoiding redundant function interference. Through a shared data model and event-driven mechanism, business data is transmitted in real time, reducing repetitive input by 90% and ensuring data continuity. The use of intermediate storage and an event bus ensures recovery after process interruption, improving data integrity. The decoupled design of functional modules, using API calls to functional modules, enables reuse across business requirements, supports custom business processes, and reduces development and maintenance costs. The event-driven architecture supports process rollback, automatically reverting to the previous state if the current task fails. Through the above design, this invention achieves deep integration of business, data, and operations, providing enterprises with an efficient, flexible, and user-friendly software architecture solution.

[0093] Example 2

[0094] This embodiment provides an uncertainty analysis device for nuclear electrical mechanism models, including a memory and a processor. The memory stores a computer program, and when the computer program is executed by the processor, it implements the uncertainty analysis method for nuclear electrical mechanism models described in Embodiment 1.

[0095] The uncertainty analysis device for nuclear electrical mechanism models provided in this embodiment is used to implement the uncertainty analysis method for nuclear electrical mechanism models. Therefore, the uncertainty analysis device for nuclear electrical mechanism models also possesses the technical effects of the uncertainty analysis method for nuclear electrical mechanism models, and will not be described again here.

[0096] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any changes or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of the present invention.

Claims

1. An uncertainty analysis method for nuclear electromechanical models, characterized in that, Includes the following steps: Step S1: Select functional modules from the function library to construct a function flow according to the logical order of the uncertainty analysis task; Step S2: Each of the functional modules defines input and output interfaces based on a unified shared data model. Business data is automatically transferred between functional flows based on the shared data model. Intermediate storage and status management are used to ensure the reliability of business data transfer and to update the status of business data in real time. Step S3: Bind the triggering relationship between each functional module of the function flow through the event bus and trigger each functional module in sequence to automatically execute the analysis task; Step S4: Decouple the functional flow and combine it into a service through API to realize the reuse of functional modules; Step S2 utilizes intermediate storage and state management to enhance the reliability of data transmission, specifically as follows: Each functional flow is assigned a unique identifier in intermediate storage, and intermediate data during the execution of the functional flow is temporarily stored in the intermediate storage; if the functional flow is interrupted, historical data is reloaded according to the intermediate storage to ensure data continuity. The real-time update of business data status in step S2 specifically includes: Real-time updates of data status are achieved through the collaboration of event-driven and state persistence. When the previous functional module completes its calculation, it will publish an event carrying the latest status. The event bus will broadcast the status event to relevant modules and the front-end interface. At the same time, the system uses a cache or database to store state snapshots in real time. Each functional flow is identified by a unique identifier. When the data status changes, the state snapshot in the cache or database is updated to ensure that the terminal can recover the data through the unique identifier. The front end listens for changes in data status and refreshes the interface progress and result display in real time.

2. The uncertainty analysis method for nuclear electromechanical models according to claim 1, characterized in that, Specifically, step S1 involves: generating the function flow in a predefined or custom manner according to the logical order of the uncertainty analysis task; The generation of the predefined function flow is specifically as follows: select functional modules that conform to the analysis task from the function library, configure a fixed execution order of functional modules according to the logical order of the analysis task, arrange the selected functional modules based on the execution order to form a standardized process, and obtain the predefined function flow; The generation of the custom function flow is as follows: based on the user's real-time needs, a function module is manually selected from the function library, and the data interface compatibility between the selected function modules is automatically checked. If they are incompatible, the user is prompted to make adjustments or additions. If they are compatible, the custom function flow is generated based on the selected function modules.

3. The uncertainty analysis method for nuclear electromechanical models according to claim 1, characterized in that, In step S2, each functional module defines its input and output interfaces based on a unified shared data model, specifically as follows: The various analysis tasks are refined and broken down into standardized steps. Based on the shared data model, the input interface, output interface, and business rules of each standardized step are defined. Each standardized step is encapsulated as a functional module of a standardized interface and stored in the functional library.

4. The uncertainty analysis method for nuclear electromechanical models according to claim 1, characterized in that, In step S2, business data is automatically transferred between functional flows based on the shared data model, specifically as follows: The shared data model defines the data transfer rules between functional modules, and business data is automatically transferred between functional flows based on these rules.

5. The uncertainty analysis method for nuclear electromechanical models according to claim 1, characterized in that, Step S3 specifically involves: The event bus operates through a publish-subscribe mechanism, with the functional modules acting as event producers. Event types are defined and event content is standardized based on task logic. During the execution of the functional flow, after the previous functional module completes data processing, it encapsulates the result data into an event and publishes the event carrying the result data to a specified message topic. Downstream modules of the functional modules subscribe to relevant message topics as consumers, listen to the events, and trigger subsequent operations. When the downstream modules execute, they directly extract the required data from the events, ensuring the real-time data transmission and flow continuity between the functional modules of the functional flow.

6. The uncertainty analysis method for nuclear electromechanical models according to claim 1, characterized in that, In step S4, the functional flow is decoupled, specifically as follows: The functional flow is broken down into fine-grained modules based on task logic, and the responsibility boundaries of each fine-grained module are defined through domain-driven design. Standardized API interfaces are defined for each fine-grained module, and interface documentation is generated. The fine-grained modules communicate with each other through APIs or event buses, and the data storage of each fine-grained module is isolated. The fine-grained modules are packaged into independent services using Docker containerization technology, and communication strategies are managed through a service mesh.

7. The uncertainty analysis method for nuclear electromechanical models according to claim 1, characterized in that, In step S4, the services are combined via API, specifically as follows: The API addresses and health status of each functional module are managed through a service registry, and services are automatically registered when a functional module starts. Callers can dynamically discover target services by service name, orchestrate target services by predefining the module call order through configuration files, or generate call chains in real time using a workflow engine and orchestrate target services based on the call chains.

8. An uncertainty analysis device for nuclear electromechanical models, characterized in that, It includes a memory and a processor, wherein the memory stores a computer program, which, when executed by the processor, implements the uncertainty analysis method for nuclear electrical mechanism models as described in any one of claims 1-7.

Images