A full-core parallel fluid-structure coupling simulation method and system

Abstract

The application discloses a kind of whole core parallel fluid-solid coupling simulation method and system, wherein system includes: global collaborative coupling simulation scheduling module, hierarchical index forest management module, high-performance parallel solver module and intelligent parameter transfer module;Wherein, global collaborative coupling simulation scheduling module is responsible for overall process control, time step, solver scheduling, convergence judgment and inter-module communication triggering;Hierarchical index forest management module is responsible for the distributed parallel construction of CLGIF, efficient dynamic update, and provides fast geometry query service;High-performance parallel solver module is used for the numerical solver of embedded or closely integrated fluid and solid physical field, and applies dynamic parallel multi-solver optimization module to maximize its computing performance and scalability;Intelligent parameter transfer module is responsible for executing physical quantity exchange on fluid-solid interface, and its core is GME-driven region-aware RBF mapping engine, to ensure the accuracy and efficiency of transfer.

Description

Technical Field

[0001] This invention belongs to the field of high-performance computing and engineering simulation technology, and specifically relates to a parallel fluid-structure interaction simulation method and system for the entire reactor core. Background Technology

[0002] Fluid-structure interaction (FSI) is a widespread phenomenon in nature and engineering, particularly in nuclear reactor engineering. The interaction between coolant flow and solid structures such as fuel rods and reactor internals is crucial for the safe operation and performance evaluation of the reactor. With the improvement of computer performance, studying full-core FSI problems through numerical simulation to obtain high-fidelity physical field information has become an important tool for reactor design, safety analysis, and performance optimization. However, achieving efficient and high-precision full-core FSI simulation calculations still faces significant challenges.

[0003] Parallel computing efficiency and scalability bottlenecks: Full-core models typically contain billions or even tens of billions of mesh cells and complex geometries, resulting in extremely large computational and memory requirements. Existing parallel computing methods, while employing parallel techniques such as domain decomposition and MPI / OpenMP, often encounter severe parallel efficiency bottlenecks in ultra-large-scale parallel environments (e.g., using thousands to tens of thousands of computing cores). This is mainly due to: ① Uneven load: Complex geometries and dynamically changing physical fields make static or simple dynamic load balancing strategies difficult to adapt, leading to some processors being idle while others are overloaded. ② Huge communication overhead: As the scale of parallelism increases, the communication volume and frequency of data exchange across processor boundaries (e.g., fluid pressure, solid displacement, mesh node information, etc.) increase dramatically, resulting in excessively high communication time and severely limiting the overall speedup. This communication bottleneck is particularly prominent in coupled interface processing involving large amounts of unstructured data interaction. ③ Insufficient optimization of heterogeneous computing: Modern high-performance computing platforms often adopt a CPU+GPU heterogeneous architecture. However, designing parallel optimization strategies that fully leverage the advantages of heterogeneous platforms and achieve deep overlap between computation and memory access remains challenging, given the hybrid computational characteristics of fluid solvers, solid solvers, and coupled algorithms in FSI (such as the coexistence of computationally intensive and memory-intensive tasks). For example, widely used high-precision numerical solution methods for structural dynamics and fluid dynamics, such as the Hybrid Full Finite Element Tear and Interconnection Method (HTFETI) and the Higher-Order Spectral Element Method (SEM), rely on large-scale dense matrix operations (DGeMM) and sparse matrix operations (SpMV) at their core. These two types of computational tasks have vastly different requirements for computational resources and memory bandwidth, making it difficult for simple parallelization or flow management strategies to achieve optimal resource utilization and performance.

[0004] Inefficient Management and Search of Massive Coupled Interface Data: The entire core model contains extremely large and complex fluid-structure interaction (FSI) interfaces. During FSI calculations, physical quantities (such as force, displacement, and temperature) need to be frequently transferred between the fluid and solid domains. This requires efficient management of the geometric information and mesh topology of the coupled interfaces, and the ability to quickly and accurately find corresponding pairs of coupled points or elements in space. Existing methods suffer from the following problems: ① Low Spatial Search Efficiency: Traditional spatial search algorithms, such as nearest neighbor searches based on simple bounding boxes or octrees / kd-trees, experience a sharp decline in search efficiency when dealing with massive (millions to billions) coupled interface nodes / elements at the core level, becoming a major performance bottleneck in the parameter transfer process. ② Poor Data Structure Adaptability: Many existing data structures struggle to effectively support dynamic changes in the coupled interfaces (such as large solid deformations and changes in contact states) and efficient parallel distributed storage and access. There is a lack of dedicated data structures that can unify global spatial relationships, support hierarchical parallel processing, and dynamically maintain and update them. This complicates efficient task decomposition and metadata management in a distributed memory environment.

[0005] The balance between accuracy and efficiency in parameter transfer is challenging: Transferring physical quantities between mismatched meshes (fluid meshes and solid meshes are often inconsistent) is a core aspect of FSI calculations. The accuracy and efficiency of the parameter transfer method directly affect the accuracy and feasibility of the entire simulation. Existing parameter transfer methods (such as nearest neighbor interpolation, nearest element projection, distance-weighted averaging, radial basis function (RBF) interpolation, moving least squares (MLS), etc.) have inherent contradictions: ① Low-order methods lack accuracy: While simple methods such as nearest neighbor and distance-weighted methods have low computational cost, they can easily introduce large interpolation errors in regions with large mesh size differences, drastic changes in geometric curvature, or large gradients in physical quantities. They may even fail to guarantee physical constraints such as energy conservation, affecting the accuracy of simulation results. ② High-order methods are computationally expensive: Although high-order methods such as RBF have high accuracy, they usually require solving a large, or even dense, linear equation system to determine the interpolation coefficients. For coupled interfaces at the entire core scale (involving millions of degrees of freedom), constructing and solving such a global linear system is computationally and memory-intensive, making it completely unsuitable for large-scale parallel computing. ③ Poor adaptability of global parameters: Many interpolation methods (especially RBF) rely on global parameters, such as the support radius of the RBF. Using a globally uniform support radius often fails to adapt to the mesh density and physical field characteristics of different regions on the coupling interface: too small a radius may lead to inefficient interpolation or low accuracy, while too large a radius may result in over-smoothing, loss of local details, introduction of spurious oscillations (especially in regions of rapid parameter changes), and a significant increase in computational cost. How to automatically determine locally optimal interpolation parameters to balance accuracy and efficiency remains an unresolved problem. While existing research has explored this, it often lacks sufficiently robust and efficient adaptive mechanisms or fails to effectively integrate with efficient parallel data structures and computational frameworks.

[0006] In summary, existing research techniques have significant shortcomings in terms of parallel scalability, efficient management and search of massive coupled data, and the coordinated optimization of accuracy and efficiency in parameter transfer. The lack of a holistic solution integrating efficient parallel computing models, advanced dynamic hierarchical data structures, and intelligent adaptive high-precision parameter transfer mechanisms severely restricts the capabilities and application scope of full-core FSI simulation. Therefore, it is urgent to develop new methods and systems to overcome these challenges. Summary of the Invention

[0007] The purpose of this invention is to solve the following technical problems:

[0008] With the increasing demands for safety and economy in complex engineering systems such as nuclear reactors, high-fidelity full-core fluid-structure interaction (FSI) simulation has become an indispensable key technology. However, current mainstream simulation methods face the following severe technical challenges when dealing with the extreme scale, complex geometry, strong nonlinear coupling, and dynamic evolution characteristics at the full-core level. These challenges collectively constitute the core bottleneck restricting simulation capabilities and reliability: ① The challenge of efficient geometric mapping of large-scale dynamic interfaces: Full-core models contain hundreds of millions or even more mesh elements, and the fluid-structure interaction interface is extremely complex and may dynamically evolve over time (e.g., fuel rod vibration, swelling, etc.). Existing spatial search algorithms often encounter the "curse of dimensionality" when processing such massive amounts of data and dynamic geometry, leading to an exponential increase in the computational overhead of spatial correlation matching or excessively high algorithm complexity, becoming a fundamental obstacle restricting overall simulation efficiency and making high-resolution dynamic simulation difficult to achieve. ② The "fidelity-efficiency" dilemma of accurate coupling of multiphysics: Accurately transferring key physical quantities such as heat and force at the fluid-structure interface is the cornerstone of ensuring the physical authenticity of simulation results. Traditional parameter transfer methods (such as global RBF) sacrifice local adaptability to simplify computation, introducing significant, and potentially non-physical, transfer errors in regions of rapid gradient change (such as stress concentration zones and high heat flux density zones), severely impairing the simulation's predictive capabilities. Conversely, methods pursuing high accuracy (such as fine local reconstruction or global solution) often come with unbearable computational costs, making large-scale, long-term simulations impractical. How to simultaneously ensure coupling fidelity and computational efficiency under extreme computational constraints remains an unresolved problem. ③ Scalability and optimization bottlenecks of ultra-large-scale parallel computing: Full-core simulation relies on large-scale parallel computing. However, the tight coupling characteristics of fluid-structure interaction, the differences in computational load between different physics solvers, and the communication overhead caused by massive data exchange make it difficult for existing parallel strategies to achieve ideal parallel speedup and load balancing. As the number of computing cores increases, communication latency and synchronization waiting often become new performance bottlenecks, severely limiting the potential for using the powerful computing capabilities of modern supercomputers for larger-scale, higher-precision simulations.

[0009] To achieve the above objectives, this invention proposes a parallel fluid-structure interaction (FSI) simulation method and supporting system for the entire reactor core. It aims to overcome the core challenges faced by existing technologies in large-scale, high-complexity nuclear reactor core simulation, including computational performance bottlenecks, complex data management at coupling interfaces, and the difficulty in coordinating the optimization of parameter transfer accuracy and efficiency. By integrating innovative data structures, intelligent parameter transfer algorithms, and targeted parallel optimization strategies, this invention significantly improves the computational efficiency, parameter transfer accuracy, data management capabilities, and overall scalability of full-core FSI simulation, providing strong technical support for the refined simulation of complex engineering problems. The core technical solution is detailed below:

[0010] I. Global Coordination Coupled Simulation Scheduling (Top-Level Coordination - Coupled Logic Control)

[0011] The top-level coordination module serves as the "command center" of the entire coupled simulation system, responsible for macroscopic simulation process control and coordination. It not only executes standard time-stepping logic, precisely controlling the calling order and timing of the fluid solver, solid solver, and coupling interface modules, but also incorporates a robust convergence judgment mechanism to monitor physical quantity residuals in nonlinear iterations or implicit couplings, ensuring the stability and accuracy of coupled calculations. More importantly, this module is the starting point for triggering subsequent core innovation modules. When data exchange is required in each coupling or iteration step, it precisely issues instructions, activating the hierarchical index forest for spatial correlation updates or queries, and initiating the GME-driven region-aware parameter mapping process. This clear top-level coordination ensures the orderly integration and efficient operation of various innovative technologies in complex coupled processes. Specifically, the main responsibilities of this module include:

[0012] Time step management: Supports explicit, implicit and hybrid time integration strategies, dynamically adjusts the time step to adapt to drastic changes in the physical field, and improves efficiency while ensuring simulation stability.

[0013] Solver scheduling: Precisely schedules the calling order of the fluid and solid solvers, supporting both strong and semi-implicit coupling strategies. By iteratively calling the fluid and solid solvers, convergence is ensured within each coupled time step.

[0014] Convergence judgment: Based on preset criteria such as physical quantity residuals, interface forces and displacements, the convergence of fluid-structure interaction iteration is judged in real time, and the iteration process is dynamically adjusted.

[0015] Data exchange trigger: At key nodes of the time step or iteration step, the transfer operation of physical quantities (such as force, displacement, temperature, etc.) on the fluid-structure interface is triggered to provide input for the subsequent update of the hierarchical index forest and parameter mapping.

[0016] Global monitoring and advanced control: Provides real-time monitoring functions and supports advanced operations such as anomaly handling, saving and restarting simulation checkpoints to ensure the stability and reliability of the simulation process.

[0017] Through the global scheduling and intelligent control of the top-level coordination module, this invention achieves efficient collaboration in complex multiphysics coupling simulation, providing a solid framework support for the operation of subsequent core modules.

[0018] II. Dynamic Geometric Intelligent Perception Engine (Core Data Structure Management—Dynamically Building and Updating Hierarchical Index Forest)

[0019] To address the need for efficient management and dynamic maintenance of massive coupled interface data in full-core simulation, this invention designs a hierarchical, dynamic indexed forest structure (CLGIF). Through a unified global data structure and an efficient dynamic update mechanism, it provides an efficient solution to complex geometric mapping problems. CLGIF constitutes the "intelligent sensing skeleton" for handling complex geometry in this invention, and its efficient querying and dynamic adaptability are key enabling technologies for achieving large-scale, long-term dynamic FSI simulation.

[0020] Hierarchical index forest structure:

[0021] ① Batch-Level Indexed Forest (BLIF): The fluid-structure interaction units (FSCUs) within the reactor core are divided into multiple batches. Within each batch, the fluid and solid interfaces are constructed using a pair of computational processes to create a local index tree structure. Through distributed parallel computing and asynchronous communication, these are integrated into a batch-level indexed forest (BLIF).

[0022] ② Global Core-Level Index Forest (CLGIF): Further integrate all batches of BLIF information into a global index forest (CLGIF), uniformly organize the spatial relationships of all coupling interfaces within the core, and provide efficient geometric query support for subsequent parameter passing.

[0023] Efficient dynamic maintenance and updates:

[0024] ① Local update: For dynamic changes in interface geometry during the simulation process (such as solid deformation or flow field disturbance), CLGIF supports efficient updates of the local index tree, avoiding the computational overhead of global reconstruction.

[0025] ② Real-time response: After each time step, the index structure is dynamically adjusted based on the latest physical field information to ensure that it always accurately reflects the interface geometry and maintains high-efficiency search performance.

[0026] Fast query and distributed storage:

[0027] CLGIF's design combines distributed storage and asynchronous access technologies, supporting efficient queries on large-scale (e.g., hundreds of millions) coupled nodes. Its theoretical query complexity can reach logarithmic levels, thus significantly alleviating the severe performance bottleneck faced by traditional geometric mapping methods in large-scale scenarios.

[0028] By using a hierarchical indexed forest structure, this invention achieves efficient management of massive interface data in full-core simulation, providing a robust geometric basis for intelligent parameter transfer.

[0029] III. Core of High-Fidelity Parameter Transmission for Intelligent Sensing (Core Algorithm Execution—GME-Driven Region-Aware RBF Mapping)

[0030] To address the problem of physical quantity transfer between mismatched meshes, this invention proposes a region-aware radial basis function (GDRA-RBF) mapping mechanism based on gated multi-expert (GME). By introducing the intelligent prediction capabilities of machine learning, it endows the traditional RBF method with region awareness and adaptability. While ensuring high-fidelity accuracy in transferring physical quantities across rapidly changing regions, it effectively improves computational efficiency by requiring only local calculations and avoiding the construction and solution of large, complex global linear systems. This achieves a synergistic optimization of high accuracy and high efficiency in the parameter transfer process.

[0031] Efficiently match related nodes:

[0032] CLGIF is used to quickly extract relevant index tree pairs, and through efficient spatial search, it accurately matches nodes or cell pairs that are spatially close on the fluid-structure interface.

[0033] GME-driven region-aware support radius prediction:

[0034] ①Regional feature perception: Extract feature information such as local grid point density, physical quantity gradient and historical error to provide input for support radius prediction.

[0035] ② Intelligent prediction: The optimal local support radius is dynamically predicted through a gated multi-expert (GME) model, which solves the problem of parameter drastic changes and transmission errors caused by a single global radius.

[0036] ③ Region-aware RBF interpolation: RBF interpolation is performed within the predicted local support radius, avoiding the construction of a globally dense matrix and significantly improving computational efficiency.

[0037] Dynamic updates and global consistency guarantees:

[0038] During parameter transfer, the index structure is dynamically optimized based on changes in physical quantities to ensure numerical consistency and physical fidelity throughout the simulation process.

[0039] The intelligent parameter transfer algorithm of this invention achieves high-fidelity physical quantity transfer through region perception and adaptive interpolation, providing an accurate and reliable coupling mechanism for full-core fluid-structure interaction simulation.

[0040] IV. Deeply Optimized Parallel Computing Framework (Performance Optimization Implementation—Application of DPMSO Strategy)

[0041] To address the performance limitations imposed by the mixed computationally intensive and memory-intensive operations in full-core fluid-structure interaction simulations, this invention proposes a Dynamic Parallel Multi-Stream Optimization (DPMSO) strategy. This strategy effectively overcomes the shortcomings of traditional static parallel task partitioning, comprehensively improving parallel computing performance and system scalability through real-time monitoring, dynamic adjustment, and deep optimization, providing powerful computing support for large-scale complex simulations.

[0042] 1) Dynamic traffic splitting and resource scheduling

[0043] The DPMSO strategy intelligently allocates computing and storage resources by sensing the characteristics of computing tasks and resource load status in real time, thereby achieving load balancing and critical path optimization.

[0044] ①Task Awareness and Classification: Based on the computational characteristics of the task, distinguish between computationally intensive operations (such as DGeMM, large-scale dense matrix-matrix multiplication) and memory-intensive operations (such as SpMV, large-scale sparse matrix-vector multiplication). Analyze the performance bottlenecks of each type of task in real time based on the task's computational requirements (such as floating-point operation intensity) and memory bandwidth requirements (such as memory access frequency).

[0045] ② Dynamic Resource Allocation: Based on real-time monitoring data, resource allocation ratios are dynamically adjusted. For example, computing cores are prioritized for DGeMM operations, and memory bandwidth is prioritized for SpMV operations. For multi-task scenarios such as fluid solvers, solid solvers, and index forest (CLGIF) operations, computing resources are allocated on demand to ensure balanced and efficient operation of each task.

[0046] ③ Task partitioning and priority scheduling: Large-scale computational tasks are divided into smaller task groups and scheduled according to dependencies and task priorities to ensure that high-priority tasks on the critical path are completed first. Through fine-grained task partitioning and dynamic scheduling mechanisms, critical path delays are minimized, and overall simulation efficiency is improved.

[0047] 2) Overlapping computation and memory access depths

[0048] The DPMSO strategy significantly improves hardware resource utilization and reduces memory access performance bottlenecks by deeply integrating computation and memory access operations.

[0049] ① Multi-Stream Parallelism: Utilizing a multi-stream parallel architecture, computation and memory access operations are executed concurrently, avoiding idle computing resources caused by memory access latency. In GPU computing, CUDA Streams or OpenCL queues are fully utilized to overlap computation tasks and data transfers, thereby reducing waiting time.

[0050] ② Memory Access Optimization: For memory-intensive tasks (such as SpMV), optimize memory access patterns by using techniques such as block partitioning and prefetching to reduce random memory accesses and improve memory bandwidth utilization. For compute-intensive tasks (such as DGeMM), reduce the overhead of multiple memory data transfers through data reuse and caching optimizations.

[0051] ③ Overlapping of computation and communication: In distributed parallelism, overlapping of computation and cross-node communication is achieved to reduce the impact of communication blockage on the overall simulation. This is accomplished through asynchronous communication mechanisms (such as MPI non-blocking communication) to achieve dynamic overlap between data transmission and local computation.

[0052] 3) Deep integration of CPU+GPU collaborative computing

[0053] Modern high-performance computing platforms typically employ a CPU+GPU heterogeneous architecture, while the hybrid nature of fluid-structure interaction (FSI) simulation tasks places higher demands on the collaborative optimization of heterogeneous computing. The DPMSO strategy utilizes the following core technologies in cross-platform heterogeneous optimization:

[0054] ① Heterogeneous task allocation: Based on the computational or memory access intensity of the tasks, different types of tasks are allocated to suitable hardware processing units. For example, DGeMM operations are allocated to GPUs to take advantage of their powerful floating-point computing capabilities, while SpMV operations are allocated to CPUs to fully utilize their memory optimization capabilities.

[0055] ② Collaborative Computing Mechanism: Design a collaborative working mechanism across CPU and GPU, dynamically allocating tasks to different hardware and eliminating performance bottlenecks between hardware through asynchronous communication and scheduling mechanisms. Combine GPU's multi-stream parallelism with CPU's multi-threaded parallelism to maximize the synergistic effect of different hardware resources.

[0056] ③ Hardware characteristic adaptation: Based on hardware characteristics (such as GPU thread block size, CPU cache size, etc.), the parallel granularity and algorithm parameters of the solver are dynamically adjusted to give full play to the hardware performance potential.

[0057] 4) Real-time monitoring and dynamic adjustment

[0058] The core of the DPMSO strategy lies in the continuous performance optimization process, rather than the static partitioning of parallel tasks. To this end, this invention designs the following key mechanisms:

[0059] ① Real-time monitoring: During simulation, the load of each computing node is monitored in real time, including the time consumed by the fluid solver, solid solver, CLGIF operation, and GDRA-RBF calculation, as well as the communication mode and overhead between nodes. Visualization of the monitoring data intuitively displays system performance bottlenecks, guiding subsequent optimization.

[0060] ② Dynamic Decision-Making and Adjustment: Based on monitoring data and preset optimization objectives (such as minimizing total runtime or maximizing resource utilization), the parallel execution scheme is dynamically adjusted. Key adjustment measures include: reallocating computational tasks to different processor cores, adjusting the parallel granularity within the solver, optimizing data communication paths or aggregation strategies, and even dynamically selecting different numerical algorithms or solver parameters.

[0061] ③ Intelligent feedback and self-learning: Through machine learning or rule-based optimization models, the decision-making mechanism of DPMSO is gradually optimized, enabling it to achieve adaptive performance improvement in long-term operation.

[0062] This invention addresses the significant shortcomings of existing coupled simulation techniques in terms of parallel efficiency, massive data management, and the coordination of parameter transfer accuracy and efficiency (as described in the background section). It proposes a systematic solution integrating innovative data structures, intelligent algorithms, and deep parallel optimization strategies. Its main innovations and beneficial effects are as follows:

[0063] Innovation Point 1: The hierarchical indexed forest (CLGIF) data structure and its dynamic management mechanism are proposed, which realizes efficient management and geometric mapping of large-scale dynamic coupling interfaces.

[0064] The difference lies in the fact that, unlike existing technologies that use simple static tree structures (such as octrees and kd-trees) or methods with low global update efficiency, this invention designs a two-layer distributed index forest structure that includes batch-level (BLIF) and global core-level (CLGIF). This structure can not only uniformly organize and manage massive (billions or even tens of billions) coupled interface units (FSCUs) at the entire core level, but more importantly, it supports efficient distributed parallel construction, asynchronous communication-based metadata data transmission, and a local efficient update mechanism for dynamic changes in the interface.

[0065] Innovation and Beneficial Effects: Highly Efficient Geometric Mapping: Combining distributed storage and asynchronous access, CLGIF supports efficient and rapid querying of large-scale coupled nodes, significantly alleviating or even overcoming the performance bottlenecks of traditional geometric mapping methods in large-scale dynamic scenarios (background technical issues ① and ②). Strong Dynamic Adaptability: Through a local update mechanism, it can efficiently respond to interface geometric changes caused by solid deformation or flow field variations, avoiding costly global reconstruction and ensuring the efficiency of long-term simulations and the real-time accuracy of indexes. Parallel Compatibility: Its layered and distributed design is naturally suited to large-scale parallel environments, simplifying task decomposition, load balancing, and data management, laying a solid foundation for subsequent efficient parameter passing and parallel computing.

[0066] Innovation Point 2: A GME-driven region-aware RBF (GDRA-RBF) parameter transfer method was developed, achieving high-precision and high-efficiency collaborative optimization of physical quantity transfer at the coupling interface.

[0067] The differences lie in the fact that existing parameter transfer methods either lack sufficient accuracy (e.g., nearest neighbor) or have high computational costs (e.g., global RBF for solving large linear systems), and generally employ globally unified or simply rule-determined interpolation parameters (e.g., support radius), making it difficult to adapt to drastic changes in local physical fields and mesh characteristics (background technical problem ③). This invention introduces a gated multi-expert (GME) machine learning model into the RBF parameter transfer process for the first time, enabling intelligent prediction of the local optimal support radius.

[0068] Innovation and Beneficial Effects: High-Precision Transfer: The GME model can perceive multi-dimensional characteristics such as grid density, physical quantity gradient, and historical errors in local regions, and dynamically and accurately predict the most suitable RBF support radius for that region. This effectively overcomes the accuracy loss or spurious oscillation problem caused by a single global radius in regions with drastic gradient changes, significantly improving the fidelity of parameter transfer. High-Efficiency Computation: By performing local RBF interpolation (based on the predicted optimal local radius), the huge computational and memory overhead of constructing and solving a large global linear system is avoided, enabling the high-precision transfer method to be efficiently applied to the entire core scale. Intelligent and Adaptive: The parameter transfer process is made intelligent and adaptive, dynamically adjusting the interpolation strategy to adapt to changing simulation conditions without manual intervention, perfectly solving the dilemma of balancing accuracy and efficiency. Dynamic Consistency: Combined with the dynamic updates of CLGIF, it ensures that parameter transfer is always based on accurate geometric correspondences and optimized interpolation parameters throughout the simulation process, guaranteeing numerical consistency.

[0069] Innovation Point 3: The Dynamic Parallel Multi-Stream Optimization (DPMSO) strategy is proposed, which realizes efficient parallel execution and resource utilization of solvers with hybrid computing characteristics.

[0070] The difference lies in the fact that existing parallel strategies often employ static partitioning or simple load balancing, which struggles to effectively handle the complex characteristics of fluid and solid solvers in FSI simulations, which often involve a mix of computationally intensive (e.g., DGeMM) and memory-intensive (e.g., SpMV) operations. This is especially true on CPU+GPU heterogeneous platforms and under massively parallel environments, where communication bottlenecks and low resource utilization are common problems (background technical issue ①). The DPMSO strategy proposed in this invention is a dynamic, deep optimization framework oriented towards hybrid task characteristics and heterogeneous platforms.

[0071] Innovation and Beneficial Effects: Improved Solver Performance: Through real-time monitoring, task awareness and classification (DGeMM / SpMV), dynamic resource allocation (CPU / GPU), and priority scheduling, the single-node and parallel computing efficiency of core solvers constituting FSI simulations (such as the large-scale SpMV and DGeMM calculations relied upon by HTFETI and SEM) is significantly improved. Maximized Hardware Utilization: By utilizing multi-stream parallelism, deep overlap of computation and memory access, and overlap of computation and communication, latency is effectively hidden, significantly improving the utilization of hardware resources such as CPU, GPU, and memory bandwidth. Enhanced Parallel Scalability: Through dynamic load balancing and communication optimization, performance bottlenecks under large-scale parallelism are effectively suppressed, enabling simulations to scale to larger computational scales and achieve better speedup ratios. Efficient Collaboration on Heterogeneous Platforms: Collaborative computing mechanisms and hardware characteristic adaptation capabilities are provided for CPU+GPU heterogeneous platforms, fully leveraging the potential of modern high-performance computing platforms. Attached Figure Description

[0072] Figure 1 This is a schematic diagram showing the overall implementation framework provided for embodiments of the present invention;

[0073] Figure 2 This is a schematic diagram of a parallel fluid-structure interaction simulation method for the entire core provided in an embodiment of the present invention;

[0074] Figure 3 This is a schematic diagram of a hierarchical index tree;

[0075] Figure 4 A schematic diagram of the structure of a gated multi-expert (GME) neural network model;

[0076] Figure 5 A schematic diagram of dynamic resource routing and fine-grained multi-flow management for DPMSO;

[0077] Figure 6 This is a schematic diagram of a full-core parallel fluid-structure interaction simulation system provided in an embodiment of the present invention. Detailed Implementation

[0078] To enable those skilled in the art to more fully understand and implement the present invention, the specific implementation process of the "a full-core parallel fluid-structure interaction simulation method and system" proposed in the present invention will be described in detail below with reference to preferred embodiments and accompanying drawings.

[0079] The core of this invention lies in constructing a highly integrated, intelligent, and deeply optimized simulation workflow, such as... Figure 1As shown in A. Overall Implementation Framework and Process Overview. Under the precise control of the globally collaborative coupled simulation scheduling module (top-level coordination module), this process seamlessly integrates hierarchical indexed forest (CLGIF) data structure management, high-performance solver execution based on dynamic parallel multi-stream optimization (DPMSO) strategy, and region-aware radial basis function (GDRA-RBF) intelligent parameter transfer mechanism based on gated multi-expert (GME).

[0080] Figure 2 This is a schematic diagram of a parallel fluid-structure interaction simulation method for the entire core provided in an embodiment of the present invention.

[0081] like Figure 2 As shown, the specific implementation process is detailed below:

[0082] B. Initialization Phase: Building the Simulation Foundation and Geometric Intelligent Perception Engine

[0083] This phase aims to lay the foundation for subsequent dynamic simulation calculations, particularly by building a hierarchical index forest (CLGIF) for efficient management and querying of massive amounts of dynamically coupled interface geometry information.

[0084] B.1. System Initialization and Global Configuration:

[0085] B.1.1. Load the full core geometry model, material properties, initial physics conditions, and simulation control parameters (such as time step strategy, coupling algorithm selection, convergence criteria, etc.).

[0086] B.1.2. Initialize the large-scale parallel computing environment, allocate computing resources (processes / threads), and establish the basic communication topology.

[0087] B.2. Core Geometric Recognition and Distributed Task Partitioning:

[0088] B.2.1. Accurately identify and discretize all fluid-structure interaction interfaces within the reactor core to form hundreds of millions or even more basic fluid-structure interaction units (FSCUs).

[0089] B.2.2. Based on preset strategies (such as spatial proximity and load balancing considerations), the massive number of FSCUs are divided into several management batches, and the processing tasks of each batch are assigned to specific computing process pairs (usually a pair of processes are responsible for the fluid side and solid side interface respectively).

[0090] B.3. Parallel construction of local spatial index trees:

[0091] B.3.1. After receiving the task assignment, each computing process constructs an efficient local hierarchical index tree on both the fluid and solid sides for the FSCU subset it is responsible for, in parallel and independently. This process makes full use of distributed computing resources.

[0092] B.4. Asynchronous aggregation to generate batch-level index forest (BLIF):

[0093] B.4.1. After the local hierarchical index tree is constructed, each computing process sends its generated tree structure information (preferably a lightweight metadata representation containing key topology and boundary information) to its designated batch master process (BMP) via a non-blocking asynchronous communication mechanism. Asynchronous communication is used to maximize the overlap between computation and communication while minimizing the overhead of synchronization waiting.

[0094] B.4.2. BMP is responsible for listening to and collecting metadata sent by all processes within its batch. Once the data is collected, it efficiently integrates it to build a batch-level index forest (BLIF) for that batch. The BLIF logically unifies the local spatial relationships within the batch.

[0095] B.5. Hierarchical Construction of Global Core Index Forest (CLGIF):

[0096] B.5.1. After all BMPs have completed BLIF construction, they also send the key summary information (metadata) of their respective BLIFs to the Global Master Process (GMP) through efficient communication methods.

[0097] B.5.2.GMP is responsible for aggregating information from all BMPs and, based on the global spatial topology, ultimately constructing a hierarchical global core index forest (CLGIF) that covers the entire reactor core and provides a globally consistent view. CLGIF is not just a static snapshot; its design inherently supports subsequent dynamic updates.

[0098] C. Time-stepping simulation loop: Iterative evolution and deep optimization of coupled physics

[0099] Under the precise control of the top-level coordination module, this core loop iteratively advances the simulation time, performing physics calculations, data exchange, and geometric updates until the predetermined simulation endpoint is reached.

[0100] C.1. Computation time step start and iteration initialization:

[0101] C.1.1. The top-level coordination module is used to announce the start of the current computation time step.

[0102] C.1.2. Initialize the iteration counter, set the initial value of the physical field, and set the convergence state flag.

[0103] C.2. Parallel Physics Solver Execution and DPMSO Performance Enhancements:

[0104] C.2.1. Solver Invocation Trigger: Based on the coupled algorithm logic, the top-level coordination module instructs the fluid solver and solid solver to start calculations in parallel. The solver performs calculations based on the interface boundary conditions passed from the previous time step.

[0105] C.2.2. Real-time intervention and deep optimization of the DPMSO strategy: When the solver performs core calculations, especially when dealing with mixed computational loads common in solving large-scale linear systems (such as computationally intensive DGeMM and memory-intensive SpMV), the DPMSO strategy is dynamically activated to maximize hardware performance and parallel efficiency.

[0106] C.2.2.1. Intelligent perception of task characteristics and monitoring of resource status: DPMSO analyzes in real time the characteristics of the current computing task to be executed (computation intensity, memory access mode, data dependency, etc.) as well as the real-time load and availability of various hardware resources on the computing node (CPU cores, GPU stream processors, memory controllers, network interfaces, etc.).

[0107] C.2.2.2. Dynamic Resource Flow and Fine-grained Multi-stream Management: Based on the perception results, DPMSO intelligently and dynamically adjusts the mapping relationship between computing tasks and hardware resources. For example, it prioritizes scheduling DGeMM-type tasks to GPU cores with high computing power, optimizes the execution of SpMV-type tasks on the CPU or utilizes the high bandwidth memory of the GPU, and fine-grained manages CUDA streams or similar mechanisms to create independent execution paths for different types of tasks, achieving efficient collaboration of heterogeneous resources.

[0108] C.2.2.3. Deep Overlapping Orchestration of Computation-Memory Access-Communication: DPMSO actively utilizes technologies such as pipelining, software prefetching, and asynchronous data transmission (overlapping of computation and I / O, and overlap of computation and MPI communication) to carefully orchestrate the execution order of tasks and data flow, minimizing memory access latency and communication latency, and achieving deep concurrency and collaboration of computation, memory access, and communication operations.

[0109] C.2.2.4. Adaptive Task Granularity and Pipeline Scheduling: DPMSO dynamically adjusts the granularity of task decomposition based on real-time performance feedback and organizes subtasks into efficient execution pipelines, further squeezing the hardware's parallel potential and reducing idle cycles.

[0110] C.3. High-fidelity parameter transfer: CLGIF empowerment and GDRA-RBF intelligent mapping:

[0111] C.3.1. Data Exchange Command Issuance and Geometric Query Initiation: After the solver completes the calculation, the top-level coordination module issues an interface data exchange command. The parameter transfer module then starts.

[0112] C.3.2. Large-scale spatial association matching accelerated by CLGIF: The parameter passing module utilizes the hierarchical structure and distributed characteristics of CLGIF to perform highly parallelized spatial queries. First, it quickly locates relevant BLIF and index tree pairs, and then efficiently traverses within these local structures, accurately matching hundreds of millions of spatial association nodes / cell pairs on the fluid-structure interface with near-logarithmic time complexity.

[0113] C.3.3. Core Execution of GDRA-RBF Intelligent Parameter Mapping: For successfully matched point pairs, the GDRA-RBF mapping mechanism is activated to achieve precise transmission of physical quantities (such as force, displacement, etc.).

[0114] C.3.3.1. Local Multidimensional Feature Extraction and Contextualization: For each target point to be interpolated, the system extracts multidimensional feature information in its local neighborhood. This includes not only the static grid point distribution density, but also dynamic gradient magnitude and direction that characterize the physical field state. It can even incorporate time-series information such as historical mapping errors or convergence speed to form a contextualized understanding of the physical and geometric environment of the local region.

[0115] C.3.3.2. GME-Driven Adaptive Optimal Support Radius Prediction: The extracted local feature vectors are input into a pre-trained offline gated multi-expert (GME) neural network model. As an intelligent decision engine, the GME model can accurately predict the local support radius that best balances accuracy and robustness when performing RBF interpolation in a specific region, based on the real-time local features input. This radius is dynamically generated and adaptively changes with the characteristics of the region.

[0116] C.3.3.3. Efficient Localized RBF Interpolation: Based on the tailored local support radius predicted by GME, small-scale, well-defined local RBF interpolation calculations are performed. This greatly improves computational efficiency (avoiding the solution of large-scale, dense linear systems globally), and at the same time, through the adaptability of the radius, it significantly improves the interpolation fidelity in complex regions such as abrupt gradient changes and mesh distortions, effectively overcoming the limitations of traditional methods.

[0117] C.4. Coupling Convergence Assessment and Iterative Decision Making:

[0118] C.4.1. Residual Calculation and Convergence Criterion Verification: The top-level coordination module collects the interface physical quantities after parameter transfer, calculates the residual norm of the parameters with the target value or the previous iteration value, and compares it with the preset convergence threshold.

[0119] C.4.2. Iterative Loop Control:

[0120] If the convergence criterion is not met and the number of iterations has not reached the upper limit, it is determined that the iteration needs to continue, and the process returns to step C.2 to use the updated boundary conditions for the next round of solver calculation and parameter transfer.

[0121] If the convergence criterion is met or the maximum number of iterations is reached, the coupling calculation at the current time step is considered complete, and the next step is initiated.

[0122] C.5.CLGIF: Dynamic structural maintenance and real-time synchronization of geometric state.

[0123] C.5.1. Update Trigger Decision: After the coupled computation (all iterations) at a time step is completed, the system evaluates the degree of interface geometric deformation. If the deformation exceeds a preset threshold, it indicates that CLGIF needs to be updated to reflect the current geometric configuration.

[0124] C.5.2. Efficient Localized Index Tree Updates and Global Synchronization: After an update is triggered, the relevant computation processes perform efficient, typically incremental, update operations (such as node insertion, deletion, and position adjustment) on the local index tree they are responsible for, rather than global reconstruction. The updated local structure information is quickly synchronized to the corresponding BLIF and even CLGIF global views through metadata changes, ensuring that the index forest always maintains a high-fidelity representation of the latest geometric state and efficient query capabilities.

[0125] C.6. Time Step Termination and Coupled Process Management:

[0126] C.6.1. Step to the next time point: If the current simulation time has not reached the preset endpoint, the top-level coordination module will advance the coupled calculation time by one step, return to step C.1, and start the calculation loop of the next complete time step.

[0127] C.6.2. Termination of Coupled Calculation and Output of Results: If the simulation end time is reached or other termination conditions are met, the top-level coordination module issues a termination command, the system completes the final calculation and data processing, outputs the final or specified simulation results, and safely releases the computing resources.

[0128] Figure 6 This is a schematic diagram of a full-core parallel fluid-structure interaction simulation system provided as an embodiment of the present invention. Figure 6 As shown, the system logically or physically integrates the following core functional modules:

[0129] ① Global Cooperative Coupled Simulation Scheduling Module: Acts as the "command center", responsible for overall process control, time stepping, solver scheduling, convergence judgment and inter-module communication triggering.

[0130] ② Hierarchical Index Forest (CLGIF) Management Module: Responsible for the distributed parallel construction, efficient dynamic updates, and provision of fast geometric query services for CLGIF.

[0131] ③ High-performance parallel solver module: Embedded or tightly integrated numerical solvers for fluid and solid physics fields, and applied with the Dynamic Parallel Multi-Solver Optimization (DPMSO) module to maximize its computational performance and scalability.

[0132] ④ Intelligent parameter transfer module: responsible for executing the exchange of physical quantities on the fluid-solid interface. Its core is the GME-driven region-aware RBF (GDRA-RBF) mapping engine, which ensures the accuracy and efficiency of the transfer.

[0133] These modules are tightly coupled and work together through standardized interfaces and efficient underlying communication mechanisms (such as MPI, shared memory, RDMA, etc.), together forming the advanced, efficient, and high-fidelity full-core parallel fluid-structure interaction simulation solution proposed in this invention.

[0134] Furthermore, the detailed implementation steps for the core module are as follows.

[0135] B.3. Hierarchical Index Tree Construction Process

[0136] In this embodiment of the invention, constructing efficient hierarchical index trees (Tf and Ts) for the fluid-side interface (fi) and solid-side interface (si) of each fluid-structure interaction unit (FSCU) is key to achieving subsequent rapid geometric matching. (Refer to...) Figure 3 The exemplary structure shown follows a carefully designed bottom-up spatial partitioning and hierarchical aggregation strategy, with the following specific steps:

[0137] B.3.1. Axial Segmentation:

[0138] For a given FSCU interface geometry (e.g., complex 3D mesh data fi or si representing the fuel rod surface or coolant channel wall), strategic segmentation is first performed along its primary extension direction (typically the reactor core axis, i.e., the Z-axis). The entire interface is then divided axially into n predefined, continuous, but non-overlapping layers. For example... Figure 3 As shown in the hollow cylinder diagram, the structure is divided into segments numbered 1 to n along its height. This step constitutes the first level of decomposition of the index tree hierarchy.

[0139] B.3.2. Intra-Layer Slicing:

[0140] After completing the axial layering, the interface geometry within each axial layer is further subdivided. The geometric region within that layer is divided into m slices. For example... Figure 3 The second layer is divided into sectors numbered 1 to m, as shown.

[0141] Key optimization: To achieve load balancing for subsequent computational tasks, this slicing is not a simple equal-angle or equal-arc-length division. Instead, it is adaptively divided based on the actual distribution density of mesh cells within the layer, aiming to ensure that each slice contains approximately the same number of mesh cells (or nodes). This may result in uneven shapes or sizes of slices in physical space, but it ensures a relatively balanced computational load for processing these slices (i.e., leaf nodes).

[0142] B.3.3. Leaf Node Generation:

[0143] Each slice defined in step B.3.2 and all its internal mesh points / elements are mapped as a single leaf node in the hierarchical index tree. Therefore, each axial layer produces m leaf nodes, and the entire index tree contains a total of m×n leaf nodes.

[0144] Leaf node attributes: Each leaf node stores or associates the following key information:

[0145] Spatial extent: Defines the spatial bounding box or precise geometric description of the geometric region represented by this leaf node.

[0146] Angle range: For cylindrical geometry, its angle range relative to the central axis can be recorded.

[0147] Mesh data pointer / reference: Points to or directly contains the original mesh cell data corresponding to the leaf node. This data itself contains detailed information, such as the spatial position of each mesh point, physical quantity values ​​(such as pressure, displacement, etc., which will be updated during the simulation), and adjacency relationships.

[0148] Hierarchical pointer: points to its unique parent node (i.e., the branch node to which it belongs).

[0149] B.3.4. Branch Node Aggregation:

[0150] All m leaf nodes belonging to the same axial layer are aggregated to form a branch node. Each axial layer corresponds to one branch node, so the entire index tree contains n branch nodes. A branch node represents the overall spatial extent of its axial layer.

[0151] Branch node attributes: Each branch node stores:

[0152] Spatial extent: The total bounding box that covers the spatial extent of all its subordinate leaf nodes.

[0153] Hierarchical pointer: points to its unique parent node (i.e., the root node) and all its subordinate child nodes (m leaf nodes).

[0154] B.3.5. Root Node Formation:

[0155] All n branch nodes (representing all axial layers) are eventually aggregated under a single root node. The root node represents the global spatial extent of the entire FSCU interface.

[0156] Root node attributes: Root node storage:

[0157] Global spatial extent: The total bounding box that covers the spatial extent of all its subordinate branch nodes, i.e., the bounding box of the entire FSCU interface.

[0158] Hierarchical pointer: points to all its subordinate child nodes (n branch nodes).

[0159] At this point, a complete hierarchical index tree (Tf or Ts) with a three-tiered "root-branch-leaf" structure is constructed. This tree structure (e.g., ...) Figure 3 (As shown in the upper right and lower right) It efficiently organizes the spatial information of complex interface geometry.

[0160] B.4. Parallel Construction and Metadata Integration of Batch-Level Index Forest (BLIF)

[0161] After all computing processes have completed the construction of Tf and Ts for their respective FSCU pairs in parallel, this information needs to be integrated at the batch level to form a batch-level index forest (BLIF).

[0162] B.4.1. Lightweight Metadata Encapsulation and Asynchronous Transmission:

[0163] After each computation process completes the construction of the Tf and Ts corresponding to its assigned (fi,si), it does not directly transmit the massive tree structure itself. Instead, it encapsulates the key information of Tf and Ts (such as the bounding box of the root node, the depth of the tree, the number of leaf nodes, the unique identifier, etc.) and the batch information (w) to which the FSCU belongs into a lightweight meta-data packet (Mfs).

[0164] Subsequently, the process sends this metadata packet Mfs to the designated batch master process (BMPw) responsible for managing this batch (Bw) via non-blocking asynchronous communication. Asynchronous sending allows the computation process to continue executing other tasks while the data is being transmitted, or to finish the current task more quickly, thereby improving parallel efficiency.

[0165] B.4.2. Metadata Collection by the Batch Master Process (BMP):

[0166] BMPw is responsible for listening to and receiving metadata packets (Mfs) sent by all computing processes within its managed batch (Bw). It maintains a list (Mw) to store all collected metadata. Because the reception is also asynchronous, BMP can efficiently process data from multiple sources.

[0167] B.4.3. Metadata Integration and BLIF Construction:

[0168] Once BMPw confirms that it has received all the expected metadata data packets within the batch Bw, it further organizes all the collected metadata (Mw) to build a batch-level index forest (BLIFw).

[0169] BLIFw is essentially a metadata index structure that contains summary information and access handles (or pointers) of the index tree (Tf, Ts) for all FSCU pairs within batch Bw. BLIFw also contains a spatial index for all FSCU pairs within the batch (such as a higher-level tree or grid built based on the root node bounding box) to facilitate faster coarse-grained queries within or across batches.

[0170] B.5. Hierarchical Integration of the Global Core Index Forest (CLGIF)

[0171] Finally, the BLIF information from all batches is aggregated into the Global Master Process (GMP) to construct the final CLGIF, which covers the entire stack core.

[0172] B.5.1. Transmission of BLIF information to GMP:

[0173] After successfully building a BLIFw, each BMPw sends it (or its key summary information) to a unique Global Master Process (GMP).

[0174] B.5.2. Global Integration and CLGIF Formation:

[0175] GMP is responsible for receiving BLIFw information from all BMPs.

[0176] GMP performs a final hierarchical integration of all received BLIF information, that is, it builds a hierarchical index structure on top of all BLIFs, which is organized based on the macroscopic spatial regions and angular ranges represented by the BLIFs.

[0177] The resulting Global Core Index Forest (CLGIF) is a globally unified, hierarchical data structure. It not only contains an index of metadata for all FSCU index trees across the entire heap core, but also has a built-in efficient cross-batch query mechanism. CLGIF provides a globally consistent view of the entire complex coupled interface geometry and offers robust data structure support for the large-scale, fast spatial association matching required in the subsequent parameter passing phase (step C.3.2). Furthermore, its hierarchical and distributed metadata design provides the foundation for its dynamic updates (step C.5).

[0178] C.3. High-efficiency and high-precision parameter transfer: CLGIF empowerment and GDRA-RBF intelligent mapping

[0179] This core component is responsible for the accurate and efficient transfer of physical quantities (such as force and displacement) between fluid-structure interaction interfaces (usually mismatched meshes). This embodiment of the invention is based on a region-aware radial basis function (GDRA-RBF) mapping mechanism driven by a gated multi-expert (GME) neural network, combined with the previously constructed hierarchical indexed forest (CLGIF). The core of this mechanism is the use of a neural network model with a specific structure (in this embodiment, its structure corresponds to...) Figure 4 The model structure shown is used to intelligently predict the local optimal RBF support radius. The specific implementation steps are as follows:

[0180] C.3.1. Initialization and Parallel Task Distribution:

[0181] C.3.1.1. Input Preparation: Receive data exchange instructions from the top-level coordination module, obtain the currently valid Global Core Index Forest (CLGIF) and a key component: a pre-trained offline gated multi-expert support radius prediction model (GMESR).

[0182] Model pre-training description: To ensure the effectiveness of the GMESR model, in this preferred embodiment, the model has been fully trained on a dataset containing, for example, 1200 training samples and 800 test samples (e.g., trained for 100 epochs). The training process demonstrated good convergence (e.g., the loss decreased rapidly in the first 10 epochs and then stabilized), and achieved satisfactory performance on the test set (e.g., the mean squared error (MSE) reached 0.6278). This validated, well-trained GMESR model was directly used for support radius prediction in the online simulation process.

[0183] C.3.1.2. Parallel Domain Decomposition: The global GMESR is logically decomposed into its k batch-level index forests ({BLIF1,...,BLIFk}). The parameter passing task will be parallelized at these batch levels.

[0184] C.3.1.3. Tree Pair Extraction and Task Allocation: Within each BLIFw, extract all fluid-fixed index tree pairs {(Tf,Ts)}all that require parameter passing. These tree pairs constitute the basic task units of the second layer of parallelization and will be dynamically allocated to available computing resources for processing.

[0185] C.3.2.CLGIF-accelerated large-scale spatial association matching:

[0186] C.3.2.1. Parallel Tree Traversal and Matching: For each assigned tree pair (Tf, Ts), an empty set L is initialized to store the matching results. Subsequently, the leaf nodes of Tf and Ts are traversed in parallel.

[0187] C.3.2.2. Efficient Leaf Node Matching: Utilizing the hierarchical structure of Tf and Ts (root-branch-leaf) and the spatial extent information stored at each level of nodes (especially branch and leaf nodes), fast pruning and spatial querying are performed. The goal is to efficiently identify and match spatially related fluid-side leaf node (lf) and solid-side leaf node (ls) pairs (e.g., distance less than a certain threshold or overlapping regions). All successfully matched leaf node pairs (lf, ls) are stored in a set L. The CLGIF structure greatly accelerates this process, avoiding brute-force global searches.

[0188] C.3.3. GDRA-RBF Intelligent Parameter Mapping Core Execution (parallel execution for each matching pair (lf, ls) in set L):

[0189] C.3.3.1. Local Contextualized Feature Vector Extraction (Construction of Flf, ls):

[0190] For the currently processed matching leaf node pair (lf, ls), the system needs to extract multi-dimensional feature information that reflects its local physical and geometric environment characteristics. These features constitute the vector Flf,ls input to the gated multi-expert support radius prediction model GMESR, and typical features include:

[0191] Local mesh density: The distribution density of mesh points inside and in the vicinity of leaf nodes on the source side (e.g., lf) and the target side (e.g., ls) can be obtained by analyzing the mesh data contained in the leaf nodes.

[0192] Physical parameter gradient: The magnitude and direction of the spatial gradient of the physical quantity (e.g., pressure) to be transmitted at the source side (e.g., lf). This reflects the degree of drastic local changes in the physical field and can be obtained by numerical difference calculation of the physical quantity values ​​at the source-side nodes.

[0193] Historical mapping error: The magnitude or convergence of the error caused by parameter transfer in this region (or similar region) in previous simulation time steps or coupled iterations.

[0194] These extracted scalar or vector features are combined and normalized to form the input feature vector Flf,ls.

[0195] C.3.3.2. GME-driven adaptive optimal local support radius prediction (obtaining R):

[0196] The constructed feature vector Flf,ls is input into the input layer of the pre-trained GMESR model (refer to...). Figure 4 (Structure diagram).

[0197] Feature encoding: The feature vector is first passed through a shared feature encoding layer (such as...) Figure 4 The Dense(32,ReLU) method is used for preliminary nonlinear feature extraction and dimensionality reduction.

[0198] Parallel processing using expert networks: Encoded features are simultaneously fed into multiple parallel expert networks. Each expert network has a different structure or focus, aiming to predict the optimal radius from different perspectives or for different feature patterns. For example (see...) Figure 4 (Model structure):

[0199] Expert Network A: It adopts a deep residual network structure, which contains multiple residual blocks (containing Dense layers, Batch Normalization and Residual Connection), and is good at capturing complex nonlinear relationships, and finally outputs a candidate support radius RA.

[0200] Expert Network B: Employs a branch with Dropout regularization, containing multiple Dense layers with Dropout, designed to improve the model's generalization ability and robustness, ultimately outputting another candidate support radius RB.

[0201] More expert networks with different characteristics can be designed.

[0202] Dynamic weight allocation in the gating module: The encoded features are also fed into a separate gating module. This module learns a decision function based on the current input features Flf,ls, and its output is a set of normalized weights (e.g., w1, w2, and w1 + w2 = 1). These weights dynamically reflect which (or more) expert network predictions are more reliable for the current local context.

[0203] Weighted fusion outputs the optimal radius: Finally, the system weights and fuses the candidate radii (RA, RB, ...) output by each expert network with the corresponding weights (w1, w2, ...) output by the gating module to obtain the final predicted optimal support radius R for the current local region (lf, ls). This support radius is highly adaptive and can be dynamically adjusted according to local features to achieve the best interpolation effect.

[0204] C.3.3.3. Efficient Localized Radial Basis Function (RBF) Interpolation Calculation:

[0205] After obtaining the optimal local support radius R, the system performs localized RBF interpolation.

[0206] Neighborhood determination: For each target grid point ps that needs to receive parameters in the target leaf node ls, using the local structure of the local leaf node lf of the source side index tree and the predicted radius R, quickly find all source grid points {pfj,.....} in the source leaf node lf that are within the support radius R of ps.

[0207] Constructing a local RBF system: Using only the source points {pfj,.....} within these local neighborhoods and their corresponding physical quantity values ​​{ofj,.....}, construct a small-scale RBF interpolation equation system.

[0208] Solution and Mapping: Efficiently solve this small-scale linear system to obtain the mapped physical quantity value osj at the target point ps.

[0209] Advantages: This localized computation significantly reduces computational complexity and memory requirements, avoiding the construction and solution of potentially ill-conditioned large-scale dense linear systems, enabling the high-precision RBF method to be efficiently applied to full-core-scale simulations. Simultaneously, the adaptability of the radius R ensures good interpolation accuracy in different regions (such as regions with smooth physical quantities or regions with abrupt gradient changes).

[0210] C.3.4. Data Structure State Update:

[0211] C.3.4.1. Physical quantity update: Update the mapped physical quantity values ​​(such as osj) obtained by GDRA-RBF calculation to the data structure associated with the target leaf node ls, for use by the subsequent solid solver or other modules.

[0212] C.3.4.2. Index Tree State Reflection: If the calculated physical quantities (especially displacements) lead to significant changes in geometric position, or if information such as mapping quality needs to be recorded, an update to the state of the relevant index tree and the upper-level forest structure can be triggered. This is primarily to ensure that CLGIF accurately reflects the latest system state (including geometric position and possible metadata) in subsequent simulation steps, laying the foundation for the next query or update. Note that this usually reflects the result, rather than modifying the mapping process itself.

[0213] C.3.5. Result Aggregation and Output: Summarize the parameter mapping results completed by all parallel processing units. Further, return the complete, updated physical parameter field on the target mesh, and the potentially updated global core index forest 'CLGIF'.

[0214] C.2. Parallel Physics Solver Execution and DPMSO Performance Enhancement

[0215] In the time-stepping loop of full-core fluid-structure interaction simulation, the computational efficiency of the physical solver is crucial. This invention employs a Dynamic Parallel Multistream Optimization (DPMSO) strategy, specifically targeting large-scale sparse matrix-vector multiplication (SpMV) and dense matrix multiplication (DGeMM) operations commonly found in the solver's core computation, to maximize hardware utilization (such as GPUs or similar accelerators) and parallel computing efficiency.

[0216] C.2.1. Solver Invocation Trigger: Based on the coupled algorithm logic, the top-level coordination module instructs the fluid solver and solid solver to start computation in parallel. These solvers generate a large number of computational operations when performing their core tasks (such as solving large-scale linear systems), especially loads that combine computationally intensive (such as dense matrix multiplication DGeMM) and memory-intensive (such as sparse matrix-vector multiplication SpMV) operations.

[0217] C.2.2. Application and Deep Optimization of the DPMSO Strategy: To cope with the aforementioned mixed computational loads and maximize hardware performance (especially accelerators such as GPUs) and parallel efficiency, the Dynamic Parallel Multistream Optimization (DPMSO) strategy is dynamically activated during the solver's core computation phase. DPMSO uses a series of collaborative mechanisms to finely manage task execution. Its core is to utilize computational streams (such as HIP or CUDA streams) to achieve parallelism and overlap, and to control the optimization level through a stream splitting flag (enable_shunt).

[0218] C.2.2.1. Intelligent perception of task characteristics and monitoring of resource status (the decision-making basis of DPMSO):

[0219] (a) Task Characteristics Analysis: Before executing any computational task, DPMSO first analyzes the task set $Tasks = {spmv1,...,spmvm,gemm1,...,gemmn} to understand its inherent requirements:

[0220] Type recognition: The task is to distinguish between SpMV and DGeMM.

[0221] Computation / Memory Access Characteristics Assessment: Estimate the computational intensity (e.g., FLOPs) and expected memory bandwidth requirements for each task.

[0222] Data dependency analysis: a key step, accurately identifying data dependencies (spmv_deps, dgemm_deps) between tasks. This forms the basis for subsequent task grouping and parallel scheduling, used to identify a set of tasks that can be safely executed in parallel.

[0223] (b) Resource Status Monitoring: DPMSO monitors the dynamic load and availability of various hardware resources on the compute nodes in real time or periodically.

[0224] Query hardware status: Use underlying hardware interfaces or libraries (such as NVML for NVIDIA GPUs, ROCm SMI for AMD GPUs, etc.) to query the GPU's stream processor (SM) utilization, memory bandwidth usage, temperature, etc.

[0225] Monitor CPU and memory: Monitor CPU core load, cache hit rate, and main memory bandwidth usage.

[0226] Network status awareness (if distributed computing is involved): Monitor the bandwidth usage and latency of network interfaces.

[0227] Maintaining Resource View: DPMSO maintains an internal representation of the current system resource "hot" and "idle" regions.

[0228] (c) Comprehensive decision-making information: Combining task characteristics (demand) with resource status (supply) to provide a basis for decision-making in subsequent dynamic resource allocation and flow management.

[0229] C.2.2.2. Dynamic Resource Diversion and Fine-grained Management of Multiple Flows (DPMSO's Core Scheduling and Execution Mechanism):

[0230] Based on the perception results of C.2.2.1, such as Figure 5 As shown, DPMSO intelligently and dynamically manages the mapping of tasks to resources and the execution flow:

[0231] (a) Heterogeneous resource routing (if the system contains heterogeneous resources such as CPU+GPU): Determine the best execution unit for a task based on task characteristics and resource status. For example, computationally intensive and highly parallel DGeMM tasks are preferentially scheduled to be executed on the GPU; certain SpMV tasks with special memory access patterns or smaller scales are scheduled accordingly if it is better to execute them on the CPU (utilizing its large cache) or on the GPU using optimized memory access patterns (such as utilizing high-bandwidth memory).

[0232] (b) Fine-grained multi-stream management: After selecting the execution resources (mainly for GPUs), the specific implementation of task parallelization is as follows:

[0233] Mode selection: Check the enable_shunt flag.

[0234] Basic parallel mode (enable_shunt=False):

[0235] Create two base streams, stream_spmv and stream_dgemm.

[0236] Assign all SpMV tasks to stream_spmv and all DGeMM tasks to stream_dgemm.

[0237] Start streaming execution to achieve simple parallelism between the two types of tasks.

[0238] Returns the pool containing both streams.

[0239] Task grouping and multi-stream optimization mode (enable_shunt=True):

[0240] Task grouping: Based on the dependencies spmv_deps and dgemm_deps obtained in C.2.2.1(a), the GroupTasks() function is called to aggregate the independent SpMV and DGeMM tasks into independent task groups spmv_groups and dgemm_groups respectively.

[0241] Stream count control: Calculate the total number of groups (total_groups) and compare it with MAX_STREAMS. If the limit is exceeded, call MergeGroups() to merge groups, ensuring that the number of streams does not exceed the limit, resulting in merged_groups.

[0242] Priority and stream creation / assignment: Traverse each group g in merged_groups:

[0243] Use the group size (GroupSize(g)) as the priority (or other strategies to determine the priority).

[0244] Create a priority stream.

[0245] Assign tasks within group g to this stream.

[0246] Add the stream to the stream pool.

[0247] Returns a pool containing all created streams.

[0248] C.2.2.3. Computation-Memory Access-Communication Deep Overlap Orchestration:

[0249] DPMSO actively utilizes the multi-stream environment created in C.2.2.2, carefully orchestrating the operation sequence and data flow to minimize latency:

[0250] (a) Computation overlap: Distribute independent computational tasks (from different groups g) onto different streams so that they can be executed in parallel at the hardware level.

[0251] (b) Overlapping computation and memory access:

[0252] By leveraging the asynchronous execution characteristics of streams, data transfer operations can be initiated to different streams simultaneously with the startup of computing cores (such as kernels on GPUs), thus achieving overlap between computation and data transfer.

[0253] Software prefetching: For CPU-side computation or data preparation phases, prefetch instructions are used to load the data that will be needed soon into the cache in advance. For GPUs, data can be pinned to host memory before data transfer to accelerate the transfer process.

[0254] (c) Overlapping computation and communication: Simulation computation involves multi-node parallel computation, and DPMSO coordinates the computation stream and MPI communication operations. For example, while one computation stream is performing the current time step computation, another stream (or background thread) starts asynchronous MPI reception (such as MPI_Irecv) for the data required for the next time step, or sends the result of the current step computation (such as MPI_Isend).

[0255] (d) Pipeline construction: For task chains with dependencies (e.g., data loading -> SpMV -> DGeMM -> data write-back), DPMSO can map these stages to different streams or use intra-stream synchronization mechanisms (such as CUDA Events) to build an execution pipeline, so that different stages of different tasks can be executed in an overlapping manner.

[0256] (e) Launch and Synchronization: Set the launch function LaunchStream() to start all configured streams. And when necessary (such as when the solver iteration ends or when global synchronization is required), use synchronization primitives (such as cudaDeviceSynchronize or synchronization of a specific stream) to ensure that all dependent operations complete.

[0257] C.2.2.4. Adaptive Task Granularity and Pipeline Scheduling:

[0258] The DPMSO strategy is designed with adaptive capabilities, allowing it to adjust based on runtime performance feedback rather than being completely static.

[0259] (a) Performance monitoring and feedback: DPMSO continuously monitors (or periodically samples) the actual execution time, resource utilization (from C.2.2.1(b)) and potential bottlenecks of the task flow orchestrated by C.2.2.3.

[0260] (b) Dynamically adjust task granularity: If monitoring finds that the task groups of certain flows are too small, resulting in a high proportion of startup overhead, or too large, causing a single flow to become a bottleneck and unable to fully utilize hardware parallelism, DPMSO can adjust the strategies of GroupTasks and MergeGroups in subsequent executions (such as changing the grouping threshold or merging logic) to seek a better task granularity.

[0261] (c) Optimize pipeline scheduling: Based on performance feedback, DPMSO can adjust the phase division, resource allocation (e.g., assign higher priority flows to tasks on the critical path) or synchronization method of the pipeline built in C.2.2.3(d) to optimize overall throughput and latency.

[0262] (d) Learning and Evolution: In more advanced implementations, DPMSO may include a simple learning mechanism (e.g., recording performance under different scheduling policies) to gradually “learn” the optimal parameter configuration and scheduling mode for a specific hardware platform and problem size.

[0263] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A parallel fluid-structure interaction simulation method for the entire reactor core, characterized in that, Includes the following steps: Identify and discretize all fluid-structure interaction interfaces within the reactor core to form basic fluid-structure interaction units (FSCUs); based on a preset strategy, divide the FSCUs into several management batches and assign the processing tasks of each batch to specific computing process pairs; After receiving the task assignment, each computing process constructs an efficient local hierarchical index tree on both the fluid and solid sides for the FSCU subset it is responsible for. After the local hierarchical index tree is built, each computing process sends the tree structure information it generates to the designated master process (BMP) of its batch through a non-blocking asynchronous communication mechanism. The BMP is responsible for listening to and collecting the metadata sent by all processes in its batch. After the data is collected, it is integrated to build the batch-level index forest (BLIF) for that batch. After all BMPs complete the BLIF construction, they send the key summary information of their respective BLIFs to the global master process GMP. GMP is responsible for collecting information from all BMPs and, based on the global spatial topology, finally constructing the global core index forest CLGIF. The top-level coordination module is used to announce the start of the current computation time step; initialize the iteration counter, set the initial values ​​of the physics field, and set the convergence status flag; The top-level coordination module, based on the coupled algorithm logic, instructs the fluid solver and solid solver to start calculations in parallel; the solvers perform calculations based on the interface boundary conditions passed from the previous time step. When the solver handles the mixed computational load in solving large-scale linear systems, the Dynamic Parallel Multistream Optimization (DPMSO) strategy is dynamically activated. After the solver completes the calculation, the top-level coordination module issues an interface data exchange command, and the parameter transfer module is then activated. The parameter transfer module utilizes the hierarchical structure and distributed characteristics of CLGIF to perform spatial queries; and for successfully matched point pairs, it initiates the GDRA-RBF mapping mechanism to realize the transfer of physical quantities. The top-level coordination module collects the interface physical quantities after parameter transmission, calculates the residual norm of the parameters with the target value or the previous iteration value, and compares it with the preset convergence threshold. If the convergence criterion is not met and the number of iterations has not reached the upper limit, it is determined that the iteration needs to continue, and the updated boundary conditions are used to perform the next round of solver calculation and parameter transfer; if the convergence criterion is met or the maximum number of iterations is reached, the coupling calculation of the current time step is considered to be completed, and the next step is initiated. After the coupled calculation at a time step is completed, the system evaluates the degree of interface geometric deformation; if the deformation exceeds a preset threshold, it indicates that CLGIF needs to be updated to reflect the current geometric configuration. After an update is triggered, the relevant computing processes perform efficient, incremental update operations on the local index trees they are responsible for, rather than rebuilding the entire index. The updated local structure information is quickly synchronized to the corresponding global view of BLIF and even CLGIF through metadata changes, ensuring that the index forest always maintains a high-fidelity representation of the latest geometric state and efficient query capabilities. If the current simulation time has not reached the preset endpoint, the top-level coordination module will advance the coupled calculation time by one step and start the calculation cycle of the next complete time step. If the simulation end time is reached or other termination conditions are met, the top-level coordination module issues a termination command, the system completes the final calculations and data processing, outputs the final or specified simulation results, and safely releases computing resources.

2. The method according to claim 1, characterized in that, The step of dynamically activating the DPMSO strategy when the solver handles mixed computational loads in solving large-scale linear systems includes: Intelligent perception of task characteristics and monitoring of resource status: DPMSO analyzes in real time the characteristics of the computing tasks to be executed and the real-time load and availability of various hardware resources on the computing nodes. Dynamic resource routing and fine-grained multi-stream management: Based on the perception results, DPMSO adjusts the mapping relationship between computing tasks and hardware resources; Deeply Overlapping Computation-Memory Access-Communication Orchestration: DPMSO orchestrates the execution order of tasks and the flow of data, hiding memory access latency and communication latency, and enabling deep concurrency and collaboration of computation, memory access and communication operations; Adaptive task granularity and pipeline scheduling: DPMSO dynamically adjusts the granularity of task decomposition based on real-time performance feedback and organizes subtasks into an efficient execution pipeline.

3. The method according to claim 1, characterized in that, The parameter passing module utilizes the hierarchical structure and distributed characteristics of CLGIF to perform spatial query steps, including: First, the relevant BLIF and index tree pairs are located, and then the system efficiently traverses within these local structures to match hundreds of millions of spatially related nodes / cell pairs on the fluid-structure interface with near logarithmic time complexity.

4. The method according to claim 1, characterized in that, The steps for activating the GDRA-RBF mapping mechanism to achieve accurate transfer of physical quantities include: Local multidimensional feature extraction and contextualization: For each target point to be interpolated, the system extracts multidimensional feature information in its local neighborhood to form a contextualized understanding of the physical and geometric environment of the local area; GME-driven adaptive optimal support radius prediction: The extracted local feature vector is input into a pre-trained offline gated multi-expert GME neural network model to predict the local support radius when performing RBF interpolation in a specific region. This radius is dynamically generated and adaptively changes with the characteristics of the region. Efficient localized RBF interpolation calculation: Based on the customized local support radius predicted by GME, local RBF interpolation calculation is performed.

5. The method according to claim 1, characterized in that, A hierarchical index tree is constructed through the following steps: Axial layering: For a given FSCU interface geometry, strategic segmentation is first performed along its main extension direction; the entire interface is divided into n predefined, continuous but non-overlapping layers axially and into segments numbered 1 to n along the height direction. This step constitutes the first level of decomposition of the index tree hierarchy. Intra-layer slicing: After completing the axial layering, the interface geometry inside each axial layer is further subdivided; the geometric region within the layer is divided into m slices. Key optimization: In order to achieve load balancing for subsequent computing tasks, this slice is adaptively divided according to the actual distribution density of grid cells within the layer, with the goal of making each slice contain an equal number of grid cells. Leaf node generation: Each slice and all the grid cells contained within it are mapped as a whole to a leaf node of the hierarchical index tree. Each axial layer generates m leaf nodes, and the entire index tree contains a total of m×n leaf nodes. Branch node aggregation: Aggregate all m leaf nodes belonging to the same axial layer to form a branch node; each axial layer corresponds to one branch node, so the entire index tree contains n branch nodes, and the branch node represents the overall spatial range of its axial layer. Root node formation: All n branch nodes are eventually aggregated under a single root node, which represents the global spatial scope of the entire FSCU interface.

6. The method according to claim 1, characterized in that, Batch-level index forests are built through the following steps: Lightweight metadata encapsulation and asynchronous transmission: After each computing process completes the construction of its assigned Tf and Ts, it encapsulates the key information of Tf and Ts, as well as the batch information to which the FSCU belongs, into a lightweight metadata data packet Mfs. Subsequently, the process sends this metadata data packet Mfs to the designated batch master process BMPw responsible for managing the batch Bw via non-blocking asynchronous communication. Asynchronous transmission allows the computing process to continue executing other tasks while data is being transmitted, or to finish the current task more quickly. Metadata collection by the Batch Master Process (BMP): BMPw is responsible for listening to and receiving metadata data packets (Mfs) sent by all computing processes within its managed batch (Bw). Metadata integration and BLIF construction: After BMPw confirms that it has received all expected metadata data packets within the batch Bw, it further organizes all collected metadata Mw to build a batch-level index forest.

7. The method according to claim 1, characterized in that, The global core index forest is built through the following steps: BLIF information is transmitted to GMP: After each BMPw successfully builds a BLIFw, it sends it to the unique global master process GMP. Global integration and CLGIF formation: GMP is responsible for receiving BLIFw information from all BMPs. GMP performs the final hierarchical integration of all received BLIF information, that is, it builds a hierarchical index structure on top of all BLIFs. This structure is organized based on the macroscopic spatial region and angular range represented by the BLIF. The resulting global core index forest is a globally unified, hierarchical data structure.

8. The method according to claim 1, characterized in that, The parameter passing module is specifically used for: initialization and parallel task distribution; CLGIF-accelerated large-scale spatial association matching; The core execution of the GDRA-RBF intelligent parameter mapping is performed in parallel for each matching pair in set L; Data structure state updates include physical quantity updates and index tree state reflection; Results aggregation and output: Summarize the parameter mapping results completed by all parallel processing units.

9. The method according to claim 1, characterized in that, The top-level coordination module, based on the coupled algorithm logic, instructs the fluid solver and solid solver to initiate computational steps in parallel, including: Solver call trigger: Based on the coupled algorithm logic, the top-level coordination module instructs the fluid solver and solid solver to start computation in parallel; these solvers generate a large number of computational operations when performing their core tasks, especially a mix of computationally intensive and memory-intensive loads; Application and Deep Optimization of DPMSO Strategy: To cope with the above-mentioned mixed computing load and maximize hardware performance and parallel efficiency, the Dynamic Parallel Multistream Optimization (DPMSO) strategy is dynamically activated in the core computing phase of the solver.

10. A full-core parallel fluid-structure interaction simulation system, applied in the method of claim 1; characterized in that, include: The system comprises a global collaborative coupling simulation scheduling module, a hierarchical index forest management module, a high-performance parallel solver module, and an intelligent parameter transfer module; among which... The global collaborative coupling simulation scheduling module is responsible for overall process control, time stepping, solver scheduling, convergence judgment, and inter-module communication triggering. The hierarchical index forest management module is responsible for the distributed parallel construction, efficient dynamic updates, and fast geometric query services of CLGIF. High-performance parallel solver modules are used to embed or tightly integrate numerical solvers for fluid and solid physics fields, and apply dynamic parallel multi-solver optimization modules to maximize their computational performance and scalability. The intelligent parameter transfer module is responsible for performing the exchange of physical quantities on the fluid-structure interface. Its core is the GME-driven region-aware RBF mapping engine, which ensures the accuracy and efficiency of the transfer.

Images