A multi-stage centrifugal pump rotor dynamics modeling method under multiple working conditions

Abstract

This invention specifically relates to a method for modeling the rotor dynamics of a multi-stage centrifugal pump under various operating conditions, belonging to the field of multi-stage centrifugal pump rotor dynamics technology. It includes: analyzing the fluid-structure interaction (FSI) computational task of the multi-stage centrifugal pump, identifying the computational characteristics of the fluid and solid domains, and achieving task mapping and instruction set decoupling with the CPU and GPU; constructing two independent asynchronous bidirectional lock-free circular queues to achieve asynchronous data interaction between the CPU and GPU. In this invention, the identification of FSI task characteristics, accurate CPU-GPU heterogeneous mapping, and bidirectional asynchronous lock-free circular queue design break through the bottleneck of traditional synchronous blocking computation from the bottom layer, solving the problems of mutual waiting between fluid and solid domain computations and low hardware resource utilization; allocating high-parallelism fluid domain computation to the GPU and highly nonlinear solid domain computation to the CPU, combined with instruction set decoupling and independent memory space isolation, enables heterogeneous hardware to perform their respective functions and collaborate efficiently.

Description

Technical Field

[0001] This invention relates to the field of multistage centrifugal pump rotor dynamics technology, and in particular to a method for modeling the rotor dynamics of a multistage centrifugal pump under multiple operating conditions. Background Technology

[0002] Multistage centrifugal pump rotor dynamics modeling relies on fluid-structure interaction numerical simulation, which is a core technology to ensure the safe operation of pump sets. Existing modeling methods have significant shortcomings in five core aspects: heterogeneous computing power adaptation, data interaction mechanism, time schedule coordination, calculation error control, and multi-condition scheduling. Existing technologies do not differentiate the computational characteristics of high-dimensional parallelism in the fluid domain and strong nonlinear serialism in the solid domain, making it impossible to achieve precise task mapping between CPU and GPU. Instruction sets interfere with each other, and the computing power of heterogeneous hardware cannot be fully released. At the same time, the synchronous blocking communication mechanism requires the fluid domain and solid domain to wait for alignment step by step, resulting in a large amount of idle waiting for CPU and GPU, and low computational efficiency.

[0003] Asynchronous parallel computing lacks a time schedule constraint mechanism, which easily leads to physical time mismatch and computational divergence. Data loss caused by time node mismatch during asynchronous processes, without reliable reconstruction and error compensation methods, results in insufficient simulation accuracy. Multi-condition computing adopts static allocation of computing power, which leads to excessive load in complex conditions and idle resources in simple conditions. The utilization rate of GPU clusters is low, the modeling cycle is long, and the scalability is poor, which cannot meet the requirements of multi-condition, high-precision, and high-efficiency rotor dynamics simulation in engineering.

[0004] Therefore, a multi-stage centrifugal pump rotor dynamics modeling method under multiple operating conditions is proposed to address the aforementioned problems. Summary of the Invention

[0005] The purpose of this invention is to provide a method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions in order to solve the above-mentioned problems.

[0006] To achieve the above objectives, the present invention adopts the following technical solution: A method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions includes: The fluid-structure interaction computation task of a multi-stage centrifugal pump is analyzed, the computational characteristics of the fluid domain and the solid domain are identified, and the task is mapped to the CPU and GPU and the instruction set is decoupled. Construct two independent asynchronous bidirectional lock-free circular queues to achieve asynchronous data interaction between the CPU and GPU; Define macroscopic time windows and relaxation tolerance thresholds, monitor the deviation of CPU and GPU computing time progress in real time, and balance asynchronous parallel efficiency and physical computing consistency through corresponding scheduling strategies. To address the data loss issue caused by time mismatch in asynchronous computing, the target data is reconstructed through interpolation / extrapolation algorithms, and dynamic error compensation is performed in conjunction with residual analysis.

[0007] Construct a global multi-condition task pool, monitor hardware resource utilization and convergence of each condition, and dynamically adjust computing power allocation.

[0008] Preferably, the step of analyzing the fluid-structure interaction computation task of a multi-stage centrifugal pump, identifying the computational characteristics of the fluid and solid domains, and realizing the mapping of the task with the CPU and GPU and the decoupling of the instruction set specifically includes: The fluid-structure interaction calculation task for a multi-stage centrifugal pump is broken down using a feature recognition algorithm, and the calculation features of the fluid domain and the solid domain are identified separately. The specific identification logic is as follows: Fluid domain computation task identification: For the impeller internal flow channel and pump casing flow channel of a multi-stage centrifugal pump, the computation content includes flow field distribution, fluid pressure, fluid velocity, and fluid excitation force; through feature recognition algorithms, the core features of fluid domain computation are determined; Solid domain computation task identification: For multi-stage centrifugal pumps, the computation content of rotor and impeller is rotor dynamic characteristics, stress and strain of solid components, displacement and deformation; through feature recognition algorithm, the core features of solid domain computation are determined.

[0009] Preferably, the method further includes: Based on the feature recognition results, the instruction streams of each sub-computation task are packaged and processed. The specific mapping logic is as follows: Fluid domain instruction flow mapping: Package the instruction flow of fluid domain computing tasks, and then map the packaged instruction flow to the GPU cluster, so that the GPU cluster can undertake the large-scale parallel computing tasks in the fluid domain. Solid-state domain instruction stream mapping: The instruction stream of solid-state domain computation tasks is kept on the CPU, and the CPU undertakes the high-frequency serial solution tasks of solid-state domain. Instruction set decoupling: Independent memory address spaces are allocated for fluid domain instruction streams and solid domain instruction streams. At the same time, an instruction set isolation mechanism is set up to prohibit fluid domain instruction streams from calling solid domain computing resources and solid domain instruction streams from calling GPU cluster computing resources. Only the heterogeneous task allocation module is allowed to schedule and manage the two types of instruction streams in a unified manner.

[0010] Preferably, the construction of two independent asynchronous bidirectional lock-free circular queues to achieve asynchronous data interaction between the CPU and GPU specifically includes: In the shared memory of the computer system, two independent asynchronous data buffer queues are created: the excitation force queue and the displacement boundary queue. The excitation force queue is a dedicated queue for transferring data from the fluid domain to the solid domain, and the displacement boundary queue is a dedicated queue for transferring data from the solid domain to the fluid domain. To avoid process blocking caused by traditional locking mechanisms, both queues adopt a lock-free data structure design and use CAS atomic operations to achieve data read and write synchronization. Specific data interaction process: Data transfer from the fluid domain to the solid domain: After the GPU cluster completes the fluid domain calculation for the current time step, it formats the calculated fluid excitation force data and then pushes the data into the excitation force queue through lock-free write logic. Data transfer from the solid domain to the fluid domain: After the CPU completes the solid domain calculation for the current time step, it formats the calculated rotor micro-eccentric displacement data and then pushes the data into the displacement boundary queue through lock-free write logic.

[0011] Preferably, the definition of the macroscopic time window and relaxation tolerance threshold, real-time monitoring of the CPU and GPU computation time deviation, and the implementation of corresponding scheduling strategies to balance asynchronous parallel efficiency and physical computation consistency, specifically include: Fluid Domain Computation Timeline The physical time corresponding to the fluid domain computation currently completed by the GPU cluster; the solid domain computation time schedule. The physical time corresponding to the solid domain currently completed by the CPU; Collected and Then, calculate the absolute value of the deviation between the two. The obtained value is then compared with the relaxation tolerance threshold. Compare the results and execute the corresponding scheduling strategy based on the comparison. When the computing speed of a GPU cluster is faster than that of a CPU, it leads to At this time, the scheduler module immediately triggers the deviation correction strategy.

[0012] Preferably, the method further includes: Macroeconomic time window Based on the calculation objective of the multistage centrifugal pump, if the calculation objective is the steady-state operating characteristics of the centrifugal pump, then... The value can be 1 to 5 seconds; if the calculation target is the transient operating characteristics of a centrifugal pump, then The value is 5~10 seconds; Relaxation tolerance threshold The setting is based on the coupling strength of the fluid-structure interaction; the higher the coupling strength, the better. The smaller the value of , the lower the coupling strength. Increasing the value of maximizes computational efficiency.

[0013] Preferably, the method for addressing the data loss problem due to time mismatch in asynchronous computation involves reconstructing the target data using interpolation / extrapolation algorithms and combining this with residual analysis for dynamic error compensation. Specifically, this includes: When the CPU or GPU initiates a data read request, the data matching algorithm first traverses the corresponding queue to check if there exists a time node equal to... If the data exists, it is read directly and returned to the requesting process without triggering compensation logic; if it does not exist, it is determined that the data is missing and compensation logic is triggered. When data is determined to be missing, the dynamic compensation module uses higher-order prediction-correction logic to reconstruct the data using existing historical data in the queue. The data at any given time, and the specific implementation process are as follows: Filter from the queue Continuous historical data points before and after a given time point; Calculate the fluid excitation force based on the selected historical data points. Over time The gradient of change, then predict Fluid excitation force at time .

[0014] Preferably, the method further includes: The reconstructed data serves only as temporary input to ensure the smooth progress of the request process's computation; subsequent data is transferred once the GPU or CPU has finished processing. Real-time calculations are performed, and after the real data is written to the queue, the dynamic compensation module immediately executes error compensation operations. The specific process is as follows: Dynamic compensation module reading Real data at any moment And calculate the reconstructed data With real data residual ; The calculated residuals Compared with the system's preset security settings Comparison: like No additional compensation is required; like , the error term The additional damping force is compensated for in the next iterative calculation of the rotor differential equation.

[0015] Preferably, the construction of a global multi-condition task pool, monitoring hardware resource utilization and convergence status of each condition, and dynamically adjusting computing power allocation specifically includes: The global multi-condition task pool adopts a distributed storage structure and is stored in the system's shared memory; The tasks in the task pool are classified into three categories based on their computational complexity: simple tasks, medium-complexity tasks, and complex tasks. Real-time collection of resource utilization data for each node and CPU in the GPU cluster. Specific monitoring metrics include: GPU utilization, CPU utilization, memory usage, and data read / write speed. The system monitors the computational convergence of each task under different operating conditions in real time, with the residual descent rate as the monitoring metric. For fluid domain computations, the residual descent rate is monitored based on the residuals from the flow field computations. For solid domain computations, the residual descent rate is monitored based on the residuals from the rotor dynamics computations. Simultaneously, a convergence threshold is set, and each task is categorized based on its residual descent rate.

[0016] Preferably, the method further includes: The heuristic load balancing algorithm module dynamically adjusts computing power allocation based on resource utilization monitoring data and computation convergence monitoring data. The core execution logic is as follows: After the system starts, the heuristic load balancing algorithm module initially distributes the tasks in the task pool to each node and CPU of the GPU cluster according to the complexity and priority of the tasks. Every preset period, the load of each hardware node and the convergence of each task are evaluated, and computing power is adjusted based on the evaluation results.

[0017] In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are: 1. This invention breaks through the bottleneck of traditional synchronous blocking computation from the bottom layer by identifying fluid-structure interaction task features, accurately mapping CPU-GPU heterogeneous systems, and designing a bidirectional asynchronous lock-free circular queue. It solves the problems of mutual waiting between fluid domain and solid domain computations and low hardware resource utilization. It allocates high-parallelism fluid domain computations to the GPU and strong nonlinear solid domain computations to the CPU. With instruction set decoupling and independent memory space isolation, it enables heterogeneous hardware to perform their respective functions and cooperate efficiently.

[0018] 2. This invention addresses two major challenges simultaneously: asynchronous computation data loss, error accumulation, and unbalanced computational power allocation across multiple operating conditions. It employs data interpolation reconstruction and dynamic residual error compensation, combined with a multi-condition task pool and heuristic computing power scheduling. To address the time node mismatch issue, target data is reconstructed using Taylor expansion combined with cubic spline interpolation. Residual feedback forms additional damping force compensation, effectively suppressing error accumulation and ensuring computational accuracy meets engineering simulation requirements. A global task pool manages multi-condition computational tasks uniformly, dynamically allocating computing power based on hardware load and convergence status. Idle computing power is transferred to slow-converging complex conditions, achieving GPU cluster load balancing and optimal resource utilization. This solution significantly shortens the multi-condition parallel simulation cycle while ensuring modeling accuracy, enabling simultaneous completion of calculations for each condition, better meeting the real-world requirements of multi-condition, high-precision, and high-efficiency rotor dynamics modeling. Attached Figure Description

[0019] Further details, features, and advantages of this application are disclosed in the following description of exemplary embodiments in conjunction with the accompanying drawings, in which: Figure 1 This is a flowchart of the method of the present invention. Detailed Implementation

[0020] Several embodiments of this application will now be described in more detail with reference to the accompanying drawings to enable those skilled in the art to implement this application. This application may be embodied in many different forms and for various purposes and should not be limited to the embodiments set forth herein. These embodiments are provided to make this application thorough and complete, and to fully convey the scope of this application to those skilled in the art. The embodiments described do not limit this application.

[0021] Unless otherwise defined, all terms used herein (including technical and scientific terms) shall have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains. It will be further understood that terms such as those defined in commonly used dictionaries shall be interpreted as having a meaning consistent with their meaning in the relevant field and / or the context of this specification, and shall not be interpreted in an idealized or overly formal sense unless expressly defined herein.

[0022] Example 1 Its specific implementation method is combined with the appendix Figure 1 Please provide a detailed explanation.

[0023] Appendix Figure 1 The flowchart of a multi-stage centrifugal pump rotor dynamics modeling method under multiple operating conditions provided in this embodiment of the invention shows the complete steps from analyzing the fluid-structure interaction calculation task of the multi-stage centrifugal pump to constructing a global multi-operating-condition task pool.

[0024] In this embodiment, it includes: The fluid-structure interaction computation task of a multi-stage centrifugal pump is analyzed, the computational characteristics of the fluid domain and the solid domain are identified, and the task is accurately mapped to the CPU and GPU and the instruction set is decoupled, laying the hardware foundation for asynchronous parallel computing. Specifically, it includes: This step forms the underlying foundation of the entire technical solution. Its core purpose is to solve the problem of accurately matching heterogeneous hardware resources with computing tasks. Specifically, it clarifies what computing tasks the CPU and GPU should undertake, how to split the instruction stream, and how to achieve mutual non-interference and efficient collaboration of instruction sets. Essentially, it lays the hardware foundation for subsequent asynchronous parallel computing by accurately adapting hardware characteristics to computing task characteristics, thereby improving computing efficiency from the root.

[0025] The computer system (which can be a server cluster or an industrial-grade workstation, including at least one main control server, one GPU cluster, and one multi-core CPU) initializes a heterogeneous task allocation module. This module is an independent software module that can be integrated into the system operating system kernel or run as a standalone application. After the heterogeneous task allocation module starts, it first reads the input overall calculation task of the multi-stage centrifugal pump (including calculation objectives, calculation accuracy requirements, calculation domain boundary conditions, initial parameters, etc.), and then performs a comprehensive analysis of the overall calculation task. The analysis includes, but is not limited to: the type of calculation task (fluid domain calculation, solid domain calculation), the mathematical model of each calculation domain, the complexity of the calculation task, the amount of data processing, the time sensitivity of the calculation task, the strength of the coupling relationship between the calculation tasks, etc. Finally, it outputs a calculation task analysis report, clarifying the core characteristics of each sub-computation task.

[0026] Computational Task Feature Identification: The heterogeneous task allocation module uses a built-in feature identification algorithm to split the fluid-structure interaction (CFD) computational task of a multi-stage centrifugal pump, identifying the computational features of the fluid domain (CFD) and solid domain (CSD) respectively. The specific identification logic is as follows: Fluid domain computation task identification: Fluid domain computation mainly targets the internal flow channels of multi-stage centrifugal pumps, such as the impeller and pump casing flow channels, employing computational fluid dynamics (CFD) methods. The core computational content includes flow field distribution, fluid pressure, fluid velocity, and fluid excitation force. Through feature recognition algorithms, two core characteristics of fluid domain computation can be identified: first, the computational data exhibits high-dimensional sparse matrix characteristics (the number of nodes in the flow channel mesh typically reaches...). ~ The first characteristic is that the mathematical equation is a high-dimensional sparse matrix equation, and the second characteristic is that it has local computationally intensive characteristics (there are complex flow states such as turbulence and vortices in local areas of the flow channel, which require a large number of local iterative calculations). At the same time, it is identified that the parallelism of the fluid domain calculation task is high, and it can be divided into multiple sub-tasks for simultaneous calculation. It has extremely high requirements for the parallel computing capabilities of the hardware, and relatively low requirements for the main frequency. Solid domain computation task identification: Solid domain computation mainly targets solid components such as rotors and impellers of multi-stage centrifugal pumps, employing computational solid mechanics (CSD) methods. The core computational content includes rotor dynamic characteristics, stress-strain, displacement, and deformation of solid components, specifically using a rotor dynamics beam element model for calculation. Through feature recognition algorithms, two core characteristics of solid domain computation can be identified: first, relatively low degrees of freedom (compared to fluid domain mesh nodes, the number of degrees of freedom of solid domain beam elements is typically on the order of 10³-10⁵, far lower than that of fluid domain); second, the existence of strong nonlinear coupling effects, mainly including bearing oil film force (the force generated by the oil film between the rotor and the bearing, which varies with rotor speed and displacement), gyroscopic effect (the inertial effect generated when the rotor rotates at high speed, affecting the rotor's dynamic characteristics), and material nonlinearity of solid components (such as elastic deformation and plastic deformation). Simultaneously, it is identified that solid domain computation tasks have low parallelism, making it difficult to break down into numerous subtasks for parallel computation. It places extremely high demands on high clock frequency and serial computation stability in hardware, while having relatively low requirements for parallel computing capabilities.

[0027] Heterogeneous hardware mapping: Based on the above feature recognition results, the heterogeneous task allocation module packages the instruction streams of each sub-computing task to achieve accurate mapping with heterogeneous hardware. The specific mapping logic is as follows: Fluid domain instruction flow mapping: The instruction flow of fluid domain computing tasks (including mathematical model instructions for CFD calculations, data processing instructions, iterative calculation instructions, etc.) is packaged in a GPU-supported instruction set format (such as the CUDA instruction set). The packaged instruction flow is then mapped to the GPU cluster (graphics processing unit cluster, consisting of at least two GPU servers, each containing at least four high-performance GPU chips, such as NVIDIA A100). The GPU cluster then undertakes the large-scale parallel computing tasks in the fluid domain. To ensure the stability and efficiency of the mapping, the heterogeneous task allocation module also dynamically allocates the fluid domain instruction flow to different GPU chips based on the load of each GPU chip in the GPU cluster, avoiding excessive load on a single GPU chip and achieving balanced utilization of GPU cluster resources.

[0028] Solid-state domain instruction flow mapping: The instruction flow of solid-state domain computation tasks (including mathematical model instructions for CSD computation, nonlinear coupling computation instructions, displacement solution instructions, etc.) is retained on the CPU (Central Processing Unit, using a multi-core high-performance CPU, such as Intel Xeon Platinum 8470C, with no less than 48 cores and a clock speed of no less than 2.9GHz). The CPU undertakes the high-frequency serial solution task of the solid-state domain. Due to the strong nonlinear coupling effect in the solid-state domain, the computation parameters need to be adjusted in real time during the computation process. Serial solution can ensure the stability and accuracy of the computation and avoid problems such as disordered coupling relationships and deviations in computation results caused by parallel solution. At the same time, the CPU also undertakes auxiliary tasks such as scheduling, data interaction, and exception handling of the entire system to ensure the smooth operation of the entire computation process.

[0029] Instruction set decoupling: To avoid interference between instruction streams in the fluid domain and solid domain, the heterogeneous task allocation module decouples the two instruction sets. Specifically, it allocates independent memory address spaces for the fluid domain instruction stream and the solid domain instruction stream, allowing each to run within its own memory address space without consuming the other's memory resources. Simultaneously, an instruction set isolation mechanism is implemented, prohibiting the fluid domain instruction stream from accessing the solid domain's computing resources and the solid domain instruction stream from accessing the GPU cluster's computing resources. Only the heterogeneous task allocation module is allowed to uniformly schedule and manage the two instruction streams, ensuring the independence and stability of the instruction sets and avoiding computational interruptions and errors caused by instruction stream conflicts.

[0030] Two independent asynchronous bidirectional lock-free circular queues are constructed to realize asynchronous data interaction between the CPU and GPU, breaking the traditional synchronous blocking barrier and eliminating process waiting delay; Specifically, it includes: The core bottleneck of the extremely low computational efficiency of traditional fluid-structure interaction (FSI) is the synchronous blocking problem. That is, the synchronous waiting mechanism of MPI (message passing interface) requires that after the fluid domain completes a time step, it must stop computing and wait for the solid domain to complete the corresponding time step, and vice versa. This synchronous blocking mechanism will cause the CPU and GPU to generate a lot of idle waiting time. Especially when the computing speed of the fluid domain and the solid domain differs greatly, the idle waiting time will increase significantly, which will seriously reduce the computational efficiency of the entire system.

[0031] This step breaks down the traditional synchronous blocking communication barrier by constructing an asynchronous bidirectional lock-free circular queue, enabling asynchronous data interaction between the CPU and GPU, completely eliminating handshake waiting delays between processes, ensuring that the CPU and GPU are always in a high-efficiency operating state, and maximizing computing efficiency.

[0032] In the shared memory of the computer system (using high-speed shared memory with a capacity of no less than 128GB and a read / write speed of no less than 200GB / s to ensure high-speed data interaction), two independent asynchronous data buffer queues are created: the excitation force queue and the displacement boundary queue. The excitation force queue is a dedicated queue for transferring data from the fluid domain to the solid domain, and the displacement boundary queue is a dedicated queue for transferring data from the solid domain to the fluid domain. The two queues are independent of each other and do not interfere with each other. Both adopt a lock-free circular queue structure to ensure that the CPU and GPU processes can read and write queue data independently without waiting for the other process to complete the read / write operation.

[0033] Queue structure design: Both queues adopt a circular queue structure. The length of the circular queue can be dynamically adjusted according to the amount of data in the computing task (the default length is 1024 storage units, and the size of each storage unit can be adjusted according to the data type. For example, when storing fluid excitation force, each storage unit is 64 bytes in size and can store multiple parameters such as radial force and axial force). The circular queue adopts a head pointer combined with a tail pointer management method. The head pointer is used to point to the starting position of readable data in the queue, and the tail pointer is used to point to the starting position of readable data in the queue. The movement of the head pointer and the tail pointer are all atomic operations to avoid data reading errors or writing failures caused by pointer confusion.

[0034] Lock-free data structure implementation: To avoid process blocking caused by traditional locking mechanisms (such as mutexes and semaphores), both queues adopt a lock-free data structure design. The core uses CAS (CompareAndSwap) atomic operations to achieve data read and write synchronization. The specific implementation logic is as follows: Data writing logic: When the GPU process needs to write data to the excitation force queue (fluid excitation force) or the CPU process needs to write data to the displacement boundary queue (rotor displacement), the current tail pointer's state (free / occupied) is first compared using a CAS atomic operation. If it is free, the data is written to that storage unit, and the tail pointer is moved one position forward using a CAS atomic operation (circular movement; when the tail pointer points to the last storage unit in the queue, it moves to the first storage unit). If the current tail pointer's storage unit is occupied, it means the queue is full. In this case, the process will not be blocked, but the data will be temporarily cached in temporary memory. When there is a free storage unit in the queue, the writing will be attempted again to ensure that the data is not lost or duplicated.

[0035] Data reading logic: When the CPU process needs to read data from the excitation force queue (fluid excitation force) or the GPU process needs to read data from the displacement boundary queue (rotor displacement), it first compares the status of the memory cell pointed to by the current head pointer (written / free) through a CAS atomic operation. If it is written, the data in the memory cell is read, and the head pointer is moved one position backward (circular movement) through a CAS atomic operation, and the memory cell is marked as free. If the memory cell pointed to by the current head pointer is free, it means that there is no new data in the queue. At this time, the process will not be blocked, but will return the no data mark and continue to execute its own calculation task. After new data is written to the queue, it will try to read again.

[0036] Specific data interaction process: Data transfer from the fluid domain to the solid domain: After the GPU cluster completes the fluid domain calculation for the current time step, it immediately formats the calculated fluid excitation force data (including the magnitude, direction, and point of application of radial and axial forces) into a data format recognizable by the CPU. Then, it pushes the data into the excitation force queue through lock-free write logic. The entire write process is completed independently without waiting for the CPU process to respond. After the GPU cluster writes the data, it immediately continues to execute the fluid domain calculation for the next time step without generating any idle waiting time.

[0037] Data transfer from the solid domain to the fluid domain: After the CPU completes the solid domain calculation for the current time step, it immediately formats the calculated rotor micro-eccentric displacement data (including parameters such as displacement magnitude, direction, and displacement velocity of each rotor node) (converting it into a data format that the GPU can recognize), and then pushes the data into the displacement boundary queue through lock-free write logic. The entire write process is also completed independently without waiting for the GPU cluster to respond. After the CPU writes the data, it immediately continues to execute the solid domain calculation for the next time step, without generating any idle waiting time.

[0038] Queue anomaly handling: The queue has a built-in anomaly detection module that monitors the queue's running status in real time, including full / empty status, data write / read errors, pointer anomalies, etc. When an anomaly is detected (such as data write failure or pointer corruption), the anomaly detection module immediately sends an anomaly signal to the heterogeneous task allocation module. Upon receiving the signal, the heterogeneous task allocation module suspends the data read / write operations of the corresponding process, resets the queue (restoring the head and tail pointers to their initial positions and clearing invalid data), and resumes the process's data read / write operations after the reset is complete, ensuring that the queue always runs stably and preventing anomalies from interrupting the entire computing process.

[0039] Define macroscopic time windows and relaxation tolerance thresholds, monitor the deviation of CPU and GPU computing time progress in real time, and balance asynchronous parallel efficiency and physical computing consistency through corresponding scheduling strategies. Specifically, it includes: The core of this step is to address the physical computation divergence problem that may result from asynchronous parallel computing between CPU and GPU. Specifically, it addresses whether the independent computation and asynchronous time step progression of CPU and GPU can disrupt the physical consistency of fluid-structure interaction (FSI) computation, leading to distorted results and computational explosion (such as numerical divergence and computational errors exceeding the allowable range). By using a time window relaxation algorithm, the asynchronous parallel characteristics of CPU and GPU can be preserved to the maximum extent while ensuring physical computation consistency, thus balancing computational efficiency and accuracy.

[0040] After the computer system's scheduler module (which works in conjunction with the heterogeneous task allocation module and is an independent software module responsible for the entire system's process scheduling, time progress monitoring, and dynamic allocation of computing power) starts up, it first defines a macroscopic time window. and a relaxation tolerance threshold Among them, macroeconomic time window The relaxation tolerance threshold is defined as the overall time range for fluid-structure interaction calculations (e.g., a complete operating cycle of a multi-stage centrifugal pump, ranging from 1 to 10 seconds, which can be adjusted according to the calculation objectives). This represents the maximum allowable deviation between CPU and GPU timelines (adjustable based on computational accuracy requirements); subsequently, the scheduler module monitors the fluid domain computation timeline in real time. Computation timeline of solid domain The deviation is assessed, and different scheduling strategies are implemented based on the magnitude of the deviation to ensure that the time schedule deviation is always kept within the allowable range and to avoid physical computation explosion.

[0041] Specific content: Definition and monitoring of time progress: Time schedule definition: Fluid domain calculation time schedule The physical time corresponding to the fluid domain computation currently completed by the GPU cluster, i.e., the time since the GPU cluster completed computation from the initial time ( )arrive Fluid domain calculation at time; solid domain calculation time schedule The physical time corresponding to the solid domain currently completed by the CPU, that is, the time the CPU has completed since the initial time ( )arrive Solid-domain computation at time t; and The initial values ​​are all 0, and they gradually increase as the calculation progresses.

[0042] Time progress monitoring: The scheduler module uses a built-in time monitoring unit to collect real-time computation time progress data of the GPU cluster and CPU, with a collection frequency of 100~1000Hz (adjustable according to computation speed); the collected data... and Then, immediately calculate the absolute value of the deviation between the two. The obtained value is then compared with the relaxation tolerance threshold. Compare the results and execute the corresponding scheduling strategy based on the comparison. The specific execution of the scheduling strategy: Normal asynchronous operation strategy: when the calculated time deviation When the time difference between the CPU and GPU is within the allowable range and will not affect the physical consistency of the fluid-structure interaction computation, the scheduler module does not intervene. The CPU and GPU continue to run independently according to their respective computation rhythms, maximizing the advantages of asynchronous parallel computing and improving computational efficiency. At this time, the CPU and GPU can flexibly adjust their respective time steps according to their own computational speed (for example, if the GPU has a faster computational speed, it can use a smaller time step to improve computational accuracy, while the CPU has a relatively slower computational speed, it can use a suitable time step to ensure computational stability), without needing to synchronize with each other.

[0043] Deviation correction strategy: When the computing speed of the GPU cluster is faster than that of the CPU, resulting in... When the time discrepancy occurs, it indicates that the computation progress in the fluid domain far exceeds that in the solid domain. If the GPU cluster continues to run at high speed, the time discrepancy will further increase, thereby compromising the physical consistency of fluid-structure interaction computation and even causing a computational explosion. At this point, the scheduler module immediately triggers a deviation correction strategy, which is implemented in one of the following two ways (automatically selected based on system load): Method 1: Trigger a lightweight spinlock to briefly suspend the thread performing the corresponding fluid domain computation in the GPU cluster (suspend duration is...). That is, suspended until the time deviation is reduced to Within (within); During the suspension period, the GPU cluster does not stop all work, only suspending threads that have exceeded the progress limit, while other threads can continue to execute unfinished computing tasks to avoid wasting GPU resources; When the suspension period ends, the suspended threads are immediately woken up to restore the normal computing rhythm of the GPU cluster; Method 2: Dynamically schedule the computing power corresponding to threads that are out of schedule in the GPU cluster to another task that has not yet converged. The scheduler module first queries the global multi-task pool to identify the task in a slow convergence state (such as a low-volume surge task), and then allocates the idle computing power in the GPU cluster (i.e., the computing power corresponding to the threads that are out of schedule) to the slow-converging task to accelerate the computation of the task. This method can not only correct the time schedule deviation, but also make full use of the idle computing power of the GPU to improve the overall efficiency of the entire multi-task computing task.

[0044] Special case handling: If the CPU's calculation speed is faster than the GPU's, resulting in... The processing logic is similar to the above. The scheduler module can briefly suspend the corresponding solid-state domain computation thread in the CPU, or allocate the CPU's idle computing power to other auxiliary computing tasks (such as data preprocessing, result analysis, etc.) to ensure that the time schedule deviation is always controlled within the specified range. Within.

[0045] Macroeconomic time window With relaxation tolerance threshold The basis for the setting: Macroeconomic time window The calculation target is mainly set based on the calculation objective of the multi-stage centrifugal pump. If the calculation objective is the steady-state operating characteristics of the centrifugal pump (such as the flow field distribution and rotor stress under rated operating conditions), then... The value can be 1 to 5 seconds (covering multiple operating cycles of the centrifugal pump to ensure the stability of the calculation results); if the calculation target is the transient operating characteristics of the centrifugal pump (such as the start-up process and the shutdown process), then The value is set to 5-10 seconds (covering the entire transient process); simultaneously, It is also necessary to consider the required computational accuracy; the higher the required accuracy, The smaller the value, the better to ensure the accuracy of the calculation results.

[0046] Relaxation tolerance threshold The setting is mainly based on the coupling strength of fluid-structure interaction. The higher the coupling strength, the more significant the effects of bearing oil film force and gyroscopic effect. The smaller the value, the better to ensure that time schedule deviations do not affect the physical consistency of coupled calculations; the lower the coupling strength, the better. The value of can be appropriately increased to maximize computational efficiency; at the same time... It is also necessary to consider the difference in computing speed between the CPU and GPU; the greater the difference in computing speed, The value of can be appropriately increased to avoid frequently triggering the deviation correction strategy and affecting computational efficiency.

[0047] To address the data loss issue caused by mismatched time nodes in asynchronous computing, the target data is reconstructed through interpolation / extrapolation algorithms, and dynamic error compensation is performed in conjunction with residual analysis to ensure computational accuracy. Specifically, it includes: Because of the asynchronous parallel computing mechanism, the CPU and GPU independently advance their computation progress, resulting in a discrepancy in their timelines (although controlled within an acceptable range using a time window relaxation algorithm, a slight deviation still exists). Therefore, when the CPU (solid-state domain computing) needs a specific time node (such as...), When processing fluid excitation force data (in seconds), the excitation force queue of the GPU cluster may only contain data analysis before and after that time point (e.g., ...). Seconds and The fluid excitation force data (seconds) cannot be directly obtained at the required time point; if the data at the most recent time point is read directly, it will cause a large error in the solid domain calculation results, affecting the accuracy of the entire fluid-structure interaction calculation.

[0048] This step addresses the data loss problem caused by time node mismatch in asynchronous parallel computing by constructing a time node alignment and dynamic physical quantity compensation mechanism. It reconstructs the data at the required time using interpolation / extrapolation algorithms and compensates for calculation errors through prediction-correction logic, ensuring that the accuracy of fluid-structure interaction calculation meets the requirements under the premise of asynchronous parallel computing.

[0049] When the CPU needs to read fluid excitation force data at a specific time point from the excitation force queue, or the GPU needs to read rotor displacement data at a specific time point from the displacement boundary queue, if the data for that specific time point is not present in the queue, the system's built-in dynamic compensation module is immediately triggered. The dynamic compensation module reconstructs the data for the required time point in shared memory using interpolation / extrapolation algorithms based on the historical data before and after that specific time point already in the queue, providing accurate computational input for the CPU or GPU. At the same time, the dynamic compensation module also monitors the error of the reconstructed data. When the actual computational data for that specific time point is subsequently obtained, the residual between the reconstructed data and the actual data is calculated. If the residual exceeds a safety set value, the error term is fed back to the next iteration calculation through the dynamic compensation mechanism to achieve error correction and ensure computational accuracy.

[0050] Specific content: Data missing detection logic: The dynamic compensation module has a built-in data matching algorithm. When the CPU or GPU initiates a data read request (explicitly specifying the time point of the required data), the algorithm will detect missing data. When performing this operation, the data matching algorithm first traverses the corresponding queue (excitation force queue or displacement boundary queue) and checks if there exists a time node equal to... If the data exists, it is read directly and returned to the requesting process without triggering compensation logic; if it does not exist, it is considered that the data is missing, and compensation logic is triggered. The specific judgment criterion is: the time nodes of all data in the queue are equal to the time nodes of the requesting process. The deviations are all greater than the preset deviation threshold ( Seconds (which can be adjusted according to calculation precision), meaning there is no difference between... Data that is close to and can be directly reused.

[0051] Reconstruction of data at the required time: When data is determined to be missing, the dynamic compensation module uses higher-order prediction-correction logic to reconstruct the data using existing historical data in the queue. The core of the time-domain prediction algorithm for the data is the Taylor expansion algorithm in the time domain. The specific implementation process is as follows: Historical data filtering: The dynamic compensation module filters data from the queue. At least three consecutive historical data points before and after the time (e.g.) , , ,in ); The selection criteria are: the time point of the historical data and The deviation should be minimized, and the calculation accuracy of historical data points should meet the requirements (i.e., the residual of historical data is less than the safety setting value). If there are fewer than 3 historical data points in the queue, the reconstruction operation should be performed after new historical data is written into the queue to ensure the accuracy of the reconstructed data.

[0052] Taylor expansion prediction: Taking the reconstruction of fluid excitation force data as an example, the dynamic compensation module calculates the fluid excitation force based on the selected historical data points. Over time Gradient of change (first derivative) Second derivative Then, using the Taylor expansion formula, the prediction is made. Fluid excitation force at time The specific formula is as follows: ; in, for Compared with historical data points Time difference ( ), for Real-time data of fluid excitation force (read from the queue). for The first time derivative of the fluid excitation force at time (via and Moment (Data calculations) for The second time derivative of the fluid excitation force at time (via , , Moment (Calculated from data).

[0053] Data Reconstruction Optimization: To further improve the accuracy of the reconstructed data, the dynamic compensation module also uses interpolation algorithms (such as cubic spline interpolation) to optimize the Taylor expansion prediction results, combining the weight allocation of multiple historical data points. The data is corrected, and the corrected data is returned to the requesting process (CPU or GPU) as the final reconstructed data for subsequent calculations.

[0054] Dynamic error compensation: The reconstructed data serves only as temporary input to ensure the smooth progress of the computation process. Subsequent data is used once the GPU or CPU has completed its computation. Real-time calculations are performed, and after the real data is written to the queue, the dynamic compensation module immediately executes error compensation operations. The specific process is as follows: Residual calculation: Read by dynamic compensation module Real data at any moment And calculate the reconstructed data With real data residual The calculation formula is: ; Residual judgment and compensation: The calculated residuals... Compared with the system's preset security settings (The range of values ​​is) ~ (This can be adjusted according to the required calculation accuracy) for comparison: like This indicates that the error in the reconstructed data is within the allowable range and no additional compensation is needed. The dynamic compensation module records this residual data for subsequent optimization of the parameters of the Taylor expansion algorithm (such as gradient calculation accuracy). like This indicates that the error in the reconstructed data exceeds the allowable range. In this case, the dynamic compensation module will adjust the error term. The compensation is incorporated into the next iterative calculation of the rotor differential equation in the form of an additional damping force; specifically, the compensation method is to incorporate the error term... Converted into additional damping force , ( (This is the damping coefficient, which can be set according to the rotor dynamics characteristics), and then... The error is added to the rotor differential equation and participates in the solid domain calculation of the next time step. Through iterative calculation, the error is gradually offset to ensure the energy dissipation balance of the entire fluid-structure interaction calculation and avoid the accumulation of errors that lead to the distortion of the calculation results.

[0055] The dynamic compensation module can automatically adapt the interpolation / extrapolation algorithm according to the type of calculation task (fluid domain data reconstruction, solid domain data reconstruction). For data with relatively gradual changes, such as fluid excitation force, the Taylor expansion prediction algorithm is preferred to ensure the continuity of the reconstructed data. For data with the possibility of abrupt changes, such as rotor displacement, the cubic spline interpolation algorithm is preferred to ensure the smoothness of the reconstructed data. Meanwhile, the dynamic compensation module records the error data of each reconstruction in real time, and optimizes the gradient calculation accuracy of the Taylor expansion algorithm and the weight allocation of the interpolation algorithm through machine learning algorithms, thereby gradually improving the accuracy of the reconstructed data and reducing the frequency of error compensation.

[0056] Construct a global multi-condition task pool, monitor hardware resource utilization and convergence of each condition, and dynamically adjust computing power allocation through heuristic algorithms to achieve optimal utilization of GPU cluster resources. Specifically, it includes: In fluid-structure interaction (FSI) calculations for multistage centrifugal pumps, practical applications typically require simultaneous calculation of the FSI characteristics of multiple operating conditions, such as start-up, rated operating condition (BEP), low-flow surge, and high-flow conditions, usually ranging from 10 to 50. The computational complexity of different operating conditions varies significantly, leading to substantial differences in convergence speed (e.g., the BEP condition has a stable flow field and converges quickly, while the low-flow surge condition has a complex flow field and converges slowly). If a traditional fixed allocation method is used, evenly distributing each operating condition to different nodes in the GPU cluster, some GPU nodes will be overloaded and slowed down due to being assigned to complex operating conditions (such as surge), while other GPU nodes will complete the calculation quickly due to being assigned to simple operating conditions (such as BEP), resulting in idle GPU resources and overall low computational efficiency.

[0057] This step involves constructing a global multi-condition task pool, employing a heuristic load balancing algorithm, monitoring the resource utilization of each hardware node and the computational convergence of each condition in real time, dynamically adjusting the computing power allocation, achieving optimal utilization of GPU cluster resources, improving the overall efficiency of simultaneous multi-condition computing, ensuring that computing tasks in all conditions can be completed synchronously, and meeting the needs of practical engineering applications.

[0058] The computer system initializes a global multi-condition task pool. The task pool is used to store all multi-stage centrifugal pump condition tasks that need to be calculated. Each condition task contains information such as condition parameters, calculation objectives, calculation accuracy requirements, and initial calculation parameters.

[0059] Simultaneously, the system activates a load monitoring module to monitor the resource utilization of each node and CPU in the GPU cluster in real time (including GPU utilization, CPU utilization, memory usage, data read / write speed, etc.). The heuristic load balancing algorithm module (integrated into the scheduler module) dynamically adjusts the computing power allocation based on the monitoring data from the load monitoring module and the computational convergence status of each task: it dynamically transfers the computing power occupied by tasks that have completed computation or have fast convergence speed to tasks with slow convergence speed and excessive load, realizing adaptive transfer of computing power, ensuring load balance among hardware nodes, and improving overall computing efficiency.

[0060] The details are as follows: Construction and management of a global multi-condition task pool: Task pool construction: The global multi-condition task pool adopts a distributed storage structure and is stored in the system's shared memory, which can support multiple processes to access it at the same time; the initial state of the task pool is pending allocation. Users can add condition tasks to the task pool through the system interface, and can also delete or modify condition tasks in the task pool; each condition task is assigned a unique task identifier, which is used for subsequent computing power allocation, progress monitoring and result statistics. Task Classification and Priority Setting: The heuristic load balancing algorithm module classifies the tasks in the task pool into three categories based on computational complexity: simple tasks (such as rated conditions and high-flow conditions, with stable flow fields and fast computational convergence), medium-complexity tasks (such as normal flow fluctuation conditions, with relatively stable flow fields and moderate computational convergence speed), and complex tasks (such as low-flow surge conditions and startup conditions, with complex flow fields and slow computational convergence). Simultaneously, priorities are set for different tasks based on engineering application requirements (such as high priority for rated and surge conditions, and medium priority for startup conditions). Tasks with higher priority receive computing power allocation first, ensuring the computational progress of core tasks.

[0061] Monitoring of resource utilization and computational convergence: Resource utilization monitoring: The load monitoring module collects real-time resource utilization data for each node and CPU in the GPU cluster at a frequency of 10~100Hz. Specific monitoring indicators include: GPU utilization (the utilization rate of a single GPU chip's computing cores, with a normal operating range of 70%~90%), CPU utilization (the overall utilization rate of multi-core CPUs, with a normal operating range of 60%~80%), memory usage (the utilization rate of shared memory and local memory of each hardware node, not exceeding 90%), and data read / write speed (the data interaction speed between shared memory and CPU / GPU, ensuring a minimum of 100GB / s). The load monitoring module feeds back the collected monitoring data to the heuristic load balancing algorithm module in real time, serving as the core basis for adjusting computing power.

[0062] Computational Convergence Monitoring: The heuristic load balancing algorithm module monitors the computational convergence of each task in real time. The core monitoring metric is the residual reduction rate (i.e., the percentage decrease in the residual of the computational result in each computational iteration step). For fluid domain computations, the residual reduction rate is monitored for the residuals of the flow field calculations (such as velocity residuals and pressure residuals). For solid domain computations, the residual reduction rate is monitored for the residuals of the rotor dynamics calculations (such as displacement residuals and stress residuals). Simultaneously, a convergence judgment threshold is set (e.g., the residual reduction rate is less than a certain value for 10 consecutive iteration steps). And the absolute value of the residual is less than If the residual decrease rate is within a certain threshold, then the task for that condition is considered converged. Based on the residual decrease rate, each task is categorized into three types: converged (residuals meet the convergence threshold), fast converged (residual decrease rate stabilizes at a certain threshold), and fast converged (residual decrease rate stabilizes at a certain threshold). ~ Between these two points, convergence is expected in a short period of time, or slow convergence (residual decay rate greater than [value missing]). Or the residuals fluctuate and do not decrease, and are expected to be difficult to converge over a long period of time, such as in low-flow surge conditions.

[0063] The specific execution logic of heuristic load balancing: The heuristic load balancing algorithm module dynamically adjusts computing power allocation based on resource utilization monitoring data and computation convergence monitoring data. The core execution logic is as follows: Computing power allocation initialization: After the system starts, the heuristic load balancing algorithm module initially allocates the tasks in the task pool to each node and CPU of the GPU cluster according to the complexity and priority of the tasks. Among them, complex tasks are preferentially allocated to nodes with low GPU utilization and strong computing performance, simple tasks are allocated to nodes with relatively high GPU utilization or weak computing performance, and solid domain computing tasks are allocated to CPUs to ensure the rationality of the initial allocation and avoid initial load imbalance.

[0064] Dynamic computing power adjustment: The heuristic load balancing algorithm module performs a comprehensive assessment of the load on each hardware node and the convergence of each task at preset intervals (e.g., 10 seconds, adjustable according to computing speed), and adjusts the computing power based on the assessment results. When a task on a GPU node has converged (e.g., under rated conditions), and the GPU utilization of that GPU node drops below 30% (i.e., a large amount of idle computing power appears), the heuristic load balancing algorithm module immediately strips the computing power of the converged task on that GPU node (releasing the GPU resources occupied by the task) and redistributes the released computing power to slow-converging tasks (e.g., low-volume surge conditions) on other GPU nodes. Specifically, the computation domain of the slow-converging task is split into multiple subdomains, and the released GPU computing power is allocated to these subdomains to achieve parallel computing and accelerate the convergence speed of the slow-converging task.

[0065] When a task on a GPU node is in a slow convergence state, and the GPU utilization of that GPU node consistently exceeds 90% and the memory usage exceeds 85% (i.e., the load is too high), while other GPU nodes have idle computing power, the heuristic load balancing algorithm module immediately allocates some computing power from the idle GPU nodes to the overloaded GPU node to help it handle the sub-computation tasks of the slow convergence task, alleviate the load pressure on that node, and improve the computing speed.

[0066] When the CPU utilization rate is consistently below 60% (i.e. there is idle computing power), the heuristic load balancing algorithm module allocates the idle computing power of the CPU to auxiliary computing tasks, such as result analysis of working condition tasks, data preprocessing, residual calculation, etc., to make full use of CPU resources and avoid resource waste.

[0067] When multiple GPU nodes experience excessive load or are idle simultaneously, the heuristic load balancing algorithm module adopts a load balancing priority strategy to prioritize ensuring the computing power requirements of high-priority tasks, and then adjusts the computing power allocation for low-priority tasks to ensure that the computing progress of core tasks is not affected.

[0068] Stability assurance during computing power transfer: To avoid problems such as computational interruption and data loss during dynamic computing power transfer, the heuristic load balancing algorithm module adopts a seamless connection mechanism when performing computing power transfer: Before transferring computing power, the corresponding task's computation status (such as the current iteration step, computation parameters, residual data, etc.) is first saved to shared memory; after the computing power transfer is completed, the newly allocated hardware node reads the saved computation status and continues to execute the computation task, ensuring the continuity of the computation process; at the same time, during the computing power transfer process, it is prohibited to delete or modify the tasks in the task pool, ensuring that the tasks can proceed normally after the computing power transfer is completed.

[0069] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters in the formulas are set by those skilled in the art according to the actual situation.

[0070] The foregoing has only described certain exemplary embodiments of the present invention by way of illustration. Undoubtedly, those skilled in the art can modify the described embodiments in various ways without departing from the spirit and scope of the present invention. Therefore, the foregoing drawings and descriptions are illustrative in nature and should not be construed as limiting the scope of protection of the claims of the present invention.

[0071] It should be noted that, in this document, the use of relational terms such as "first" and "second" is merely for distinguishing one entity or operation from another, and does not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes the element.

[0072] It should be understood that in the various embodiments of this application, the order of the above-mentioned processes does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0073] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0074] Those skilled in the art will understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0075] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0076] In addition, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0077] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0078] The foregoing has only described certain exemplary embodiments of the present invention by way of illustration. Undoubtedly, those skilled in the art can modify the described embodiments in various ways without departing from the spirit and scope of the present invention. Therefore, the foregoing drawings and descriptions are illustrative in nature and should not be construed as limiting the scope of protection of the claims of the present invention.

Claims

1. A method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions, characterized in that, include: The fluid-structure interaction computation task of a multi-stage centrifugal pump is analyzed, the computational characteristics of the fluid domain and the solid domain are identified, and the task is mapped to the CPU and GPU and the instruction set is decoupled. Construct two independent asynchronous bidirectional lock-free circular queues to achieve asynchronous data interaction between the CPU and GPU; Define macroscopic time windows and relaxation tolerance thresholds, monitor the deviation of CPU and GPU computing time progress in real time, and balance asynchronous parallel efficiency and physical computing consistency through corresponding scheduling strategies. To address the data loss issue caused by time mismatch in asynchronous computing, the target data is reconstructed through interpolation / extrapolation algorithms, and dynamic error compensation is performed in conjunction with residual analysis. Construct a global multi-condition task pool, monitor hardware resource utilization and convergence of each condition, and dynamically adjust computing power allocation.

2. The method according to claim 1, wherein, This paper analyzes the fluid-structure interaction computation task of a multi-stage centrifugal pump, identifies the computational characteristics of the fluid and solid domains, and realizes the mapping of the task with the CPU and GPU and the decoupling of the instruction set. Specifically, this includes: The fluid-structure interaction calculation task for a multi-stage centrifugal pump is broken down using a feature recognition algorithm, and the calculation features of the fluid domain and the solid domain are identified separately. The specific identification logic is as follows: Fluid domain computation task identification: For the impeller internal flow channel and pump casing flow channel of a multi-stage centrifugal pump, the computation content includes flow field distribution, fluid pressure, fluid velocity, and fluid excitation force; through feature recognition algorithms, the core features of fluid domain computation are determined; Solid domain computation task identification: For multi-stage centrifugal pumps, the computation content of rotor and impeller is rotor dynamic characteristics, stress and strain of solid components, displacement and deformation; through feature recognition algorithm, the core features of solid domain computation are determined.

3. The method according to claim 2, wherein, Also includes: Based on the feature recognition results, the instruction streams of each sub-computation task are packaged and processed. The specific mapping logic is as follows: Fluid domain instruction flow mapping: Package the instruction flow of fluid domain computing tasks, and then map the packaged instruction flow to the GPU cluster, so that the GPU cluster can undertake the large-scale parallel computing tasks in the fluid domain. Solid-state domain instruction stream mapping: The instruction stream of solid-state domain computation tasks is kept on the CPU, and the CPU undertakes the high-frequency serial solution tasks of solid-state domain. Instruction set decoupling: Independent memory address spaces are allocated for fluid domain instruction streams and solid domain instruction streams. At the same time, an instruction set isolation mechanism is set up to prohibit fluid domain instruction streams from calling solid domain computing resources and solid domain instruction streams from calling GPU cluster computing resources. Only the heterogeneous task allocation module is allowed to schedule and manage the two types of instruction streams in a unified manner.

4. The method of claim 1, wherein, Construct two independent asynchronous bidirectional lock-free circular queues to achieve asynchronous data interaction between the CPU and GPU, specifically including: In the shared memory of the computer system, two independent asynchronous data buffer queues are created: the excitation force queue and the displacement boundary queue. The excitation force queue is a dedicated queue for transferring data from the fluid domain to the solid domain, and the displacement boundary queue is a dedicated queue for transferring data from the solid domain to the fluid domain. To avoid process blocking caused by traditional locking mechanisms, both queues adopt a lock-free data structure design and use CAS atomic operations to achieve data read and write synchronization. Specific data interaction process: Data transfer from the fluid domain to the solid domain: After the GPU cluster completes the fluid domain calculation for the current time step, it formats the calculated fluid excitation force data and then pushes the data into the excitation force queue through lock-free write logic. Data transfer from the solid domain to the fluid domain: After the CPU completes the solid domain calculation for the current time step, it formats the calculated rotor micro-eccentric displacement data and then pushes the data into the displacement boundary queue through lock-free write logic.

5. The method of claim 1, wherein, Define macroscopic time windows and relaxation tolerance thresholds, monitor the deviation in CPU and GPU computation time progress in real time, and use corresponding scheduling strategies to balance asynchronous parallel efficiency and physical computation consistency, specifically including: Fluid domain computation time progress Corresponding physical time for the fluid domain computation currently completed by the GPU cluster; solid domain computation time progress Corresponding physical time for the solid domain computation currently completed by the CPU; Collected With After that, the absolute value of the deviation of the two is calculated And the obtained value is compared with the relaxation tolerance threshold According to the comparison result, the corresponding scheduling strategy is executed; When the computing speed of a GPU cluster is faster than that of a CPU, it leads to At this time, the scheduler module immediately triggers the deviation correction strategy.

6. The method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions according to claim 5, characterized in that, Also includes: Macroeconomic Time Window Based on the calculation objective of the multistage centrifugal pump, if the calculation objective is the steady-state operating characteristics of the centrifugal pump, then... The value can be 1 to 5 seconds; if the calculation target is the transient operating characteristics of a centrifugal pump, then The value is 5~10 seconds; Relaxation tolerance threshold The setting is based on the coupling strength of the fluid-structure interaction; the higher the coupling strength, the better. The smaller the value of , the lower the coupling strength. Increasing the value of maximizes computational efficiency.

7. The method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions according to claim 1, characterized in that, To address the data loss issue caused by time mismatch in asynchronous computing, target data is reconstructed using interpolation / extrapolation algorithms, and dynamic error compensation is performed in conjunction with residual analysis. Specifically, this includes: When the CPU or GPU initiates a data read request, the data matching algorithm first traverses the corresponding queue to check if there exists a time node equal to... If the data exists, it is read directly and returned to the requesting process without triggering compensation logic; if it does not exist, it is determined that the data is missing and compensation logic is triggered. Once data is determined to be missing, the dynamic compensation module employs higher-order prediction-correction logic to reconstruct the data using existing historical data in the queue. The data at any given time, and the specific implementation process are as follows: Filter from the queue Continuous historical data points before and after a given moment; Calculate the fluid excitation force based on the selected historical data points. Over time The gradient of change, then predict Fluid excitation force at time .

8. The method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions according to claim 7, characterized in that, Also includes: The reconstructed data serves only as temporary input to ensure the smooth progress of the request process's computation; subsequent data is transferred once the GPU or CPU has finished processing. Real-time calculations are performed, and after the real data is written to the queue, the dynamic compensation module immediately executes error compensation operations. The specific process is as follows: Dynamic compensation module reading Real data at any moment And calculate the reconstructed data With real data residual ; The calculated residuals Compared with the system's preset security settings Comparison: like No additional compensation is required; like , the error term The additional damping force is compensated for in the next iterative calculation of the rotor differential equation.

9. The method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions according to claim 1, characterized in that, Construct a global multi-condition task pool, monitor hardware resource utilization and convergence status of each condition, and dynamically adjust computing power allocation, specifically including: The global multi-condition task pool adopts a distributed storage structure and is stored in the system's shared memory; The tasks in the task pool are classified into three categories based on their computational complexity: simple tasks, medium-complexity tasks, and complex tasks. Real-time collection of resource utilization data for each node and CPU in the GPU cluster. Specific monitoring metrics include: GPU utilization, CPU utilization, memory usage, and data read / write speed. The system monitors the computational convergence of each task under different operating conditions in real time, with the residual descent rate as the monitoring metric. For fluid domain computations, the residual descent rate is monitored based on the residuals from the flow field computations. For solid domain computations, the residual descent rate is monitored based on the residuals from the rotor dynamics computations. Simultaneously, a convergence threshold is set, and each task is categorized based on its residual descent rate.

10. The method for modeling the rotor dynamics of a multi-stage centrifugal pump under multiple operating conditions according to claim 9, characterized in that, Also includes: The heuristic load balancing algorithm module dynamically adjusts computing power allocation based on resource utilization monitoring data and computation convergence monitoring data. The core execution logic is as follows: After the system starts, the heuristic load balancing algorithm module initially distributes the tasks in the task pool to each node and CPU of the GPU cluster according to the complexity and priority of the tasks. Every preset period, the load of each hardware node and the convergence of each task are evaluated, and computing power is adjusted based on the evaluation results.

Images