A polymer construction method, apparatus, and storage medium

Abstract

The application relates to the field of computer-aided engineering, and provides an aggregation body construction method, an aggregation body construction device and a storage medium. The method comprises the following steps: acquiring the total number of nodes of a structural mechanics simulation model, and calculating and determining the number of first-layer aggregation bodies according to a preset target node number contained in each aggregation body; based on the number of the first-layer aggregation bodies, a first version of the first-layer aggregation bodies which are balanced in node number and reflect the connection topology of original grids is constructed by performing recursive division on a node connection graph of the original grids from global coarse division to local fine division; the first version of the first-layer aggregation bodies is traversed, nodes belonging to rigid units are screened out from the first version of the first-layer aggregation bodies, each screened rigid node is separately constructed into an aggregation body, the first-layer aggregation bodies are updated, and a corrected first-layer aggregation body is obtained; and based on the connection relationship between the corrected first-layer aggregation bodies, other aggregation bodies in each layer except the first layer are recursively constructed by merging adjacent aggregation bodies in the same layer.

Description

Technical Field

[0001] This application relates to the field of computer-aided engineering, and in particular to a method, apparatus and storage medium for constructing aggregates. Background Technology

[0002] Linear solving in structural mechanics is one of the core technologies in engineering simulation, widely used in static analysis and dynamic response calculation of structures such as buildings, bridges, and aerospace. In actual engineering, structural mechanics models typically contain millions or even tens of millions of degrees of freedom, resulting in a massive set of finite element linear equations. Direct solutions face challenges such as high storage overhead and long computation time. To address this, the industry commonly employs multi-level solvers (e.g., multi-level aggregation iteration or multi-mesh methods) to accelerate the solution process. One of the core steps of these methods is to divide the nodes of the original mesh into several aggregates (i.e., coarse mesh nodes), thereby constructing a multi-level preprocessing matrix.

[0003] In existing technologies, the construction of aggregates typically relies on graph partitioning algorithms, such as recursive bisection or multi-level partitioning methods, to cut the node connection graph in order to obtain a partitioning result with a roughly balanced number of nodes in each aggregate and the minimum number of connecting edges between aggregates. However, such methods have the following shortcomings: 1) Most graph partitioning algorithms only focus on the balance of the number of nodes, ignoring the connection topology of the original mesh, resulting in poor internal connectivity of the partitioned aggregates and destroying the local continuity of the original mesh; 2) Rigid elements often exist in structural mechanics models, whose node stiffness values ​​are much higher than those of ordinary nodes. If rigid nodes are mixed with ordinary nodes in the same aggregate, it will cause serious numerical stiffness problems in the subsequent solution process, reducing the convergence efficiency of the preprocessor; 3) Existing methods lack effective recursive merging strategies when constructing multi-level aggregates, often failing to balance the balance and topological fidelity of each layer of aggregates, thus limiting the overall performance of multi-level solvers. Summary of the Invention

[0004] This application provides a method, apparatus, and storage medium for constructing aggregates, which improves the balance and numerical stability of aggregate construction by preserving topological balance partitioning and separating rigid nodes.

[0005] On the one hand, this application provides a method for constructing an aggregate, the method comprising: Step S1: Obtain the total number of nodes in the structural mechanics simulation model, and calculate and determine the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate; Step S2: Based on the number of the first-layer aggregates, a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh is constructed by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning. The recursive partitioning includes: progressively coarsening the node connection graph to generate a small-scale graph with a preset number of nodes; performing balanced partitioning on the small-scale graph with a preset number of nodes to obtain an initial partitioning result; mapping the initial partitioning result back to a finer-level graph step by step; and using a local or global optimization algorithm to correct the partitioning result after each level of mapping until the partitioning of the original mesh is obtained. Step S3: Traverse the first version of the first-layer aggregate, select nodes that belong to rigid units, and construct each selected rigid node into an aggregate separately, thereby updating the first-layer aggregate and obtaining the corrected first-layer aggregate; Step S4: Based on the connection relationship between the modified first-layer aggregates, adjacent first-layer aggregates are merged to recursively construct aggregates for all layers except the first layer, thus completing the construction of aggregates at all levels.

[0006] On the other hand, this application provides an apparatus for constructing polymers, the apparatus comprising: The acquisition module is used to acquire the total number of nodes in the structural mechanics simulation model, and calculate and determine the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate; The first construction module is used to construct a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning based on the number of the first-layer aggregate. The recursive partitioning includes: progressively coarsening the node connection graph to generate a small-scale graph with a preset number of nodes; performing balanced partitioning on the small-scale graph with a preset number of nodes to obtain an initial partitioning result; mapping the initial partitioning result back to a finer-level graph step by step; and using a local or global optimization algorithm to correct the partitioning result after each level of mapping until the partitioning of the original mesh is obtained. The update module is used to traverse the first version of the first-layer aggregate, filter out the nodes that belong to rigid units, and build each filtered rigid node into an aggregate separately, thereby updating the first-layer aggregate and obtaining the corrected first-layer aggregate. The second construction module is used to recursively construct aggregates of all layers except the first layer by merging adjacent aggregates of the same layer based on the connection relationship between the modified first-layer aggregates, thus completing the construction of aggregates of all layers.

[0007] Thirdly, this application provides an electronic device, which includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the technical solution of the above-described aggregate construction method.

[0008] Fourthly, this application provides a storage medium storing a computer program, which, when executed by a processor, implements the steps of the above-described aggregate construction method.

[0009] As can be seen from the technical solution provided in this application, on the one hand, by obtaining the total number of nodes in the structural mechanics simulation model and combining it with the preset target number of nodes, the number of first-layer aggregates is calculated and determined, thus providing a clear scale constraint for subsequent partitioning. On this basis, by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning, not only is the balance of the number of nodes in the first-layer aggregates achieved, but more importantly, the connection topology of the original mesh is preserved, so that the nodes inside each aggregate remain physically closely related, avoiding topological breaks caused by partitioning; on the other hand, by traversing the first layer... First, a first-layer aggregate is constructed, and nodes belonging to rigid elements are selected from it. Each rigid node is then constructed as a separate aggregate, thereby eliminating the negative impact of rigid nodes on the numerical properties of ordinary aggregates and ensuring the numerical stability of each aggregate in subsequent linear solutions. Second, based on the modified connection relationships between the first-layer aggregates, adjacent aggregates of the same layer are merged to recursively construct aggregates for all layers other than the first layer. This process fully utilizes the adjacency information of the lower-level aggregates, allowing higher-level aggregates to naturally inherit the topological relationships of the lower layers, forming a hierarchical and structurally sound multi-level aggregate system. In summary, the technical solution of this application improves the balance and numerical stability of aggregate construction by preserving topological balance partitioning and separating rigid nodes. Attached Figure Description

[0010] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0011] Figure 1 This is a flowchart of the aggregate construction method provided in the embodiments of this application; Figure 2 This is a schematic diagram of the topological equilibrium-preserving construction of the first-layer aggregate provided in an embodiment of this application; Figure 3This is a schematic diagram of rigid node correction provided in an embodiment of this application; Figure 4 This is a schematic diagram of the polymer construction apparatus provided in the embodiments of this application; Figure 5 This is a schematic diagram of the device provided in the embodiments of this application. Detailed Implementation

[0012] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0013] In this specification, adjectives such as "first" and "second" are used only to distinguish one element or action from another, without necessarily requiring or implying any actual such relationship or order. Where circumstances permit, reference to an element or component or step (etc.) should not be construed as being limited to only one of the elements, components, or steps, but may be one or more of the elements, components, or steps, etc.

[0014] For ease of description, the dimensions of the various parts shown in the accompanying drawings are not drawn to actual scale.

[0015] In existing technologies, the construction of aggregates typically relies on graph partitioning algorithms, such as recursive bisection or multi-level partitioning methods, to cut the node connection graph in order to obtain a partitioning result with a roughly balanced number of nodes in each aggregate and the minimum number of connecting edges between aggregates. However, such methods have the following shortcomings: 1) Most graph partitioning algorithms only focus on the balance of the number of nodes, ignoring the connection topology of the original mesh, resulting in poor internal connectivity of the partitioned aggregates and destroying the local continuity of the original mesh; 2) In structural mechanics models, there are often rigid elements (e.g., high-stiffness regions in beam and shell elements), whose nodes have stiffness values ​​much higher than ordinary nodes. If rigid nodes are mixed with ordinary nodes in the same aggregate, it will cause serious numerical stiffness problems in the subsequent solution process, reducing the convergence efficiency of the preprocessor; 3) Existing methods lack effective recursive merging strategies when constructing multi-level aggregates, often failing to balance the balance and topological fidelity of each layer of aggregates, thus limiting the overall performance of multi-level solvers.

[0016] To address the aforementioned problems in the prior art, this application proposes a method for constructing aggregates, the flowchart of which is attached. Figure 1 As shown, it mainly includes steps S1 to S4, which are detailed below: Step S1: Obtain the total number of nodes in the structural mechanics simulation model, and calculate and determine the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate.

[0017] In step S1, the total number of nodes in the structural mechanics simulation model to be solved is first obtained. The total number of nodes is derived from the discretization of the finite element mesh and forms the basis of the degrees of freedom of the entire simulation model. Then, based on the preset target node count (oneAggNodeNum) for each aggregate, the number of aggregates in the first layer is calculated. The target number of nodes is not fixed but dynamically set based on the total number of nodes: when the total number of nodes is within a first-scale range (e.g., the number of nodes is small), the target number of nodes is proportional to the total number of nodes to ensure that each aggregate contains an appropriate number of nodes; when the total number of nodes is within a second-scale range greater than the first-scale range (e.g., the number of nodes is extremely large), the target number of nodes is fixed at a preset upper limit to avoid an excessive number of aggregates leading to an excessively large coarse-layer matrix. Specifically, as a preferred implementation, the target number of nodes is typically between 2 and 200, with smaller node sizes approaching 2 and larger node sizes approaching 200. For example, when the number of nodes is 500,000, the target number of nodes can be set to 50; when the number of nodes exceeds 5 million, the target number of nodes is fixed at 200. The number of aggregates in the first layer can be determined using the formula... The calculation yields a result that is rounded up to ensure coverage of all nodes. In this way, this application can flexibly adapt to simulation models of different sizes, providing accurate size constraints for subsequent topology-preserving partitioning.

[0018] Step S2: Based on the number of first-layer aggregates, a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh is constructed by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning. The recursive partitioning includes: progressively coarsening the node connection graph to generate a small-scale graph with a preset number of nodes; performing balanced partitioning on the small-scale graph to obtain the initial partitioning result; mapping the initial partitioning result back to the finer-level graph step by step; and using local or global optimization algorithms to correct the partitioning result after each level of mapping until the partitioning of the original mesh is obtained.

[0019] In existing technologies, the construction of aggregates typically employs a diffuse approach from local to global. For example, a starting node is selected, adjacent nodes are incorporated into the current aggregate one by one, and then the next starting node is selected. This approach often results in aggregates constructed earlier containing more nodes, forcing subsequent aggregates to fill irregular regions, leading to a severe imbalance in the number of nodes. Furthermore, the aggregate shape cannot effectively reflect the connection topology of the original mesh, resulting in a large condition number in the coarse-layer matrix and poor preprocessing convergence. To address this issue, this application proposes a recursive partitioning strategy from global coarse partitioning to local fine partitioning. Specifically, first, large blocks are partitioned on a coarse mesh geometrically similar to the original mesh. Then, each large block is further subdivided, and this process is recursively repeated until the number of nodes in the finest layer is equivalent to the preset target number of nodes. Figure 2 As shown, this global-then-local approach considers the overall outline from the beginning. Each subdivision is performed in a way that preserves the mesh outline, and each subdivision is done in a balanced manner, thus ensuring that the number of nodes in the final first-layer aggregate is balanced and the topology is faithful.

[0020] As an embodiment of this application, based on the number of first-layer aggregates, a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh is constructed by recursively dividing the node connection graph of the original mesh from global coarse division to local fine division. This can be achieved through the following steps S2-1 to S2-4, which are described in detail below: Step S2-1: Create a node connection graph based on the node-to-node connection relationships of the original mesh. .

[0021] First, obtain the node-to-node connectivity relationships of the mesh in the structural mechanics simulation case. These connections are typically derived from the element-node topology of the finite element mesh, meaning the adjacency relationships between nodes are determined by shared nodes among elements. Based on this, create an undirected graph. Each node corresponds to a grid node, and each edge represents a direct connection between two nodes (e.g., sharing the same cell). This graph forms the basis for all subsequent partitioning operations.

[0022] Step S2-2: Merge the node connection graph step by step using the method of multiple edge matching or multiple clique matching. The nodes in the graph generate a small-scale graph with a total number of nodes reaching a preset small-scale level. ,in, m The number of layers for recursive coarsening.

[0023] The coarsening process aims to progressively reduce a large-scale node-connected graph to a smaller-scale graph with a controllable number of nodes, while preserving the topological features of the original mesh. Specifically, heavy edge matching or heavy clique matching methods are used to merge nodes in the graph level by level. In each level of coarsening, a set of non-adjacent edges (or cliques) is selected, and the two endpoints (or multiple nodes) of each edge (or clique) are merged into a supernode, thereby generating the next level of coarse graph. This process continues until the number of nodes in the coarse graph first reaches or falls below a preset lower limit threshold for small-scale graphs (e.g., on the order of 100). The resulting graph is denoted as [Graph Name]. , m This refers to the number of recursive coarsening layers. Through this step-by-step merging, the global topology of the original mesh is compressed into a small-scale graph, providing an efficient computational foundation for subsequent precise partitioning.

[0024] Step S2-3: For small-scale graphs Perform precise balanced partitioning to ensure that each partition contains the same number of nodes and the number of connecting edges between partitions is minimized.

[0025] In small-scale maps Since the number of nodes has been significantly reduced, a precise balanced partitioning algorithm with higher computational complexity can be used to obtain a high-quality initial partition. Precise partitioning algorithms can employ either geometric bisection or greedy graph growing. Geometric bisection uses node coordinates to divide the graph into two subgraphs with equal numbers of nodes, recursively. Greedy graph growing starts from a seed node and gradually adds neighboring nodes until the subgraph reaches the target number of nodes. Regardless of the method used, the goal is to make each partition block contain as many nodes as possible while minimizing the number of connecting edges (i.e., cut edges) between blocks. The partitioning scheme obtained in this step will serve as the starting point for subsequent finer partitioning corrections.

[0026] Step S2-4: Convert the small-scale map The partitioning results are mapped back to the second coarse layer map level by level. After each level of mapping, the Kernighan-Lin method is used to refine and correct the partitioning results until the 0th level graph is obtained. The division resulted in the formation of the first-layer aggregate.

[0027] Small-scale map Starting from the partitioning results, the data is mapped back to finer layers level by level. The mapping process is simple: since each coarse-layer node corresponds to a set of fine-layer nodes, the partitioning label of the coarse-layer node is assigned to all its corresponding fine-layer nodes. However, this direct mapping often leads to a degradation in partitioning quality because the boundaries of the coarse-layer partitions may no longer be optimal in the fine layers. Therefore, after each level of mapping, the Kernighan-Lin method is used to locally refine the partitioning of the current layer. The Kernighan-Lin method reduces the number of cut edges by swapping boundary nodes while maintaining a balance in the number of nodes in each block. This refinement process is repeated until convergence. When the mapping and refinement are performed level by level to the 0th layer... At this point, the final partitioning result is obtained, namely the first-layer aggregate. This aggregate not only has a balanced number of nodes (consistent with the number determined in step S1), but also maintains the connection topology of the original mesh, laying a good foundation for subsequent rigid node processing and multi-level construction.

[0028] As another embodiment of this application, based on the number of first-layer aggregates, a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh can be constructed by recursively dividing the node connection graph of the original mesh from global coarse segmentation to local fine segmentation. This can be achieved through the following scheme: Create a node connection graph G0 based on the node-node connection relationships of the original mesh, and calculate the local density index of each node, where the local density index is the ratio of the degree of the node to the average degree of its neighboring nodes; Based on the local density index of each node, adaptive coarsening is performed on the nodes in the node connection graph G0: For node clusters with local density higher than a first threshold, the heavy edge matching method is used for coarsening; for sparse regions with local density lower than a second threshold, the heavy clique matching method is used for coarsening; for regions between the two, a hybrid coarsening strategy is used, so that the reduction ratio of the number of nodes in the coarsened graph G1 changes dynamically with the local density; Repeat the above steps for the coarsened graph G1 until a small-scale graph G with a total number of nodes reaches a preset small-scale order of magnitude is obtained. m Where m is the number of adaptive coarsening layers; for small-scale graphs G m A multi-objective genetic algorithm is used for partitioning, with optimization objectives including the balance of node counts in each partition block, the number of inter-block connections, and the average shortest path length of nodes within each partition block in the original graph, resulting in a Pareto-optimal partitioning scheme. This Pareto-optimal partitioning scheme is then mapped back to the second-coarse graph G level by level. m-1After each level of mapping, simulated annealing is used to globally optimize the partitioning results until the partitioning of the 0th layer graph G0 is obtained, thus forming the first version of the first layer aggregate. Compared with the fixed coarsening strategy (heavy edge matching or heavy clique matching) and single precise partitioning method (geometric bisection or greedy graph growth) used in the technical solutions of steps S2-1 to S2-4, and the fine partitioning correction only uses Kernighan-Lin local search, this scheme introduces local density-driven adaptive coarsening, which can select the most suitable coarsening method according to the graph structure characteristics of different regions, avoiding topological distortion caused by a uniform strategy. At the same time, a multi-objective genetic algorithm is used to simultaneously optimize the three indicators of balance, edge cutting rate and topological fidelity, and global fine partitioning correction is performed through simulated annealing, overcoming the defect of local search easily getting trapped in local optima in the technical solutions of steps S2-1 to S2-4.

[0029] Because the recursive partitioning process in step S2 may result in a discrepancy between the actual number of aggregates and the expected number due to algorithm parameters or the complexity of the mesh topology (e.g., one more or one less aggregate due to boundary handling or rounding errors), if this discrepancy is not detected in time, it will affect the construction of upper-level aggregates in subsequent step S4, and may even lead to a disordered hierarchical structure. Therefore, this application provides a verification mechanism, namely, Figure 1 The example method could also include: after step S2 and before subsequent step S3, verifying whether the number of first-layer aggregates in the first version is equal to the number of first-layer aggregates determined in step S1; if they are not equal, re-execute step S2. Thus, by performing quantity verification before proceeding to step S3, and immediately reverting to re-execute step S2 if a mismatch is found, the accuracy of the number of first-layer aggregates is ensured. This pre-verification mechanism guarantees the reliability of the entire process.

[0030] Another verification mechanism provided in this application can be as follows: after step S2 and before step S3, verify whether the number of first-layer aggregates in the first version is equal to the number of first-layer aggregates determined in step S1; if they are not equal, then activate the adaptive parameter adjustment mechanism: calculate the percentage deviation between the current actual number of aggregates and the target number, and dynamically adjust the lower limit threshold of the preset small scale in step S2-2 according to the percentage deviation, with the adjustment magnitude being positively correlated with the percentage deviation; re-execute step S2, and record the parameters after this adjustment and the corresponding partitioning results; if the number still does not match after three adjustments, then activate the backup partitioning strategy: replace the precise balanced partitioning method in step S2-3 with the spectral partitioning method based on the Laplacian matrix eigenvalue decomposition, and execute step S2 again. Compared with the verification mechanism of the aforementioned embodiments, this scheme introduces adaptive parameter adjustment and backup strategy switching: dynamically adjust the coarsening threshold according to the percentage deviation to make the next partitioning closer to the target; if multiple failures occur, switch to a more stable spectral partitioning method. This closed-loop control with learning and fault tolerance capabilities significantly improves the robustness and automation of the method, reflecting a deep consideration of complex engineering scenarios.

[0031] Step S3: Traverse the first-level aggregate, select nodes that belong to rigid units, and build each selected rigid node into an aggregate separately, thereby updating the first-level aggregate and obtaining the corrected first-level aggregate.

[0032] In structural mechanics simulations, the nodal stiffness values ​​of rigid elements (e.g., high-stiffness regions in beam and shell elements) are typically much higher than those of ordinary nodes. If rigid nodes and ordinary nodes are mixed in the same aggregate, the equivalent stiffness of the aggregate will be dominated by the rigid nodes, leading to a significant increase in the condition number of the coarse-layer matrix and a sharp decline in the convergence performance of the preprocessor. Existing aggregate construction methods do not specifically handle this situation, and therefore perform poorly when dealing with structural models containing rigid elements. To address this issue, this application actively identifies and separates rigid nodes based on the first-layer aggregate obtained in step S2.

[0033] The following combination Figure 3 The example diagram of rigid node correction illustrates the specific implementation of step S3, namely steps S3-1 to S3-3: Step S3-1: Traverse each aggregate in the first-level aggregate of the first version and check whether the aggregate contains rigid nodes.

[0034] First, iterate through all the first-layer aggregates obtained in step S2, checking each aggregate for nodes belonging to rigid elements. The determination of rigid nodes is as follows: obtain the type and corresponding stiffness matrix of each element; determine the rigidity determination rule based on the element type; identify nodes in the first-layer aggregates whose stiffness values ​​exceed the threshold set by the rigidity determination rule, and mark them as rigid nodes. Specifically, the stiffness matrix dimensions of different element types (e.g., beam elements, shell elements, solid elements) differ significantly, therefore, differentiated determination rules need to be set according to the element type. For example, for beam elements, the threshold can be set based on the ratio of their bending stiffness to shear stiffness; for shell elements, the threshold can be set based on the ratio of their membrane stiffness to bending stiffness. In this way, abnormally high stiffness nodes in various types of elements can be accurately identified.

[0035] As an embodiment of this application, traversing each aggregate in the first-layer aggregate of the first version and checking whether the aggregate contains rigid nodes can be achieved through the following scheme: obtaining the stiffness matrix of each element and calculating the strain energy density distribution of each element; comparing the strain energy density of each node with the average strain energy density of its element; if the strain energy density of the node exceeds a preset multiple of the average strain energy density, it is initially marked as a candidate rigid node; for the initially marked candidate rigid nodes, extracting the stiffness matrix eigenvalues ​​of all nodes in its neighborhood to form a feature vector; inputting the feature vector into a pre-trained support vector machine classifier, wherein the support vector machine classifier uses known rigid and non-rigid nodes in historical simulation data as training samples and outputs the classification result of whether the node is a rigid node; marking the nodes classified as rigid nodes as rigid nodes. This scheme introduces strain energy density comparison as an initial screening, which can capture abnormally high stiffness regions from the perspective of energy distribution, and then uses support vector machine for secondary accurate classification, integrating machine learning technology into traditional structural mechanics analysis. This data-driven intelligent judgment method not only improves the accuracy but also adapts to the features of different models.

[0036] Step S3-2: If the aggregate contains a rigid node, remove the rigid node from the original aggregate and mark the removed rigid node as a new aggregate.

[0037] For each rigid node identified in step S3-1, remove it from its original aggregate and construct a completely new aggregate on its own. For example... Figure 2 As shown, the gray circles represent rigid nodes, which are separated from the original aggregates and each forms a new aggregate containing only itself. This approach ensures that the ultra-high stiffness of rigid nodes is not diffused into aggregates containing other ordinary nodes, thus avoiding the numerical ill-conditioning of coarse-layer matrices.

[0038] Step S3-3: Update the total number of first-level aggregates to be equal to the original number of first-level aggregates plus the number of rigid nodes.

[0039] After step S3-2, the number of first-layer aggregates changes: the number of newly added aggregates equals the total number of rigid nodes separated. Therefore, the updated number of first-layer aggregates... ,in, This represents the number of rigid nodes. Simultaneously, the connectivity relationships between aggregates need to be updated to reflect the new adjacency topology formed after the rigid nodes are isolated.

[0040] It should be noted that if there are no rigid nodes in the first version of the first-layer aggregate obtained in step S2, step S3 can be skipped, and the first version of the first-layer aggregate can be directly used as the corrected first-layer aggregate to save unnecessary computational overhead.

[0041] Step S3 above actively identifies and filters nodes belonging to rigid elements by traversing the first-level aggregates, and then constructs each rigid node as a separate aggregate. In this way, rigid nodes no longer share the same aggregate with ordinary nodes; their ultra-high stiffness is confined to independent, extremely small aggregates. During the subsequent assembly of the coarse-level matrix, although the coarse-level elements corresponding to these independent aggregates have relatively large values, their extremely small size and weak coupling with other aggregates prevent them from contaminating the numerical properties of other aggregates. The condition number of the entire coarse-level matrix is ​​thus kept within a reasonable range, and the preprocessor can effectively balance and attenuate all error components, thereby ensuring the convergence robustness of the multi-level solver.

[0042] Step S4: Based on the corrected connection relationship between the first-layer aggregates, merge adjacent aggregates of the same layer to recursively construct aggregates of all layers except the first layer, thus completing the construction of aggregates of all levels.

[0043] After revising the first-level aggregates, it is necessary to continue building higher-level aggregates based on these first-level aggregates to form a complete multi-level structure. The specific implementation of step S4 includes the following steps S4-1 to S4-3: Step S4-1: Obtain the adjacency relationships between the first-layer aggregates after correction.

[0044] First, based on the updated first-level aggregates and their node affiliation information from step S3, the adjacency relationships between the aggregates are calculated. Two aggregates are considered adjacent if and only if there is at least one node-to-node connection between them across the aggregates. This adjacency relationship forms the graph structure basis for subsequent merging operations.

[0045] Step S4-2: Traverse all first-level aggregates, combine each first-level aggregate with an adjacent aggregate of the same level to form a coarser-level aggregate, and ensure that no aggregate can become a child node of two coarser-level aggregates at the same time.

[0046] After obtaining the adjacency relationships, all aggregates in the current layer are traversed, and each aggregate is paired with an adjacent aggregate in the same layer to form a coarser-level aggregate. The merging strategy directly affects the quality of the upper-level aggregates. As an embodiment of this application, traversing all first-level aggregates and combining each first-level aggregate with an adjacent aggregate in the same layer to form a coarser-level aggregate can be done by: calculating the connection weights between the aggregates in the current layer, where the connection weight is the number of node-to-node connection edges shared between the two aggregates; selecting adjacent aggregate pairs in descending order of connection weight for merging, prioritizing the merging of aggregate pairs with the largest connection weights. This greedy merging strategy based on connection weights ensures that the most tightly connected aggregates are merged first, thereby maximizing the connectivity within the upper-level aggregates and preserving the locally dense connections of the lower-level mesh. Simultaneously, it must be ensured that no aggregate can simultaneously become a child node of two coarser-level aggregates during the merging process; that is, each aggregate can only be merged once, thus maintaining the tree-like hierarchical relationship of the multi-level structure.

[0047] As another embodiment of this application, the implementation scheme of traversing all first-layer aggregates and combining each first-layer aggregate with an adjacent aggregate of the same layer into a coarser-level aggregate can also be as follows: construct the adjacency graph of the current layer aggregates and assign a comprehensive weight to each adjacent edge, wherein the comprehensive weight is obtained by weighted summation of three components: the first component is the number of node-node connection edges shared between the two aggregates, the second component is the logarithm of the ratio of the average stiffness of the nodes inside the two aggregates, and the third component is the reciprocal of the Euclidean distance between the center points of the two aggregates; the adjacency graph is segmented using a spectral clustering method to divide the aggregates into several clusters, and the aggregates in each cluster will be merged into a coarser-level aggregate, wherein the number of clusters in the spectral clustering is obtained by dividing the total number of the coarsest layer aggregates by the total number of the current layer aggregates and rounding down, and ensuring that the sum of the comprehensive weights of the aggregates in each cluster is maximized. Compared to the aforementioned embodiments, this scheme introduces a three-dimensional comprehensive weight, which integrates topological connection strength, numerical stiffness difference, and geometric proximity, to more comprehensively reflect the coupling relationship between aggregates. At the same time, it uses spectral clustering for globally optimal segmentation, rather than greedy sequential merging, which can find a globally approximate optimal merging scheme and avoid the cumulative error of the greedy strategy.

[0048] Step S4-3: Repeat steps S4-1 and S4-2 to continue building upwards based on the newly generated coarse-layer aggregate until the preset coarsest layer size is reached.

[0049] After merging the current layer, the newly generated coarse-layer aggregates form the aggregate set of the next layer (coarser layer). Then, based on the adjacency relationships between these new aggregates, the merging process of steps S4-1 and S4-2 is repeated to continue building coarser layers upwards. This recursive process continues until the number of the coarsest-layer aggregates drops to a preset threshold (e.g., stopping when the size of the coarsest-layer matrix is ​​small enough to be directly solved). At this point, the aggregates of all layers are constructed, forming a complete multi-level structure from the finest to the coarsest layer.

[0050] Through the recursive merging in step S4, this application constructs a hierarchical and structurally sound multi-level aggregation system. The upper-level aggregates naturally inherit the topological relationships of the lower levels, and the size of each aggregate gradually decreases as the level increases, providing an ideal coarse-grid foundation for the efficient operation of the multi-level preprocessor.

[0051] In step S4 of the above embodiment, the number of construction layers for each aggregate layer other than the first layer is determined by the preset size of the coarsest layer matrix. Recursion stops when the number of coarsest layer aggregates drops to a predetermined threshold. The ultimate goal of the multi-level preprocessor is to obtain a sufficiently small coarsest layer matrix that can be solved directly (e.g., by LU decomposition). Therefore, recursive construction needs to continue until the number of coarsest layer aggregates drops to a preset threshold (e.g., 100 or less). This threshold can be set according to the computer's memory capacity and the solver's efficiency. In this way, this application can automatically determine the required number of layers without manual intervention, realizing the adaptive construction of multi-level structures.

[0052] In step S1, the target number of nodes in each aggregate is dynamically set based on the total number of nodes: when the total number of nodes is within a first scale range, the target number of nodes is proportional to the total number of nodes; when the total number of nodes is within a second scale range greater than the first scale range, the target number of nodes is fixed at a preset upper limit. This dynamic setting strategy aims to balance the number of first-layer aggregates with the number of nodes in each aggregate. When the model size is small (e.g., fewer than 500,000 nodes), if the target number of nodes remains constant, the number of first-layer aggregates will be too small, and each aggregate will contain too many nodes, which is detrimental to subsequent fine-grained partitioning. Conversely, if the target number of nodes increases linearly with the total number of nodes, the number of first-layer aggregates can be kept within a reasonable range. When the model size is extremely large (e.g., more than 5 million nodes), if it continues to increase proportionally, the target number of nodes will become too large, resulting in too many nodes in each aggregate, thus losing the meaning of partitioning. Therefore, setting an upper limit (e.g., 200) ensures that the number of first-layer aggregates is not too small in large-scale models, thereby ensuring that the size of the coarse-layer matrix is ​​controllable. Through this dynamic setting, this application can adaptively adapt to simulation models of different scales, ensuring that the granularity of the first-layer aggregate is appropriate and avoiding degradation of partitioning quality in extreme cases.

[0053] In step S2-2 above, the termination condition for the coarsening process is: the step-by-step merging process continues until a small-scale graph is reached. The number of nodes in the coarse graph first reaches or falls below a preset lower threshold for a small-scale graph. Here, the lower threshold can refer to the minimum target size for coarsening, such as 100. Coarsening stops when the number of nodes in the coarse graph first drops to 100 or below. A lower threshold is set instead of a fixed value because the total number of nodes varies greatly among different models. Coarsening to a fixed number of nodes may lead some models to require too many coarsening layers, while others may not be coarsened enough. By setting a range (e.g., on the order of 100), the small-scale graph can be ensured to maintain a certain level of coarsening. The number of nodes is small enough for accurate partitioning, but not so small that key features of the original topology are lost.

[0054] In the above embodiments, for small-scale graphs When performing precise balanced partitioning, either the geometric bisection method or the greedy graph growth method is used. The geometric bisection method is suitable for meshes with geometric coordinate information. It divides the node set in two by a plane perpendicular to a coordinate axis, recursively, until the target number of blocks is reached. The greedy graph growth method, on the other hand, does not rely on coordinate information. Starting from a seed node, it gradually adds neighboring nodes until the number of nodes in the subgraph reaches the target value. Both methods are mature algorithms in the field of graph partitioning, but in the context of this application, they are applied to coarsened small-scale graphs. Therefore, the computational cost is controllable, and a high-quality initial partition can be obtained.

[0055] In the above embodiments, the Kernighan-Lin method is used to refine the partitioning results after each level of mapping. The goal is to ensure that the node count deviation of each partition block does not exceed a preset tolerance threshold, and that the number of inter-block connections is reduced compared to before the refinement. Here, the tolerance threshold is usually set to a small percentage (e.g., 5%), allowing the number of nodes in each block to fluctuate within a certain range, rather than forcing them to be completely equal. This aims to provide the Kernighan-Lin method with greater optimization space while maintaining balance, thereby further reducing the number of cut edges. By simultaneously optimizing balance and cut edge rate, the refined partitioning refinement can improve the sparsity of the subsequent coarse-layer matrix while ensuring partitioning quality.

[0056] In the above embodiments, after each fine-grained partitioning correction, the balance index and edge-cutting rate index of the current partitioning result are calculated. If the balance index is lower than a first preset threshold or the edge-cutting rate index is higher than a second preset threshold, the fine-grained partitioning correction steps S2 to S4 are repeated until both the balance index and edge-cutting rate index meet the requirements. This mechanism ensures that the quality of the first-layer aggregate is always within a controllable range. The balance index can be measured by the standard deviation or maximum deviation of the number of nodes in each block, while the edge-cutting rate index is the ratio of the number of inter-block connecting edges to the total number of edges. By setting clear thresholds (e.g., balance not lower than 90%, edge-cutting rate not higher than 10%), repeated correction is automatically triggered when a fine-grained partitioning correction fails to meet the standards. This closed-loop feedback control avoids quality defects that may remain from a single correction and significantly improves the robustness of the method.

[0057] The above mechanism employs a fixed, repetitive correction strategy. While this ensures that the quality of the first-layer aggregates remains within a controllable range, it lacks the ability to utilize historical correction effects and make adaptive decisions. Therefore, this application can also employ another mechanism: In step S2, after each fine-grained correction, the balance index and edge-cutting rate index of the current partitioning result are calculated. If the balance index is lower than a first preset threshold or the edge-cutting rate index is higher than a second preset threshold, a reinforcement learning-driven correction strategy is initiated: the current partitioning state is encoded as a state vector, which includes the number of nodes in each aggregate, the distribution of inter-block connections, and the adjustment magnitude of the last three corrections; the selectable correction actions are defined as: fine-tuning the boundaries of a pair of adjacent aggregates, internally repartitioning an aggregate, or swapping the boundary nodes between two aggregates; a Q-learning algorithm is used to select correction actions with the goal of maximizing long-term rewards, which are obtained by a weighted sum of the improved balance and edge-cutting rates; reinforcement learning correction is repeated until both the balance index and edge-cutting rate index meet the requirements, or the preset maximum number of iterations is reached. Clearly, this scheme introduces reinforcement learning into the graph partitioning correction process, enabling the system to learn the optimal action sequence from historical correction experience rather than blindly repeating it. The Q-learning algorithm can balance exploration and utilization, find the globally optimal correction path in complex partitioning states, and greatly improve the correction efficiency and final quality.

[0058] In this embodiment, a rigid element is defined as follows: When a node P is rigidly connected to several other nodes, node P is usually called a rigid element (node). If the number of nodes connected to node P exceeds half the number of nodes in a first-level aggregate, then the rigidity of P will be very high. Such nodes are considered as rigid nodes and are eliminated according to the aforementioned rigid element method and set as a separate aggregate.

[0059] In this embodiment, the selection scheme for rigid nodes is as follows: First, the average stiffness value Stiffness_avg is obtained by averaging the diagonal elements of the total stiffness matrix; the stiffness threshold is set to N_threshold times the average stiffness value, usually set to 20; each diagonal element in the total stiffness matrix is ​​compared with the average stiffness in turn, and if it is greater than the set threshold, the node corresponding to the diagonal element is set as a rigid node.

[0060] After determining the stiffness criteria for each element, all elements are traversed to identify those that satisfy the stiffness condition. Then, all nodes contained within these rigid elements are marked as rigid nodes. It's important to note that a node may belong to multiple elements simultaneously; as long as one of these elements is determined to be rigid, the node is considered a rigid node. Marked rigid nodes will be processed individually in subsequent steps. Through this precise identification method, this application effectively avoids missed or false identifications, ensuring that only truly high-stiffness nodes are separated.

[0061] In the above embodiments, when there are no rigid nodes in the first version of the first-layer aggregate, step S3 is skipped, and the first version of the first-layer aggregate is directly used as the corrected first-layer aggregate.

[0062] Because nodes undergo multiple coarsening and mapping processes during the recursive partitioning in step S2, their final aggregate location may be difficult to pinpoint quickly. When step S3 requires filtering rigid nodes, retracing the entire node connectivity graph incurs enormous computational overhead, severely impacting efficiency, especially in large-scale mesh scenarios. Therefore, this application provides an efficient node localization mechanism, namely… Figure 1 The example method can also include: during the recursive partitioning process, synchronously recording the aggregate identifier to which each node belongs in each coarsening step, forming a node-aggregate tracing path. When filtering out nodes belonging to rigid units, the first-level aggregate to which the rigid node belongs can be quickly located based on the tracing path, without needing to retrace the entire node connection graph. Specifically, this application maintains a tracing path for each node during the partitioning process, recording the aggregate identifier to which the node belongs in each coarsening step. When it is necessary to locate a rigid node, it is only necessary to trace backward along the path to the first level (level 0) to directly obtain the first-level aggregate identifier to which it belongs, with a time complexity of O(log n). O ( m ),in, m The number of coarsening layers is typically no more than 10. This mechanism significantly reduces the computational overhead of rigid node selection, making it particularly suitable for large-scale mesh scenarios.

[0063] Figure 1The example method may also include: during the recursive partitioning process in step S2, maintaining a variable-length hash list for each node, where the key of the variable-length hash list is the coarsening layer number and the value is the aggregate identifier to which the node belongs in the current layer; simultaneously, establishing an inverted index for each aggregate to record all node identifiers contained in each layer of the aggregate; when step S3 requires filtering rigid nodes, first querying the identifier of the node in the first-layer aggregate; if the node has been moved in subsequent coarsening processes (i.e., different aggregate identifiers exist in different layers in the hash list), then tracing back along the hash list to the first layer to obtain its final first-layer aggregate; if the node has never been moved, then directly returning the first-layer aggregate identifier in the hash list; the hash list and inverted index are updated in real time after each coarsening or mapping operation to ensure data consistency. The dual index structure of variable-length hash list and inverted index introduced in this scheme supports... O (1) Node location with time complexity and O The system enables path backtracking at a rate of (log n) and allows for real-time incremental updates, avoiding the overhead of full reconstruction. This data structure design, combining hash tables and inverted indexes, is significantly innovative in computer science, solving the storage and query efficiency bottlenecks in tracing paths within large-scale grid environments.

[0064] When recursively constructing upper-level aggregates, selecting adjacent aggregates for merging is a crucial decision. An unreasonable merging order (e.g., random merging or merging by number) can lead to distorted shapes and loose connections in upper-level aggregates, thereby disrupting the topological consistency of the multi-level structure. Therefore, the above embodiments of this application traverse all first-level aggregates, combining each first-level aggregate with an adjacent aggregate of the same level to form a coarser-level aggregate, which can be achieved through the following steps A and B: Step A: Calculate the connection weights between aggregates in the current layer. The connection weight is the number of node-to-node connection edges shared between two aggregates.

[0065] First, iterate through all aggregate pairs in the current layer. For each pair of adjacent aggregates, count the number of shared node-to-node connections between them. A shared edge is an edge whose two endpoints belong to two different aggregates. This number represents the connection weight between the two aggregates. The connection weight reflects the tightness of coupling between the two aggregates: more shared edges indicate a denser connection in the original mesh, resulting in stronger connectivity within the merged upper-layer aggregates. For example, if aggregates A and B have 10 shared edges, while aggregates A and C have only 2 shared edges, then A and B have a higher weight and should be merged first.

[0066] Step B: Select adjacent aggregate pairs in descending order of connection weight and merge them, prioritizing the aggregate pairs with the largest connection weight.

[0067] After calculating the connection weights of all adjacent aggregate pairs, these weights are sorted in descending order. Then, aggregate pairs are selected and merged sequentially according to the sorting results. After each merge, the aggregate set and adjacency relationships are updated, ensuring that each aggregate participates in only one merge (i.e., it will not become a child node of two coarser-level aggregates simultaneously). This greedy strategy ensures that the most tightly connected aggregates are merged first, thereby constructing upper-level aggregates with tightly connected internal structures and sparse external structures, which is beneficial for optimizing the sparse structure of the coarse-level matrix. For example, if the aggregate pair with the highest weight is (A, B), A and B are first merged into a new aggregate AB, and then A and B are removed from the candidate list to continue processing the next pair with the highest weight. In this way, this application can generate high-quality upper-level aggregates.

[0068] From the above Figure 1 As can be seen from the example of the aggregate construction method, on the one hand, by obtaining the total number of nodes in the structural mechanics simulation model and combining it with the preset target number of nodes, the number of first-layer aggregates is calculated and determined, thus providing a clear scale constraint for subsequent partitioning. On this basis, by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning, not only is the balance of the number of nodes in the first-layer aggregates achieved, but more importantly, the connection topology of the original mesh is preserved, so that the nodes inside each aggregate remain physically closely related, avoiding topological breaks caused by partitioning; on the other hand, by traversing the first First, the system constructs a first-layer aggregate and selects nodes belonging to rigid elements from it, building each rigid node into a separate aggregate. This eliminates the negative impact of rigid nodes on the numerical properties of ordinary aggregates, ensuring the numerical stability of each aggregate in subsequent linear solutions. Second, based on the modified connection relationships between the first-layer aggregates, adjacent aggregates of the same layer are merged to recursively construct aggregates for all layers except the first layer. This process fully utilizes the adjacency information of the lower-level aggregates, allowing higher-level aggregates to naturally inherit the topological relationships of the lower layers, forming a hierarchical and structurally sound multi-level aggregate system. In summary, the technical solution of this application improves the balance and numerical stability of aggregate construction by preserving topological balance in partitioning and separating rigid nodes.

[0069] Please see the appendix Figure 4 This application provides an aggregate construction device, which includes an acquisition module 401, a first construction module 402, an update module 403, and a second construction module 404, as detailed below: The acquisition module 401 is used to acquire the total number of nodes in the structural mechanics simulation model, and calculate and determine the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate. The first construction module 402 is used to construct a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning based on the number of first-layer aggregates. The recursive partitioning includes: progressively coarsening the node connection graph to generate a small-scale graph with a preset number of nodes; performing balanced partitioning on the small-scale graph to obtain an initial partitioning result; progressively mapping the initial partitioning result back to a finer-level graph; and using a local or global optimization algorithm to correct the partitioning result after each level of mapping until the partitioning of the original mesh is obtained. The update module 403 is used to traverse the first-level aggregate, filter out the nodes that belong to rigid units, and build each selected rigid node into an aggregate separately, thereby updating the first-level aggregate and obtaining the corrected first-level aggregate. The second construction module 404 is used to recursively construct aggregates of all layers except the first layer by merging adjacent aggregates of the same layer based on the connection relationship between the modified first-layer aggregates, thus completing the construction of aggregates of all layers.

[0070] From the above Figure 4 As can be seen from the example of the aggregate construction device, on the one hand, by obtaining the total number of nodes in the structural mechanics simulation model and combining it with the preset target number of nodes, the number of first-layer aggregates is calculated and determined, thus providing a clear scale constraint for subsequent partitioning. On this basis, by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning, not only is the balance of the number of nodes in the first-layer aggregates achieved, but more importantly, the connection topology of the original mesh is preserved, so that the nodes inside each aggregate remain physically closely related, avoiding topological breaks caused by partitioning; on the other hand, by traversing the first First, the system constructs a first-layer aggregate and selects nodes belonging to rigid elements from it, building each rigid node into a separate aggregate. This eliminates the negative impact of rigid nodes on the numerical properties of ordinary aggregates, ensuring the numerical stability of each aggregate in subsequent linear solutions. Second, based on the modified connection relationships between the first-layer aggregates, adjacent aggregates of the same layer are merged to recursively construct aggregates for all layers except the first layer. This process fully utilizes the adjacency information of the lower-level aggregates, allowing higher-level aggregates to naturally inherit the topological relationships of the lower layers, forming a hierarchical and structurally sound multi-level aggregate system. In summary, the technical solution of this application improves the balance and numerical stability of aggregate construction by preserving topological balance in partitioning and separating rigid nodes.

[0071] Figure 5 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. For example... Figure 5 As shown, the electronic device 5 in this embodiment mainly includes: a processor 50, a memory 51, and a computer program 52 stored in the memory 51 and executable on the processor 50, such as a program for an aggregate construction method. When the processor 50 executes the computer program 52, it implements the steps in the above-described aggregate construction method embodiment, for example... Figure 1 Steps S1 to S4 are shown. Alternatively, when processor 50 executes computer program 52, it implements the functions of each module / unit in the above-described device embodiments, for example... Figure 4 The functions of the acquisition module 401, the first construction module 402, the update module 403, and the second construction module 404 are shown.

[0072] For example, the computer program 52 of the aggregate construction method mainly includes: obtaining the total number of nodes in the structural mechanics simulation model, and calculating and determining the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate; based on the number of first-layer aggregates, constructing a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning, wherein the recursive partitioning includes: progressively coarsening the node connection graph to generate a small-scale graph with a node number reaching a preset small-scale level, and performing balanced partitioning on the small-scale graph to obtain... The initial partitioning result is mapped back to a finer-level graph level by level. After each level of mapping, a local or global optimization algorithm is used to correct the partitioning result until the original mesh partitioning is obtained. The first-level aggregate is traversed, and nodes belonging to rigid elements are selected. Each selected rigid node is constructed as an aggregate, thereby updating the first-level aggregate and obtaining the corrected first-level aggregate. Based on the connection relationship between the corrected first-level aggregates, adjacent aggregates of the same level are merged to recursively construct aggregates for all levels except the first level, thus completing the construction of aggregates for all levels. The computer program 52 can be divided into one or more modules / units, which are stored in the memory 51 and executed by the processor 50 to complete this application. One or more modules / units can be a series of computer program instruction segments capable of performing specific functions, which describe the execution process of the computer program 52 in the electronic device 5.For example, computer program 52 can be divided into the functions of acquisition module 401, first construction module 402, update module 403, and second construction module 404 (modules in the virtual device). The specific functions of each module are as follows: Acquisition module 401 is used to acquire the total number of nodes in the structural mechanics simulation model, and calculate and determine the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate; First construction module 402 is used to construct a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh by recursively dividing the node connection graph of the original mesh from global coarse division to local fine division based on the number of first-layer aggregates. The recursive division includes: progressively coarsening the node connection graph to generate a node number that reaches a preset minimum. A small-scale graph of similar scale is subjected to balanced partitioning to obtain an initial partitioning result. This initial partitioning result is then mapped back to a finer-level graph level by level. After each level of mapping, a local or global optimization algorithm is used to correct the partitioning result until the original mesh partitioning is obtained. The update module 403 is used to traverse the first-level aggregate, select nodes belonging to rigid elements, and construct each selected rigid node into a separate aggregate, thereby updating the first-level aggregate and obtaining the corrected first-level aggregate. The second construction module 404 is used to recursively construct aggregates for all levels except the first level by merging adjacent aggregates of the same level based on the connection relationship between the corrected first-level aggregates, thus completing the construction of aggregates for all levels.

[0073] Electronic device 5 may include, but is not limited to, processor 50 and memory 51. Those skilled in the art will understand that... Figure 5 This is merely an example of electronic device 5 and does not constitute a limitation on electronic device 5. It may include more or fewer components than shown, or combine certain components, or different components. For example, electronic device may also include input / output devices, network access devices, buses, etc.

[0074] The processor 50 may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or any conventional processor.

[0075] The memory 51 can be an internal storage unit of the electronic device 5, such as a hard disk or RAM. The memory 51 can also be an external storage device of the electronic device 5, such as a plug-in hard disk, Smart Media Card (SMC), Secure Digital (SD) card, or Flash Card. Furthermore, the memory 51 can include both internal and external storage units of the electronic device 5. The memory 51 is used to store computer programs and other programs and data required by the electronic device. The memory 51 can also be used to temporarily store data that has been output or will be output.

[0076] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed. That is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments 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. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above-described device can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0077] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0078] 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.

[0079] In the embodiments provided in this application, it should be understood that the disclosed devices / electronic devices and methods can be implemented in other ways. For example, the device / electronic device embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another device, or some features may be ignored or not executed. Furthermore, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.

[0080] 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.

[0081] Furthermore, 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. The integrated unit can be implemented in hardware or as a software functional unit.

[0082] If integrated modules / units are implemented as software functional units and sold or used as independent products, they can be stored in a storage medium. Based on this understanding, all or part of the processes in the above-described embodiments of this application can also be implemented by a computer program instructing related hardware. The computer program for the aggregate construction method can be stored in a storage medium. When the computer program is executed by a processor, it can implement the steps of the above-described method embodiments, namely, obtaining the total number of nodes in the structural mechanics simulation model, and calculating and determining the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate; based on the number of first-layer aggregates, constructing a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh by recursively dividing the node connection graph of the original mesh from global coarse division to local fine division, wherein the recursive division includes: dividing the node connection graph The process involves progressively coarsening the graph to generate a small-scale graph with a preset number of nodes. This small-scale graph is then evenly partitioned to obtain an initial partitioning result. This initial partitioning result is then mapped back to finer-level graphs, and local or global optimization algorithms are used to correct the partitioning result after each level of mapping until the original mesh partitioning is obtained. The first-layer aggregate is traversed, and nodes belonging to rigid elements are selected. Each selected rigid node is then constructed as a separate aggregate, thus updating the first-layer aggregate and obtaining a corrected first-layer aggregate. Based on the connection relationships between the corrected first-layer aggregates, adjacent aggregates of the same layer are merged recursively to construct aggregates for all levels except the first layer, completing the construction of aggregates for all levels. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or some intermediate form. Storage media can include: any entity or device capable of carrying computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the contents of storage media can be appropriately added to or removed according to the requirements of legislation and patent practice in a jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, storage media may not include electrical carrier signals and telecommunication signals.

[0083] The above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. These modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application. The specific embodiments described above further illustrate the purpose, technical solutions, and beneficial effects of this application. It should be understood that the above descriptions are merely specific embodiments of this application and are not intended to limit the protection scope of this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the protection scope of this application.

Claims

1. A method for constructing an aggregate, characterized in that, The method includes: Step S1: Obtain the total number of nodes in the structural mechanics simulation model, and calculate and determine the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate; Step S2: Based on the number of the first-layer aggregates, a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh is constructed by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning. The recursive partitioning includes: progressively coarsening the node connection graph to generate a small-scale graph with a preset number of nodes; performing balanced partitioning on the small-scale graph with a preset number of nodes to obtain an initial partitioning result; mapping the initial partitioning result back to a finer-level graph step by step; and using a local or global optimization algorithm to correct the partitioning result after each level of mapping until the partitioning of the original mesh is obtained. Step S3: Traverse the first version of the first-layer aggregate, select nodes that belong to rigid units, and construct each selected rigid node into an aggregate separately, thereby updating the first-layer aggregate and obtaining the corrected first-layer aggregate; Step S4: Based on the connection relationship between the modified first-layer aggregates, adjacent first-layer aggregates are merged to recursively construct aggregates for all layers except the first layer, thus completing the construction of aggregates at all levels. Step S2 includes: creating a node connection graph based on the node-node connection relationships of the original mesh. The node connection graph is merged step by step using methods such as heavy edge matching or heavy clique matching. The nodes in the graph generate a small-scale graph with a total number of nodes reaching a preset small-scale level. Where m is the number of recursive coarsening layers; for the small-scale graph Perform precise and balanced partitioning to ensure that each partition contains an equal number of nodes and minimizes the number of edges connecting the partitions; then, transform the small-scale graph... The partitioning results are mapped back to the second coarse layer map level by level. After each level of mapping, the Kernighan-Lin method is used to refine and correct the partitioning results until the 0th level graph is obtained. The division thus forms the first-layer aggregate of the first version; The step of traversing the first-layer aggregates and filtering out nodes belonging to rigid units includes: traversing each aggregate in the first-layer aggregates and checking whether the aggregate contains rigid nodes; if it does, removing the rigid nodes from the original aggregates and marking the removed rigid nodes as a new aggregate; updating the total number of first-layer aggregates to be equal to the original number of first-layer aggregates plus the number of rigid nodes.

2. The polymer construction method according to claim 1, characterized in that, Step S4 includes: Step S4-1: Obtain the corrected adjacency relationships between the first-layer aggregates; Step S4-2: Traverse all first-level aggregates, combine each first-level aggregate with an adjacent aggregate of the same level to form a coarser-level aggregate, and ensure that no aggregate can become a child node of two coarser-level aggregates at the same time. Step S4-3: Repeat steps S4-1 and S4-2 to continue building upwards based on the newly generated coarse-layer aggregate until the preset coarsest layer size is reached.

3. The polymer construction method according to claim 2, characterized in that, The step of traversing all first-level aggregates and combining each first-level aggregate with an adjacent aggregate of the same level into a coarser-level aggregate includes: Calculate the connection weights between aggregates in the current layer, where the connection weight is the number of node-to-node connection edges shared between two aggregates; Adjacent aggregate pairs are selected and merged in descending order of their connection weights, with priority given to merging aggregate pairs with the highest connection weights.

4. The polymer construction method according to claim 1, characterized in that, The method further includes: after step S2 and before step S3, verifying whether the number of the first layer aggregates in the first version is equal to the number of the first layer aggregates determined in step S1; if they are not equal, then re-execute step S2.

5. An apparatus for constructing polymers, characterized in that, The apparatus implements the polymer construction method according to any one of claims 1 to 4, and the apparatus comprises: The acquisition module is used to acquire the total number of nodes in the structural mechanics simulation model, and calculate and determine the number of first-layer aggregates based on the preset target number of nodes contained in each aggregate; The first construction module is used to construct a first-layer aggregate with a balanced number of nodes and reflecting the connection topology of the original mesh by recursively partitioning the node connection graph of the original mesh from global coarse partitioning to local fine partitioning based on the number of the first-layer aggregate. The recursive partitioning includes: progressively coarsening the node connection graph to generate a small-scale graph with a preset number of nodes; performing balanced partitioning on the small-scale graph with a preset number of nodes to obtain an initial partitioning result; mapping the initial partitioning result back to a finer-level graph step by step; and using a local or global optimization algorithm to correct the partitioning result after each level of mapping until the partitioning of the original mesh is obtained. The update module is used to traverse the first version of the first-layer aggregate, filter out the nodes that belong to rigid units, and build each filtered rigid node into an aggregate separately, thereby updating the first-layer aggregate and obtaining the corrected first-layer aggregate. The second construction module is used to recursively construct aggregates of all layers except the first layer by merging adjacent aggregates of the same layer based on the connection relationship between the modified first-layer aggregates, thus completing the construction of aggregates of all layers.

6. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the aggregate construction method as described in any one of claims 1 to 4.

7. A storage medium storing a computer program, characterized in that, When the computer program is executed by a processor, it implements the aggregate construction method as described in any one of claims 1 to 4.

Images