Iron tower anti-falling device static load calculation method and system based on finite element analysis

Abstract

This invention specifically relates to a method and system for calculating the static load of a power transmission tower fall arrestor based on finite element analysis, belonging to the field of power transmission tower safety protection technology. It includes: a finite element result data parsing and topology reconstruction module; a physical quantity gradient field high-frequency calculation module; a mesh shelling and merging module; a view frustum intersection and dynamic memory scheduling module; and a data mapping and rendering module. In this invention, the core mechanical feature of stress gradient is deeply integrated with mesh simplification and rendering optimization algorithms, constructing a physically-aware intelligent rendering optimization system. This system can achieve reasonable mesh simplification in structural regions with gentle stress changes based on the spatial distribution characteristics of the stress field, reducing data redundancy and memory usage, and improving the rendering smoothness of large-scale models. Simultaneously, in critical stress areas of the fall arrestor and dangerous areas with drastic stress changes, the original mesh details and stress distribution information are fully preserved, avoiding misjudgments of safety hazards caused by rendering simplification.

Description

Technical Field

[0001] This invention relates to the field of power transmission tower safety protection technology, and in particular to a method and system for calculating the static load of tower fall arresters based on finite element analysis. Background Technology

[0002] Transmission towers are the core infrastructure of power transmission systems. As a key safety protection device for high-altitude operation and maintenance of transmission lines, fall arresters directly affect the personal safety of maintenance personnel and the stable operation of the power grid system.

[0003] With the large-scale construction of high-voltage, long-span transmission lines, the simulation models of tower-fall arrester assemblies exhibit characteristics of large scale, high precision, and multi-scale coupling. The number of model nodes generally reaches millions or even tens of millions, placing higher engineering demands on the analytical efficiency of finite element results, the smoothness of rendering large-scale models, and the visualization accuracy of key stress areas. In practical engineering applications, simulation results often come from different types of solvers such as ANSYS, Abaqus, and Nastran, requiring compatibility with heterogeneous result file parsing capabilities. At the same time, the assembly model combines the hundred-meter-scale large-scale structure of the tower trunk with the millimeter-scale micro-contact structure of the fall arrester locking mechanism, resulting in a large spatial scale span. It is necessary to fully preserve the stress distribution details of key contact areas while rendering the entire model smoothly, posing a multi-scale adaptation requirement for rendering optimization techniques.

[0004] Currently, both finite element simulation and 3D visualization technologies have formed relatively mature technical systems. Their deep integration and synergistic optimization have become an important development direction in the field of power transmission equipment safety performance simulation analysis. In existing technical systems, core mechanical features such as stress gradients are mainly used for structural mechanical performance evaluation, but have not yet formed a deep coupling relationship with rendering optimization algorithms. For static load simulation scenarios of multi-scale assemblies such as tower-fall arresters, there is an urgent need for a complete technical solution that can handle heterogeneous file parsing, intelligent rendering optimization with mechanical feature perception, and high-precision visualization of multi-scale models, in order to further improve the efficiency and engineering practicality of static load simulation analysis of tower fall arresters. Summary of the Invention

[0005] The purpose of this invention is to provide a method and system for calculating the static load of tower fall arresters based on finite element analysis in order to solve the above-mentioned problems.

[0006] To achieve the above objectives, the present invention adopts the following technical solution: A static load calculation system for tower fall arresters based on finite element analysis includes: The finite element result data parsing and topology reconstruction module is configured to parse the heterogeneous finite element result files of the iron tower fall arrester, extract the node spatial coordinates, element topology connections and node equivalent stress scalar data, and construct the mesh topology connectivity relationship based on the half-edge data structure in memory; The high-frequency calculation module for physical quantity gradient fields is configured to perform a topological one-ring neighborhood space search based on a half-edge data structure, reconstruct and differentiate the neighborhood stress field, and calculate the three-dimensional stress gradient vector and stress gradient scalar of each node. The mesh shelling and merging module is configured to calculate the dynamic gradient threshold based on the available video memory capacity, determine the low gradient region based on the dynamic gradient threshold, perform edge folding operation on the low gradient region, and pass the stress value of the new vertex through interpolation to output a heterogeneous mesh. The view frustum intersection and video memory dynamic scheduling module is configured to build a hierarchical bounding box tree for heterogeneous meshes, remove invisible nodes, stream visible heterogeneous mesh data to video memory via a main memory ring buffer, and perform video memory page replacement. The data mapping and rendering module is configured to receive heterogeneous mesh data from video memory, perform depth interpolation on texture coordinates and find pseudo-color textures, and output a three-dimensional stress cloud map of the static load of the fall arrester.

[0007] Preferably, in the finite element result data parsing and topology reconstruction module, the efficient reading and low-level parsing of heterogeneous finite element result files are as follows: The system initializes a data reading thread pool with asynchronous I / O capabilities; for large result files with more than one million nodes, memory-mapped file technology is used to map large files on the disk to the operating system's virtual memory address space. The parsing engine scans and locates the node spatial coordinate data segment, the unit topology connection data segment, and the node physical quantity data segment according to the preset file data block identifier; When parsing the physical quantity data segment, the system extracts three normal stress components and three shear stress components, and transforms the stress tensor into a one-dimensional equivalent stress scalar. For any node in space, its equivalent stress The calculation formula is established by the following mathematical logic: ; in, These represent the normal stresses at the node in the three orthogonal directions X, Y, and Z in the local coordinate system, respectively. These represent the corresponding shear stresses.

[0008] Preferably, the complex topology reconstruction process based on half-edge data structure is as follows: Traverse all finite element surface elements; for each polygonal facet, instantiate a half-edge object for each edge inside it in counter-clockwise order; establish a pointer binding network in the heap area of ​​memory, as follows: Each half-edge holds a memory pointer to its starting "vertex"; a pointer to its "face"; a pointer to the next clockwise / counterclockwise "half-edge" within the same face; and a pointer to its paired half-edge that shares the same physical boundary but is in the opposite direction. Each "vertices" only needs to hold a pointer to any half of an edge that originates from the vertex; Each "face" only needs to hold one pointer to any half of the face that makes up the face; When binding paired half-edge pointers, a unique hash key is generated from the indices of the two vertices constituting the physical edge; when traversing the half-edge set, the hash key is used to... The time complexity of finding and matching twin halves is [not specified].

[0009] Preferably, the topological one-ring neighborhood space search based on the half-edge data structure includes: Based on the constructed half-edge data structure, a topological one-ring neighborhood search algorithm is executed, targeting the current central node. The system collects all pairs of matching halves by accessing any initial half of its bound edge and continuously tracking the paired half and the next half. The set of directly connected neighbor nodes ; If the mesh in the gear edge region of the fall arrester is too sparse and the topological neighborhood cannot provide enough data support, an Euclidean space range search based on a 3D KD tree is automatically triggered to forcibly obtain the K nearest neighbor nodes within the given spherical space radius as supplementary calculation points.

[0010] Preferably, the meshless gradient derivation process based on the moving least squares method is as follows: For the central node In a local region, let the local approximate stress function be... : ; Where, vector These are the fitting coefficients to be solved; The system constructs a distance-weighted error functional. ; in, Neighboring nodes coordinates It is the known equivalent stress value of the neighboring nodes; It is a spatial weighting function; The error functional above has respect to the coefficients Taking the partial derivatives and setting them to zero transforms the problem into solving a system of normal equations. Solving this system yields the coefficient vector. ; At this point, the system extracts the calculation results from... Components, combined to form a central node The three-dimensional gradient vector of the stress field .

[0011] Preferably, the dynamic gradient threshold : Get the number of bytes of available free video memory for the current graphics processor. ; The system also determines the number of bytes occupied by a single vertex in video memory based on the preset rendering data packet structure. Calculate the maximum number of safe nodes that the current GPU can smoothly render. ; The system extracts the set of stress gradient scalar values ​​for all mesh nodes. ,in Generate an ascending sequence of gradient scalars; Let the total number of nodes in the original finite element model be... :based on and The relationship between the two factors determines the dynamic gradient threshold. ; Determine the threshold Then, for any polygonal patch in space Extract its surface normal vector and plane equation constants ; For the vertices that make up the face Its fundamental geometric quadratic error matrix Defined as a 4×4 symmetric matrix; Traversing vertices In the half-side data structure, the fundamental error matrices of all adjacent faces are summed to obtain the vertex. The initial geometric quadratic error matrix : For any line from vertex to be folded and Composed physical edges Extract the stress gradient scalar values ​​of these two vertices. and Construct a joint error metric function .

[0012] Preferably, the topology-safe edge folding execution logic and attribute lossless interpolation include: The system obtains information by accessing half of the data structure. One-ring neighbor node set and One-ring neighbor node set The system calculates the intersection of two sets. If a set is detected If the number of elements is not equal to 2, terminate the edge folding, remove it from the queue, and obtain the next edge; The simulation will Move to The position is determined, the normal vector of the affected patch is recalculated, and a dot product operation is performed with the original normal vector. If the dot product result is negative, the folding is rejected. After passing all security checks, the original target was... and All vertex pointers on all halves of the edge are uniformly modified to point to the newly allocated memory. The system reclaims and releases edges in the heap memory. The memory space for the face it occupies, as well as the memory space for an extra set of half-edges and vertex objects; For the new vertex equivalent stress value Extract the total area of ​​the affected polygonal faces before merging. The Gaussian inverse distance interpolation method based on patch area weighting is used to calculate... .

[0013] Preferably, the view frustum intersection and video memory dynamic scheduling module specifically includes: A bottom-up clustering algorithm and spatial cost function are used to construct a hierarchical bounding box tree for heterogeneous meshes containing polygonal patches; Extract the current observation matrix and projection matrix of the graphics pipeline to derive the view frustum boundary plane, use the separating axis theorem to calculate the directed distance from the nodes of the hierarchical bounding box tree to the boundary plane, and perform a culling test for the invisible bounding box nodes of the view frustum. Page-locked memory is allocated in the host main memory and a circular buffer is constructed. The visible heterogeneous mesh data that has passed the culling test is deconstructed into vertex attributes and index data, and then asynchronously streamed to the graphics processor's video memory buffer via the direct memory access mechanism. When the video memory capacity reaches the saturation threshold, the average stress gradient scalar value of the vertices in each candidate data block in the video memory data block linked list is calculated as the physical importance weight, and the video memory pages are swapped out from the data blocks that are inactive and have low physical importance weights.

[0014] Preferably, the specific execution steps of the data mapping and rendering module include: The visible heterogeneous mesh data is scanned by a parallel reduction algorithm to obtain the mean and standard deviation of the local stress distribution in order to calculate the upper and lower limits of the dynamic limiting mapping. The equivalent stress scalar of each vertex is nonlinearly normalized based on the upper and lower limits to generate one-dimensional texture coordinates. During the rasterization stage of the graphics pipeline, the screen space centroid coordinates of the pixel fragments inside the polygon are obtained, and the perspective correction interpolation engine is called to perform non-linear depth interpolation on the one-dimensional texture coordinates. Based on this, the pre-mounted pseudo-color gradient texture in the video memory is searched to extract the high-precision color vector. For the microscopic coplanar contact area between the fall arrestor and the tower track, a reverse depth test is activated in the underlying rendering state machine to reverse the depth mapping interval. Based on the polygon offset algorithm, a dynamic depth offset is calculated according to the slope scaling factor of the depth gradient to participate in the depth test, so as to eliminate depth conflict flicker at the coplanar interface. Subpixel-level coverage-weighted smoothing is applied to the pixels at the edges of the small patch, and the front and rear frame buffers of the double-buffered swap chain are swapped when a vertical blank backtracking pulse signal is detected, outputting a three-dimensional stress cloud map of the static load of the fall arrester.

[0015] A method for calculating the static load of tower fall arresters based on finite element analysis includes: The heterogeneous finite element result file is parsed, the nodal spatial coordinates and stress data are extracted and converted into equivalent stress scalars, and the mesh topology connectivity based on the half-edge data structure is constructed in memory. Based on the mesh topology connectivity, the local neighborhood set of each node is obtained, and the three-dimensional stress gradient vector and stress gradient scalar of each node are solved. Calculate the dynamic gradient threshold based on the available video memory capacity, identify regions where the stress gradient scalar is below the threshold as low gradient regions, perform topology-safe edge folding and stress property interpolation on low gradient regions, and generate heterogeneous meshes. A hierarchical bounding box tree is constructed for the heterogeneous mesh. Invisible nodes are eliminated by performing an intersection test with the current view frustum. The visible heterogeneous mesh data is then asynchronously streamed to the video memory via a circular buffer in main memory. Physical field scalar normalization is performed on the heterogeneous mesh data in the video memory. The perspective correction interpolation engine is called to perform pixel-level depth interpolation on the normalized coordinates and find pseudo-color textures. Depth conflicts at micro-contact boundaries are handled, and a three-dimensional stress cloud map of the static load of the fall arrester is rendered and output.

[0016] In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are: 1. This invention constructs a physically-aware intelligent rendering optimization system by deeply binding the core mechanical feature of stress gradient with mesh simplification and rendering optimization algorithms. It can achieve reasonable mesh simplification in structural areas with gentle stress changes based on the spatial distribution characteristics of the stress field, reducing data redundancy and memory usage, and improving the rendering smoothness of large-scale models. At the same time, in critical stress areas of the fall arrester and dangerous areas with drastic stress changes, it completely preserves the original mesh details and stress distribution information, avoiding misjudgment of safety hazards caused by rendering simplification.

[0017] 2. This invention improves the engineering practicality and operational stability of static load simulation analysis of tower fall arresters by constructing a fully automated technology system from finite element result analysis to stress cloud map visualization. Addressing the visualization challenges of multi-scale assemblies of towers and fall arresters, it solves common industry problems such as color discontinuity in large-size surface stress cloud maps and flickering at microscopic contact surfaces through multiple underlying rendering optimization technologies. Simultaneously, through intelligent memory scheduling and a hardware-software collaborative fault-tolerance mechanism, it ensures smooth operation during large-scale model perspective switching and system stability under extreme conditions. Attached Figure Description

[0018] 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 system structure diagram of the present invention; Figure 2 This is a flowchart of the method of the present invention. Detailed Implementation

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

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

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

[0022] Appendix Figure 1 The structural block diagram of the static load calculation system for tower fall arresters based on finite element analysis provided in the embodiments of the present invention shows the connection relationship between the finite element result data parsing and topology reconstruction module and the data mapping and rendering module, and marks the main functional interaction flow of each module.

[0023] Appendix Figure 2 The flowchart of the static load calculation method for tower fall arresters based on finite element analysis provided in the embodiments of the present invention shows the complete steps from parsing heterogeneous finite element result files to rendering and outputting a three-dimensional stress cloud map of the static load of the fall arrester.

[0024] In this embodiment, it includes: Module 1: Finite Element Result Data Parsing and Topology Reconstruction Module, configured to parse heterogeneous finite element result files of tower fall arresters, extract node spatial coordinates, element topology connections and node equivalent stress scalar data, process abnormal geometry, and construct mesh topology connectivity based on half-edge data structure in memory; This module serves as the data entry point and underlying structural foundation for the entire stress gradient-based dynamic level-of-detail rendering optimization system. Its core technical objective is to overcome the closed data format barriers of general-purpose finite element analysis (CAE) software, extract massive amounts of node data losslessly, and construct a topological data structure in computer memory that supports ultra-fast spatial adjacency relationship queries.

[0025] Efficient reading and low-level parsing of heterogeneous finite element result files: In industry, static load calculations for fall arresters and towers may come from different solvers (such as ANSYS .rst files, Abaqus .odb files, or Nastran .op2 files). This module first incorporates a cross-platform, low-level binary stream parsing engine.

[0026] This engine does not rely on the API interfaces provided by the original manufacturer (to avoid high licensing fees and runtime performance overhead), but instead performs a through-read based directly on the byte stream sequence of the file system. The specific implementation steps are as follows: The system initializes a data reading thread pool with asynchronous I / O capabilities. For large result files with more than a million nodes, the system does not use the conventional approach of loading the entire file into memory (which is prone to memory overflow), but instead uses memory-mapped file technology to map large files on disk to the operating system's virtual memory address space. The parsing engine scans and locates three core data segments according to the preset file data block identifiers: node spatial coordinate data segment, unit topology connection data segment, and node physical quantity (stress / strain / displacement) data segment; When parsing the physical quantity data segment, the system extracts a stress tensor with six independent components, including three normal stress components and three shear stress components. In order to be used for subsequent gradient field rendering, the system needs to convert this three-dimensional stress tensor into a one-dimensional equivalent stress scalar.

[0027] This module incorporates the von Mises equivalent stress calculation logic based on the fourth strength theory. For any node in space, its equivalent stress... The calculation formula is established by the following mathematical logic: ; in, These represent the normal stresses at the node in the three orthogonal directions X, Y, and Z in the local coordinate system, respectively. These represent the corresponding shear stresses.

[0028] Through this step, the system reduces the dimensionality of the complex tensor field to a scalar field that is easier for computers to process.

[0029] Complex topology reconstruction based on half-edge data structures: After obtaining discrete node coordinates, element connectivity (such as tetrahedral and hexahedral element vertex indices), and equivalent stress, the most crucial step is to establish the topological relationships of these data in three-dimensional space. If a traditional adjacency matrix or adjacency list is used, the memory usage will explode exponentially when dealing with millions of nodes, and the computational time complexity for subsequent queries of adjacent nodes will be extremely high.

[0030] Therefore, this module introduces an improved "half-edge data structure" to achieve topology reconstruction of the mesh. In this structure, three core structures are allocated in computer memory: vertices, faces, and half-edges. Each physical boundary edge of the finite element mesh surface is artificially split into two "half-edges" with opposite directions by the system.

[0031] The specific algorithm logic for topology reconstruction is as follows: First, the system iterates through all finite element surface elements (discarding internally invisible volume elements to save memory, since graphics rendering only applies to structural surfaces); for each polygonal facet, a half-edge object is instantiated for each of its internal edges in a counter-clockwise order. Next, a strict pointer binding network is established in the heap area of ​​memory: Each half-edge holds a memory pointer to its starting "vertex"; a pointer to its "face"; a pointer to the next clockwise / counterclockwise "half-edge" within the same face; and most importantly, a pointer to its "paired half-edge" that shares the same physical boundary but is in the opposite direction.

[0032] Each "vertices" only needs to hold a pointer to any half of the edge that starts from that vertex.

[0033] Each "face" only needs to hold one pointer to any half of the face that makes up that face.

[0034] To ensure efficient topology reconstruction, the system employs a collision-free mapping strategy based on a hash table when binding paired half-edge pointers. A bitwise XOR operation and a bitwise shift operation are performed on the two vertex indices constituting a physical edge to generate a unique hash key. When traversing the half-edge set, this key is used to... It can quickly find and match twin halves in terms of time complexity.

[0035] Nonmanifold geometric anomaly handling and data standardization: In the complex mechanical assembly model of the tower and fall arrestor, errors in finite element mesh generation tools can easily lead to non-manifold geometry, such as multiple faces sharing the same edge or multiple objects intersecting at only a single vertex. This abnormal topology can cause fatal memory overflows or infinite loops when constructing twin pointers in a half-edge data structure.

[0036] This module incorporates a rigorous non-manifold detection and repair subroutine. Before constructing a half-edge structure, the system counts the number of times each global physical edge is referenced by a face. If an edge is detected to have more than two references (e.g., a "T-shaped" intersection), the system will logically tear apart the connection region. Specifically, this is achieved by cloning the vertex coordinate data at the abnormal intersection in memory, assigning it a new internal index ID, and physically separating the originally intersecting faces on the topology graph, transforming them into two or more manifold structures that are infinitely close in spatial coordinates but completely independent in memory topology.

[0037] After the above-mentioned full-process processing, the system has built a "data building" in memory that deeply integrates geometric coordinates, finite element stress scalar fields and efficient spatial access logic, thus preparing the underlying architecture for the next step of high-frequency calculation of gradient fields.

[0038] Module 2: High-frequency calculation module for physical quantity gradient field, configured to connect with the finite element result data parsing and topology reconstruction module, is used to perform a topological one-loop neighborhood space search based on a half-edge data structure, use the moving least squares method to reconstruct the derivative of the neighborhood stress field, calculate the three-dimensional stress gradient vector and stress gradient scalar of each node, and perform smoothing filtering on singularities; This module is the mathematical and algorithmic engine that enables the system to achieve "dynamic intelligent rendering." Its core task is to calculate the three-dimensional spatial rate of change (i.e., gradient) of the stress field on millions of grid nodes using the topology constructed in Module 1. The essence of the stress gradient reflects the "severity" of the stress approaching the danger threshold under static load in the tower fall arrest system.

[0039] Local neighborhood space search for unstructured grids: In regular Cartesian meshes (such as medical image voxels), calculating gradients only requires simple differences between adjacent points on the coordinate axes. However, the finite element models of towers and fall arresters are highly unstructured triangular or tetrahedral meshes with nodes irregularly scattered in space.

[0040] The system first executes the "topological one-ring neighborhood" search algorithm based on the half-edge data structure constructed in Module 1. This algorithm is then applied to the currently computed central node. The system continuously tracks the "Twin" and "Next" halves by accessing any of its bound initial halves, much like circling the ribs of an umbrella, quickly and comprehensively collecting all halves related to the initial half. The set of directly connected neighbor nodes .

[0041] If the mesh is found to be too sparse in certain extremely sharp gear edge areas of the fall arrestor, and the topological neighborhood cannot provide sufficient data support, the system will automatically trigger a Euclidean space range search based on a 3D KD tree to forcibly obtain the K nearest neighbor nodes within a given spherical space radius as supplementary calculation points.

[0042] Meshless gradient derivation based on moving least squares method: After obtaining the neighborhood node set and its corresponding von Mises equivalent stress data, the system enters the core gradient solution stage. To overcome the geometric distortion error caused by the unstructured mesh, this module abandons the simple finite difference method with poor accuracy and instead introduces the moving least squares algorithm to reconstruct and differentiate the local stress field with high accuracy.

[0043] For the central node In a local region, the system assumes that the stress field can be approximated using a first-order Taylor polynomial basis. Let the local approximate stress function be... ; Where, vector These are the fitting coefficients to be solved. Here, In a physical sense, it precisely corresponds to the partial derivatives of the stress field in the X, Y, and Z directions, which are the gradient components we are looking for.

[0044] is the constant term of the first-order Taylor polynomial; Let be the rectangular coordinates of any point in three-dimensional space, and be the independent variable of the stress function; To obtain the optimal coefficient vector The system constructs a distance-weighted error functional. ; in, Neighboring nodes coordinates It is the known equivalent stress value of the neighboring nodes. It is a spatial weighting function with highly technical characteristics: to reduce the interference of outliers far from the central node on the stress gradient calculation, the system adopts a Gaussian decay weighting function. ; It is the central node The total number of neighboring nodes, taking a positive integer value; For the first Neighboring nodes, These are the X, Y, and Z coordinates of the node in a three-dimensional Cartesian coordinate system. parameter This is a smoothing factor that the system dynamically and adaptively calculates based on the average side length of the local grid.

[0045] Subsequently, the system invokes the underlying high-performance linear algebra computation library (such as a matrix solver customized based on the BLAS / LAPACK specification) to evaluate the aforementioned error functional with respect to the coefficients. Taking the partial derivatives and setting them equal to zero transforms the problem into solving a system of normal equations: (The normal equations derived after minimizing the error functional are a system of 4 linear equations.) The system solves the 4×4 linear equation system using either LU decomposition or singular value decomposition (SVD) to directly obtain the coefficient vector. .

[0046] At this point, the system extracts the calculation results from... Components, combined to form a central node The three-dimensional gradient vector of the stress field:

[0047] These are the unit orthogonal basis vectors in the X, Y, and Z coordinate axes of a three-dimensional rectangular coordinate system; Gradient scalarization and adaptive boundary singularity smoothing filtering: After obtaining the 3D gradient vector, the LOD (Level of Detail) algorithm for graphics rendering requires a unified metric to measure the drasticness of change. Therefore, the system calculates the Euclidean norm (i.e., magnitude) of the gradient vector, generating a pure gradient scalar value:

[0048] In certain extreme conditions of the fall arrester (such as at the microscopic sharp corner where the locking gear is in rigid contact with the track), finite element calculations can generate stress values ​​that theoretically tend to infinity due to stress singularities. This can cause the gradient scalar calculated at that node to grow explosively (generating data noise points). If these noise points are directly fed to the subsequent LOD rendering module, the rendering pipeline will make incorrect mesh subdivision decisions.

[0049] Therefore, this module finally incorporates an adaptive boundary singularity smoothing filter. The system statistically analyzes the data distribution of gradient scalars across all nodes globally and calculates their mean. with standard deviation The system constructs a control chart based on statistics, setting a threshold of [value missing]. When a local node gradient value is detected to exceed the dynamic upper limit, the system determines it to be stress singular noise. Subsequently, instead of simply truncating the data, the system calls a Laplacian smoothing filter to forcibly reset the gradient value of the abnormal node to the area-weighted average of the gradient values ​​of all normal nodes in its topological ring neighborhood, thereby ensuring that the gradient field data sent to the rendering module is absolutely smooth and conforms to the actual physical trend.

[0050] Module 3: Mesh Shelling and Merging Module, configured to connect with the physical quantity gradient field high-frequency calculation module, is used to calculate the dynamic gradient threshold based on the available video memory capacity, identify regions where the stress gradient scalar is less than the dynamic gradient threshold as low gradient regions, perform topology-safe edge folding operations on low gradient regions using a joint error metric function that incorporates physical field penalty terms, and output heterogeneous meshes by interpolating the stress values ​​of new vertices. This module is the core of the entire system. The technical problem it solves is: after outputting a finite element model with millions or even tens of millions of nodes, how to overcome the limitations of traditional blind LOD algorithms based on "camera distance" and enable the computer to perform mesh simplification with "physical field awareness." Specifically, it removes a large number of redundant nodes in safe areas of the tower where stress is relatively flat, while retaining all mesh details intact in areas with intense stress and large stress gradients, such as fall arresters, to significantly reduce the data throughput of subsequent processing.

[0051] Dynamic gradient threshold under constraints of memory capacity and total number of nodes Solver engine: Before performing mesh shelling, the system does not set a hard-coded static gradient threshold, because different tower models and different drop conditions can lead to highly uneven stress gradient distribution. This module first incorporates a dynamic threshold calculation algorithm based on the current computer hardware resource status.

[0052] The system first calls the operating system's underlying hardware query interface (such as the WMI interface or Linux's Sysfs file system) to obtain the number of bytes of available free video memory for the current graphics processing unit (GPU). The system also calculates the number of bytes occupied by a single vertex in video memory based on the preset rendering data package structure (including attributes such as vertex coordinates, normal vectors, texture coordinates, and stress scalar values). Therefore, the system calculates the maximum number of safe nodes that the current GPU can smoothly render. ,in To account for system safety factors related to memory fragmentation, the value is typically between 0.7 and 0.85.

[0053] Obtain the target capacity Then, the system extracts the set of stress gradient scalar values ​​for all mesh nodes calculated in module two. ,in The system inputs the data from the set into a one-dimensional quicksort or bucket sort algorithm engine to generate an ascending sequence of gradient scalars.

[0054] Subsequently, the system constructs the empirical cumulative distribution function. Let the total number of nodes in the original finite element model be... ,if If the system determines that the current hardware resources are sufficient, it will skip this simplification module and directly set the threshold. Let it be infinity. If... The system needs to remove The system has nodes in a sorted gradient sequence. Using this as the index position, the corresponding gradient value is extracted and multiplied by a dynamically adjusted weight, ultimately establishing it as the dynamic gradient threshold under the current operating condition. This operational logic ensures that the system always removes nodes whose global gradient changes are the most gradual.

[0055] Physics-driven construction of the quadratic error metric cost matrix: Determine the threshold Afterwards, the system will process all... Mesh simplification is implemented for nodes in low-gradient regions. To ensure that the three-dimensional geometric outline of the tower does not suffer severe distortion after merging patches, this system mathematically integrates the traditional quadratic error metric algorithm with the equivalent stress field.

[0056] Traditional QEM algorithms evaluate error by calculating the sum of squared distances from a vertex to its neighboring faces. In this system, for any polygonal facet in space... The system first extracts its surface normal vector. and plane equation constants noodle sheet The equation of a spatial plane can be expressed as ,in A point in a three-dimensional space in homogeneous coordinates.

[0057] For the vertices that make up the face Its fundamental geometric quadratic error matrix Defined as a 4×4 symmetric matrix: ; System traversal of vertices In the half-side data structure, the fundamental error matrices of all adjacent faces are summed to obtain the vertex. The initial geometric quadratic error matrix : ; As vertices The set of all adjacent polygon faces can be obtained through the half-edge data structure constructed in Module 1. Fast query retrieval with time complexity of level 1; At this point, the core logic of the invention intervenes: the system must penalize the folding behavior of edges with high stress gradients: for any edge to be folded from vertex... and Composed physical edges The system extracts the stress gradient scalar values ​​of these two vertices. and The system constructs a joint error metric function that is "physical field sensitive". : ; In this formula, It is assumed that and The optimal spatial coordinates after merging into a new vertex. It is a dimensionless penalty coefficient. The physical and algorithmic significance of this formula is that when the edge... When in a region of drastic stress change, the exponential term in the latter half will increase sharply, causing the folding cost of that edge to skyrocket.

[0058] The system calculates the folding cost of all candidate edges in the grid. After calculation, the edges are pushed into a priority queue based on a min-heap for management. Edges with lower costs are placed earlier in the queue and are merged sooner.

[0059] Topology-safe edge folding execution logic and lossless attribute interpolation: Edge folding is a substantive action that alters the topological connectivity in computer memory. The system pops the edge with the minimum folding cost from the top of the priority queue. Perform a folding operation to merge two vertices into a new target vertex. .

[0060] Before deleting or rewriting data in memory, the system must have a built-in "topology security defense mechanism." The system obtains this information by accessing half of the data structure. One-ring neighbor node set and One-ring neighbor node set The system calculates the intersection of two sets. , In a standard triangular manifold mesh, the number of intersections of the endpoints of an internal edge must be exactly 2. If a set is detected... If the number of elements is not equal to 2, the system determines that forcibly folding the edge will cause the model to produce a non-manifold "bow tie" topological anomaly. The system will immediately terminate the folding of the edge, remove it from the queue, and obtain the next edge.

[0061] In addition, the system also needs to perform normal flip detection. The system simulation will... Move to The system recalculates the normal vectors of the affected patches at their positions and performs a dot product with the original normal vectors. If the dot product result is negative, it indicates that the merging will cause the patches to self-intersect or flip in 3D space, and the system will also reject this folding.

[0062] Once all security checks are passed, the system performs a low-level half-pointer redirection: redirecting the pointer that was originally pointing to... and All vertex pointers on all halves of the edge are uniformly modified to point to the newly allocated memory. Subsequently, the system reclaims and releases the edges in the heap memory. The memory space for the face it occupies, as well as a set of extra half-edges and vertex objects.

[0063] While merging the geometric topology, it is essential to perform lossless transfer of the finite element physical properties. For the new vertex... equivalent stress value The system cannot perform a simple arithmetic average. To conform to the laws of mechanical distribution, the system extracts the total area of ​​the affected polygonal faces before merging. The Gaussian inverse distance interpolation method based on patch area weighting is used to calculate... : ; This represents the total number of polygon faces affected by vertex merging during the edge folding operation, and its value is a positive integer. For the first The two-dimensional spatial area of ​​each affected surface, taking the value of a positive real number; For the new vertices after the merger , and the The geometric center of the affected facet The Euclidean distance between them is a positive real number. For the first The equivalent stress scalar value corresponding to the centroid position of each affected surface.

[0064] This ensures that the color distribution of the macroscopic stress field cloud map of the tower in the low-precision rendering area remains strictly consistent with the original high-precision solution results, avoiding misjudgment of engineering safety hazards due to visual dimensionality reduction.

[0065] Module 4: View frustum intersection and video memory dynamic scheduling module, configured to connect with gradient-based non-uniform mesh shelling and merging module, is used to build hierarchical bounding box trees for heterogeneous meshes, perform intersection tests with view frustums to remove invisible nodes, stream visible heterogeneous mesh data to video memory via main memory ring buffer, and perform physical property-aware video memory page replacement based on stress gradient scalar average weight. After the physics-driven shelling process in Module 3, the originally massive uniform finite element mesh has been transformed into a heterogeneous mesh (containing an extremely high-density mesh for the fall arrestor region and an extremely low-density mesh for the tower safety region). This module aims to solve the bandwidth bottleneck problem of transferring heterogeneous data from main memory (RAM) across the PCIe bus to video memory (VRAM). It achieves on-demand streaming of data by constructing a spatial index tree and combining it with the user's interactive perspective in the UI.

[0066] The hierarchical bounding box (BVH) tree of the physics field envelopment is constructed from bottom to top: If the system had to traverse all remaining heterogeneous mesh faces to determine visibility every time the user rotated or zoomed the 3D model's viewpoint, it would severely consume CPU clock cycles, leading to a drop in rendering frame rate. Therefore, the system needs to build a hierarchical bounding box tree in memory for accelerated spatial lookups.

[0067] This system abandons the traditional octree and instead adopts axis-aligned bounding boxes (AABB trees) because AABBs have lower computational cost for updates and intersection tests. The construction process is completed by a bottom-up clustering algorithm: First, the system calculates the initial AABB bounding box for each polygon patch output by module three (whether it's a high-precision small patch or a low-precision large patch). The AABB is defined by two 3D coordinate points: the smallest diagonal point of the bounding box. and the largest diagonal point At this point, these individual bounding boxes constitute the set of leaf nodes of the BVH tree.

[0068] Subsequently, the system enters the iterative merging phase. The system employs a greedy algorithm based on surface area heuristics to find the optimal merging pair. For any two adjacent bounding box nodes... and The system assumes they are merged into a parent bounding box. The system calculates the combined spatial cost function. .in, For the merged parent bounding box The three-dimensional surface area; For the merged parent bounding box The total number of triangular facets contained therein is numerically equal to The number of triangles contained and The sum of the number of triangles included.

[0069] The system merges the two bounding boxes with the lowest global search space cost to generate new internal nodes and establishes bidirectional parent-child pointers at the memory level. This process is iterated until only a single global root bounding box (RootNode) containing the macroscopic outline of the entire tower and fall arrestor remains in memory. At this point, the massive unstructured mesh is completely organized into a binary tree data structure with strict spatial hierarchy.

[0070] Mathematical Modeling and High-Frequency Exact Intersection Algorithm for Hexahedral View Cone Space: When the fall arrester static load rendering system is running on the screen, the user's line of sight can be abstracted as a truncated pyramid shape, called a view frustum in computer graphics. The second step of this module is to extract the mathematical model of this view frustum at high frequency and perform collision detection with a BVH tree.

[0071] The system reads the current view matrix (derived from the camera position, the view target point, and the up vector, reflecting the transformation from the world coordinate system to the camera local coordinate system) and the projection matrix (defined by the camera's field of view, screen aspect ratio, and near / far clipping plane, reflecting the transformation from the camera coordinate system to the clipping space) from the state machine of the graphics application programming interface (such as OpenGL or Vulkan).

[0072] The system multiplies these two 4×4 matrices to obtain a composite view projection matrix. . The projection matrix is ​​a 4×4 homogeneous transformation matrix; The ViewMatrix is ​​a 4×4 homogeneous transformation matrix. By extracting the row vectors of this composite matrix, the system can accurately derive the six boundary planes (left, right, bottom, top, near, far) constituting the view frustum in three-dimensional space. Let the matrix... The four lines are respectively For example, the coefficient vector of the equation for the "left plane" of the view cone can be obtained through... The normal vectors of the six planes are obtained by direct addition, and the same applies to the other planes, ultimately forming the normal vectors of the six planes. and intercept .

[0073] After obtaining the six planes of the view frustum, the system performs a depth-first search (DFS) traversal to find intersections starting from the root node of the BVH tree. For any AABB bounding box encountered during the current traversal, the system does not need to test the eight vertices of the bounding box; instead, it uses an optimized split-axis theorem calculation method. Based on the sign of the normal component of the view frustum plane, the system quickly locates the vertex on the AABB closest to the plane. and the farthest vertex .

[0074] The system calculates the directed distance from a point to a plane: if If the bounding box is completely outside the plane (i.e., outside the screen), the system immediately determines it as "invisible" (Cull) and directly breaks the further search of the BVH tree branch in the memory query, discarding tens of thousands of polygon face data under it; if the bounding box intersects with all planes or is completely inside the plane, the system continues to recursively delve into the child nodes until it reaches the leaf node.

[0075] On-demand data assembly and video memory streaming based on a circular buffer: After frustum culling, the system filters out the leaf nodes (i.e., the actual set of polygonal faces) that are "absolutely visible" from the current viewpoint. These heterogeneous mesh data need to be pushed into video memory in the most efficient way.

[0076] This system allocates a special "page-locked memory" segment in the host's main memory. This memory space is not swapped to the hard drive by the operating system, thus supporting direct memory access (DMA) hardware transfers with the GPU.

[0077] The system constructs a circular buffer data structure in page-locked memory. The system then structurally reconstructs the polygonal patch data obtained through the view frustum test, deconstructing it into separate "vertex attribute arrays" (containing 3D coordinates). and equivalent stress scalar ) and "index array" (which describes how vertices are combined to form a triangle).

[0078] The system obtains the mapping pointer of the GPU's video memory in main memory through the underlying memory mapping interface. The system assigns a dedicated asynchronous transfer thread to continuously copy data packets from the main memory circular buffer to the mapping pointer address in a pipeline-like manner. This lock-free mechanism allows the GPU's DMA engine to continuously extract data into the vertex buffer object (VBO) and index buffer object (IBO) of video memory while the CPU writes data at one end, thus achieving zero-latency uploading of heterogeneous stress mesh data.

[0079] Video memory page replacement and physical attribute-aware LRU eviction mechanism: When a user performs a large-scale viewpoint pan, causing a large number of new high-density grid areas of the fall arrestor to enter the view frustum, the system may face extreme situations where GPU memory is exhausted. This module introduces a "physically aware" least recently used eviction algorithm on the memory side.

[0080] Unlike the LRU strategy in operating systems, which is based solely on "access time," the memory controller in this system assigns an additional "physical importance weight" to each data block when maintaining the linked list of memory data blocks. This weight is equal to the average scalar stress gradient of all vertices within that data block.

[0081] When the system detects that new grid data needs to be uploaded but the video memory is full, the memory scheduler first scans the tail of the linked list (i.e., candidate discard blocks that have not appeared on the screen for a long time). If the tail data block has an extremely high "physical importance weight" (for example, it contains data from the core locking area of ​​the fall arrestor), the system will make an exception and lock it in video memory, and force the pointer to traverse forward to find a data block with a lower "physical importance weight" (for example, the far end of the tower base) that is also inactive, and then swap it out of the video memory and overwrite it.

[0082] Through this underlying memory scheduling logic, this module ensures that no matter how drastically the user's perspective changes, the system always reserves the extremely valuable memory bandwidth and space for the core area that is most complex and subject to the most drastic changes, fundamentally eliminating the memory overflow crash problem that is common in industrial software when processing ultra-large-scale assembly models.

[0083] Module 5: Data Mapping and Rendering Module, configured to connect with the View Frustum Intersection and Memory Dynamic Scheduling Module, is used to receive heterogeneous mesh data in memory, perform physical field scalar normalization based on statistical distribution, call the perspective correction interpolation engine to perform pixel-level depth interpolation on the normalized stress texture coordinates and find pseudo-color textures, combine reverse depth testing and polygon offset algorithm to eliminate contact boundary depth conflicts, and output a three-dimensional stress cloud map of the fall arrester's static load. This module is located at the very end of the entire data processing architecture, interacting directly with the computer's underlying graphics processing unit (GPU) hardware pipeline. Its core technical challenge is addressing the following: after processing by Module 3 (non-uniform mesh hulling) and Module 4 (dynamic frustum scheduling), the data pushed to the video memory is highly heterogeneous (i.e., the fall arrestor section contains millions of facets retaining extreme microscopic details, while the main tower section consists of highly compressed and merged low-polygon large facets). How can we ensure that this data, with its extremely uneven topological density, not only maintains a stable frame rate but also avoids visual distortions, artifacts, or color banding when finally outputting a 3D stress cloud map?

[0084] Vertex attribute assembly and high-concurrency computation of programmable geometric transformation matrices: The rendering pipeline officially starts after the circular buffer in Module 4 pushes heterogeneous vertex data packets to the vertex buffer object (VBO) in video memory. The system first activates the first critical stage in the programmable shader pipeline: the vertex shader.

[0085] Because the data entering the VBO is in batches, the system utilizes thousands of stream processors on the GPU to perform ultra-large-scale single-instruction multiple-data (SIMD) concurrent computation. For any vertex in the buffer pool... The system extracts its three-dimensional local physical coordinate vector. (In homogeneous coordinates) and the accompanying equivalent stress scalar properties .

[0086] Inside the vertex shader, the system first executes a rigorous coordinate system transformation algorithm. The system reads three core transformation matrices from the graphics engine's global state machine: the model matrix... (Responsible for transforming the local coordinates of the fall arrestor to the global coordinates of the tower), observation matrix (Responsible for transforming world coordinates to the virtual camera's observation space coordinates) and the projection matrix (Responsible for transforming the observation space coordinates into the clipping space coordinates).

[0087] For each concurrently executed vertex, the underlying hardware performs a series of matrix multiplication operations to derive the standard coordinate vector of that vertex in the four-dimensional clipping space. : ; Among them, the result vector At this point, the system does not modify the stress scalar. Instead of using numerical values, it treats them as custom attributes and passes them to the next stage of the pipeline via dedicated high-speed registers. This step gives the static mechanical mesh dynamic camera viewpoint responsiveness.

[0088] Global / Local Dynamic Adaptive Physics Field Scalar Normalization and Pseudo-Color Mapping Algorithm In the process of converting the stress scalar calculated by finite element method into visible colors on the screen, if the traditional approach of traversing and calculating RGB colors on the CPU and then uploading them to the video memory is used, it will exhaust the transmission bandwidth between main memory and video memory. This module pushes all the mapping logic from physical quantities to color to the GPU and introduces a one-dimensional texture lookup table mechanism.

[0089] First, before rendering each frame, the system needs to perform statistical normalization on the physical field data within the current view frustum. The system uses a parallel reduction algorithm to scan the stress values ​​of all active vertices in the GPU's Compute Shader, extracting the maximum stress value for the current frame. and minimum stress value .

[0090] To prevent isolated grid singularities (such as the infinite stress generated by the extremely sharp locking teeth of a fall arrestor) from widening the mapping range of the entire color spectrum and causing a lack of color distinctiveness in most normal areas of the tower, a dynamic limiting mechanism is introduced into the system. The system calculates the mean of the local stress distribution. with standard deviation Forced to adjust the mapping limit to The lower limit is revised to .

[0091] In the vertex shader, the system extracts the stress scalar of the vertex. Perform nonlinear or linear normalized scalar transformations to generate normalized texture coordinates. : ; Subsequently, the system calls the underlying built-in truncation function. Ensure variables Strictly bound to the closed interval [0,1]. The system pre-generates and mounts a pseudo-color gradient texture (e.g., a classic "warm and cool color map") of size 1024×1 pixels in video memory. Values ​​of 0 are mapped to dark blue, 0.5 to green, and 1.0 to dark red. The vertex shader calculates the normalized coordinates. The data is sent out so that subsequent pipelines can directly extract high-precision RGB color values ​​from the one-dimensional texture, completely decoupling the mechanical calculation domain from the color rendering domain.

[0092] Fragment attribute smoothing interpolation engine based on perspective correction centroid coordinates: This is the core mathematical mechanism by which this module addresses the "fragmentation of heterogeneous data." After processing by the vertex shader, the 3D coordinates of the vertices are divided by perspective (i.e., the coordinate vectors are divided by perspective) through hardware. Divide each component by the homogeneous coordinate component. The vertices are converted into standard device coordinates (NDC) and further mapped to the pixel coordinates of the 2D screen window. Simultaneously, the vertices are assembled into discrete triangular polygonal patches.

[0093] At this point, the system faces a severe challenge: to reduce memory usage, Module 3 generates large, low-polygonal "patches" spanning tens or even hundreds of meters in the low-stress gradient region of the tower; while millimeter-level "tiny patches" are retained in the fall arrestor region. When the rasterizer discretizes these polygons into pixel fragments on the screen, if the internal physical quantities are not interpolated with extremely high precision, the large patches on the tower will appear as abrupt, solid-color blocks, severely violating the physical law that the stress field changes continuously and gradually in nature.

[0094] To address this issue, the system not only takes over traditional color interpolation but also hardware-level depth interpolation of physical properties. For triangles and polygons (composed of vertices...) Any pixel fragment within the composition The underlying hardware first calculates the screen space centroid coordinates of the pixel relative to its three vertices, and sets them as follows: and satisfy .

[0095] However, during the projection from 3D space onto a 2D screen, due to perspective distortion, directly using the barycentric coordinates of the screen space for linear interpolation leads to severe distortion errors (for example, stress changes at the far end of a tower appear faster than at the near end). Therefore, the system forcibly enables a hardware-level perspective correction interpolation engine. For this pixel fragment... Normalized stress texture coordinates that need to be inherited The system performs the following complex nonlinear rational polynomial operations: ; in, These are the normalized stress coordinates of the three vertices of the triangle. The homogeneous depth component is generated for perspective projection transformation. Through this underlying mathematical constraint, the present invention ingeniously compensates for the loss of visual accuracy caused by the significant simplification of the mesh in Module 3. Even if the main part of the tower is compressed into a very small number of large triangular facets, the system can still reconstruct a continuous stress gradient field at the pixel level that is visually almost indistinguishable from the original high-precision mesh of tens of millions, achieving the perfect technical effect of "extremely simplified data with no visual loss".

[0096] Nonlinear depth calculation for microscopic complex contact boundaries and Z-Fighting conflict elimination mechanism In the static load analysis of fall arresters, their core operating mechanism is that their internal locking blocks or gears violently clamp the edge of the tower rail in an instant. This "infinitely close" mechanical contact alignment will cause a catastrophic display error known as depth conflict (Z-Fighting) in 3D graphics rendering.

[0097] Specifically, when the distance between the metal contact surface of the fall arrester and the metal contact surface of the tower track in three-dimensional space is less than or equal to the minimum resolution limit of a single-precision floating-point number (Float32), the GPU's depth test buffer (Z-Buffer) will be unable to distinguish which surface is closer to the camera. This will cause a violently flickering grid-like noise at the junction of the fall arrester and the track on the screen, directly hindering engineers from observing the stress distribution in the dangerous area.

[0098] To address this rendering defect caused by physical contact, this module performs low-level optimization by addressing the mathematical nonlinear characteristics of the depth buffer data. The depth values ​​of the conventional graphics pipeline... The mapping is non-linear, and its formula is: ; in, The distance along the optical axis from the far clipping plane of the perspective projection to the optical center of the camera; The distance along the optical axis from the near clipping plane of the perspective projection to the optical center of the camera; To observe the spatial depth value, that is, the true linear distance along the optical axis from the three-dimensional spatial point corresponding to the current fragment to the optical center of the camera; For the homogeneous coordinates of vertices in clip space Quantity; This inverse distribution causes the depth resolution to drop exponentially with distance from the camera. To address this, the system first forcibly injects a reverse depth test technique into the underlying rendering state machine. The system sets the depth buffer to 0.0, changes the depth test comparison operator from "less than" to "greater than", and, combined with the exponential bit distribution characteristics of floating-point numbers, completely reverses the depth mapping between the near and far clipping planes. This strategy fully utilizes the hardware characteristic of floating-point numbers having extremely high bit density near zero, enabling the depth resolution of the internal microscopic contact surface of the fall arrester to be improved by tens of thousands of times, even when the fall arrester is far from the camera.

[0099] Furthermore, for mesh data exhibiting coplanarity in the physical model, the system, during pipeline drawing calls (DrawCall), analyzes the mesh semantic labels and dynamically activates a polygon offset algorithm for high-risk faces belonging to the "fall arrester locking mechanism." The system calls the underlying API to send two core bias parameters to the rasterizer: the slope scaling factor. and constant depth cell multiplier Before the generated fragment depth value is entered into the Z-Buffer for comparison, the hardware forcibly calculates a tiny depth offset based on the following logic. : ; The system uses depth data with this offset in the final visibility test. Without changing the actual spatial coordinates of the object, it uses the subtle "deception" of the underlying data to perfectly eliminate the flickering problem of the contact surface under extreme conditions, thus ensuring the visual stability of the most critical analysis area.

[0100] Pixel-level fragment blending, multi-sampling anti-aliasing, and underlying frame buffer swapping architecture When the data stream reaches the penultimate stage of the pipeline, the fragment shader, the system performs final pixel attribute finalization. The fragment shader receives normalized stress coordinates from the perspective correction interpolation engine. The hardware texture sampler is invoked, and a bilinear filtering mode is used to perform a high-speed search on the 1D pseudo-color texture generated in the second step of module five, extracting the accurate physical state color vector. .

[0101] Meanwhile, considering that the crash arrester is composed of numerous irregular curved contours (such as the edges of ratchet pawls), its edges will exhibit noticeable stepped aliasing (jaws) due to the orthogonal rasterization characteristics of the pixel matrix. To address this issue, instead of performing costly blurring calculations within the fragment shader, the system activates the multi-sampling anti-aliasing mechanism of the graphics card's underlying hardware. When creating a frame buffer object (FBO), the system forcibly requests a combination of a color buffer and a depth buffer containing at least four sub-samples per pixel. The rasterizer performs sub-pixel-level coverage testing at the edges of the polygons and performs an arithmetic weighted average of the coverage weights, resulting in an extremely smooth and sharp 3D mechanical contour of the crash arrester in the final output, exhibiting the precision characteristic of engineering software.

[0102] Finally, after passing depth and stencil tests, the fragment color and coverage data are written to the off-screen rendering buffer in video memory. At this point, the screen still displays the previous frame. This module establishes a double-buffered swap chain logic based on either vertical synchronization (V-Sync) or adaptive synchronization (Adaptive-Sync). Only when the monitor emits a vertical blank backtracking pulse signal will the system send a SwapBuffers instruction to the GPU, rapidly swapping the two memory address pointers. This ensures that when users drag and rotate to view the tower stress cloud map, the image data is strictly and uniformly updated in terms of physical field logic from beginning to end, and there will never be any data synchronization errors causing screen tearing.

[0103] The SwapBuffers instruction is a key API instruction in the low-level rendering pipeline of computer graphics, corresponding to the "low-level frame buffer swapping architecture" section in the fifth sub-step of Module 5 of the patent. Its core function is to achieve ultra-fast swapping of the front and back buffers under the double buffering mechanism, fundamentally solving the screen tearing problem when rendering large industrial scenes (such as stress cloud maps of iron towers and fall arresters), and ensuring that the update of physical field data on the screen is strictly integrated and synchronized.

[0104] Hardware and software collaborative monitoring and fault-tolerant handling mechanism for rendering pipeline timeout recovery (TDR): When the finite element model is exceptionally complex or the user-input load parameters cause extremely dense stress abrupt changes in local areas of the crash arrester, Module 3 will retain all the tiny facets because these areas have extremely high gradients. When these occasional "super polygonal data blocks" are pushed to the GPU and complex shader logic is executed, they are highly likely to take too long, causing the single-frame rendering time to exceed the operating system's graphics driver watchdog timer threshold (e.g., the 2-second limit in Windows). At this point, the operating system's timeout detection and recovery mechanism will be triggered, forcibly resetting the entire graphics driver, causing the rendering system to crash and exit.

[0105] To provide system-level protection, this module introduces an additional cross-threaded rendering daemon. This daemon uses an asynchronous object query mechanism to monitor the underlying nanosecond-level time consumed by the GPU pipeline when processing each group of grid data blocks with extremely high precision.

[0106] The system presets a safety performance threshold (e.g., the single-frame processing limit is set to 80% of the current display refresh rate cycle, approximately 13.3 milliseconds). When the daemon detects that the GPU is about to trigger a timeout due to excessive computation, the system sends an emergency interrupt control signal via the CPU in the next frame. Subsequently, the system triggers an emergency dimensionality reduction rollback strategy: forcibly short-circuiting the logic branch of "preserving high gradient regions" in Module 3, performing temporary data sparsification on the ultra-high-density mesh block that is causing computational blockage (e.g., skipping two-thirds of the vertex assembly), and simultaneously disabling MSAA and high-precision perspective correction interpolation in the shader, switching to the cheapest constant shading.

[0107] By employing dynamic fault-tolerant control logic that temporarily sacrifices some extremely high-frequency details in exchange for preventing the underlying computer hardware from crashing and restarting, this system demonstrates super adaptive capabilities under extremely harsh data input conditions. Example

[0108] Please see Figure 2 A method and system for calculating the static load of tower fall arresters based on finite element analysis, comprising the following parts: The heterogeneous finite element result file is parsed, the nodal spatial coordinates and stress data are extracted and converted into equivalent stress scalars. After processing non-manifold geometric anomalies, the mesh topology connectivity based on half-edge data structure is constructed in memory. The local neighborhood set of each node is obtained based on the grid topology connectivity. The local stress field is reconstructed by the moving least squares method. The three-dimensional stress gradient vector and stress gradient scalar of each node are solved. Weighted smoothing filtering is performed on singular points that exceed the distribution threshold. The dynamic gradient threshold is calculated based on the available video memory capacity. Regions with stress gradient scalar values ​​below the threshold are identified as low gradient regions. A joint error metric function incorporating physical field penalty terms is used to perform topologically safe edge folding and stress property interpolation on low gradient regions to generate heterogeneous meshes. A hierarchical bounding box tree is constructed for the heterogeneous mesh. Invisible nodes are eliminated by performing an intersection test with the current view frustum. Visible heterogeneous mesh data is asynchronously streamed to video memory via a circular buffer in main memory. When video memory is saturated, physical property-aware video memory page replacement is performed based on stress gradient scalar weights. Based on statistical distribution, physical field scalar normalization is performed on the heterogeneous mesh data in the video memory. The perspective correction interpolation engine is called to perform pixel-level depth interpolation on the normalized coordinates and find pseudo-color textures. The depth conflict of micro-contact boundaries is handled by combining reverse depth testing and polygon offset algorithm. The three-dimensional stress cloud map of the static load of the fall arrester is rendered and output.

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

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

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

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

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

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

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

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

[0117] 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 static load calculation system for iron tower fall arresters based on finite element analysis, characterized in that, include: The finite element result data parsing and topology reconstruction module is configured to parse the heterogeneous finite element result files of the iron tower fall arrester, extract the node spatial coordinates, element topology connections and node equivalent stress scalar data, and construct the mesh topology connectivity relationship based on the half-edge data structure in memory; The high-frequency calculation module for physical quantity gradient fields is configured to perform a topological one-ring neighborhood space search based on a half-edge data structure, reconstruct and differentiate the neighborhood stress field, and calculate the three-dimensional stress gradient vector and stress gradient scalar of each node. The mesh shelling and merging module is configured to calculate the dynamic gradient threshold based on the available video memory capacity, determine the low gradient region based on the dynamic gradient threshold, perform edge folding operation on the low gradient region, and pass the stress value of the new vertex through interpolation to output a heterogeneous mesh. The view frustum intersection and video memory dynamic scheduling module is configured to build a hierarchical bounding box tree for heterogeneous meshes, remove invisible nodes, stream visible heterogeneous mesh data to video memory via a main memory ring buffer, and perform video memory page replacement. The data mapping and rendering module is configured to receive heterogeneous mesh data from video memory, perform depth interpolation on texture coordinates and find pseudo-color textures, and output a three-dimensional stress cloud map of the static load of the fall arrester.

2. The static load calculation system for tower fall arresters based on finite element analysis according to claim 1, characterized in that, In the finite element result data parsing and topology reconstruction module, the efficient reading and low-level parsing of heterogeneous finite element result files are as follows: The system initializes a data reading thread pool with asynchronous I / O capabilities; for large result files with more than one million nodes, memory-mapped file technology is used to map large files on the disk to the operating system's virtual memory address space. The parsing engine scans and locates the node spatial coordinate data segment, the unit topology connection data segment, and the node physical quantity data segment according to the preset file data block identifier; When parsing the physical quantity data segment, the system extracts three normal stress components and three shear stress components, and transforms the stress tensor into a one-dimensional equivalent stress scalar. For any node in space, its equivalent stress The calculation formula is established by the following mathematical logic: ; in, , , These represent the normal stresses at the node in the three orthogonal directions X, Y, and Z in the local coordinate system, respectively. These represent the corresponding shear stresses.

3. The static load calculation system for tower fall arresters based on finite element analysis according to claim 2, characterized in that, The complex topology reconstruction process based on a half-edge data structure is as follows: Traverse all finite element surface elements; for each polygonal facet, instantiate a half-edge object for each edge inside it in counter-clockwise order; establish a pointer binding network in the heap area of ​​memory, as follows: Each half-edge holds a memory pointer to its starting point "vertex"; a pointer to its corresponding "face"; a pointer to the next clockwise / counterclockwise "half-edge" within the same face; and a pointer to its paired half-edge that shares the same physical boundary but is in the opposite direction. Each "vertices" only needs to hold a pointer to any half of the edge that starts from the vertex; Each "face" only needs to hold a pointer to any half of the face that makes up the face; When binding paired half-edge pointers, a unique hash key is generated from the indices of the two vertices constituting the physical edge; when traversing the half-edge set, the hash key is used to... The time complexity of finding and matching twin halves is [not specified].

4. The static load calculation system for tower fall arresters based on finite element analysis according to claim 1, characterized in that, Performing a topological one-ring neighborhood space search based on a half-edge data structure includes: Based on the constructed half-edge data structure, a topological one-ring neighborhood search algorithm is executed, targeting the current central node. The system collects all pairs of matching halves by accessing any initial half of its bound edge and continuously tracking the paired half and the next half. The set of directly connected neighbor nodes ; If the mesh in the gear edge region of the fall arrester is too sparse and the topological neighborhood cannot provide enough data support, an Euclidean space range search based on a 3D KD tree is automatically triggered to forcibly obtain the K nearest neighbor nodes within the given spherical space radius as supplementary calculation points.

5. The static load calculation system for tower fall arresters based on finite element analysis according to claim 4, characterized in that, The derivation process of the meshless gradient based on the moving least squares method is as follows: For the central node In a local region, let the local approximate stress function be... : ; Where, vector These are the fitting coefficients to be solved; The system constructs a distance-weighted error functional. ; in, Neighboring nodes coordinates It is the known equivalent stress value of the neighboring nodes; It is a spatial weighting function; The error functional above has respect to the coefficients Taking the partial derivatives and setting them to zero transforms the problem into solving a system of normal equations. Solving this system yields the coefficient vector. ; At this point, the system extracts the calculation results from... Components, combined to form a central node The three-dimensional gradient vector of the stress field .

6. The static load calculation system for tower fall arresters based on finite element analysis according to claim 1, characterized in that, Dynamic gradient threshold Solution process: Get the number of bytes of available free video memory for the current graphics processor. ; The system also determines the number of bytes occupied by a single vertex in video memory based on the preset rendering data packet structure. Calculate the maximum number of safe nodes that the current GPU can smoothly render. ; The system extracts the set of stress gradient scalar values ​​for all mesh nodes. ,in ; Generate an ascending sequence of gradient scalars; Let the total number of nodes in the original finite element model be... :based on and The relationship between the two factors determines the dynamic gradient threshold. ; Determine the threshold Then, for any polygonal patch in space Extract its surface normal vector and plane equation constants ; For the vertices that make up the face Its fundamental geometric quadratic error matrix Defined as a 4×4 symmetric matrix; Traversing vertices In the half-side data structure, the fundamental error matrices of all adjacent faces are summed to obtain the vertex. The initial geometric quadratic error matrix : For any line from vertex to be folded and Composed physical edges Extract the stress gradient scalar values ​​of these two vertices. and Construct a joint error metric function .

7. The static load calculation system for tower fall arresters based on finite element analysis according to claim 6, characterized in that, Topology-safe edge folding execution logic and attribute lossless interpolation include: The system obtains information by accessing half of the data structure. One-ring neighbor node set and One-ring neighbor node set The system calculates the intersection of two sets. If a set is detected If the number of elements is not equal to 2, terminate the edge folding, remove it from the queue, and obtain the next edge; The simulation will Move to The position is determined, the normal vector of the affected patch is recalculated, and a dot product operation is performed with the original normal vector. If the dot product result is negative, the folding is rejected. After passing all security checks, the original target was... and All vertex pointers on all halves of the edge are uniformly modified to point to the newly allocated memory. The system reclaims and releases edges in the heap memory. The memory space for the face it occupies, as well as the memory space for an extra set of half-edges and vertex objects; For the new vertex equivalent stress value Extract the total area of ​​the affected polygonal faces before merging. The Gaussian inverse distance interpolation method based on patch area weighting is used to calculate... .

8. The static load calculation system for tower fall arresters based on finite element analysis according to claim 1, characterized in that, The view frustum intersection and dynamic memory scheduling module specifically includes: A bottom-up clustering algorithm and spatial cost function are used to construct a hierarchical bounding box tree for heterogeneous meshes containing polygonal patches; Extract the current observation matrix and projection matrix of the graphics pipeline to derive the view frustum boundary plane, use the separating axis theorem to calculate the directed distance from the nodes of the hierarchical bounding box tree to the boundary plane, and perform a culling test for the invisible bounding box nodes of the view frustum. Page-locked memory is allocated in the host main memory and a circular buffer is constructed. The visible heterogeneous mesh data that has passed the culling test is deconstructed into vertex attribute and index data, and then asynchronously streamed to the graphics processor's video memory buffer via the direct memory access mechanism. When the video memory capacity reaches the saturation threshold, the average stress gradient scalar value of the vertices in each candidate data block in the video memory data block linked list is calculated as the physical importance weight, and the video memory page swapping is performed on the data blocks that are inactive and have low physical importance weights.

9. The static load calculation system for tower fall arresters based on finite element analysis according to claim 1, characterized in that, The specific execution steps of the data mapping and rendering module include: The visible heterogeneous mesh data is scanned by a parallel reduction algorithm to obtain the mean and standard deviation of the local stress distribution in order to calculate the upper and lower limits of the dynamic limiting mapping. The equivalent stress scalar of each vertex is nonlinearly normalized based on the upper and lower limits to generate one-dimensional texture coordinates. During the rasterization stage of the graphics pipeline, the screen space centroid coordinates of the pixel fragments inside the polygon are obtained, and the perspective correction interpolation engine is called to perform non-linear depth interpolation on the one-dimensional texture coordinates. Based on this, the pre-mounted pseudo-color gradient texture in the video memory is searched to extract the high-precision color vector. For the microscopic coplanar contact area between the fall arrestor and the tower track, a reverse depth test is activated in the underlying rendering state machine to reverse the depth mapping interval. Based on the polygon offset algorithm, a dynamic depth offset is calculated according to the slope scaling factor of the depth gradient to participate in the depth test, so as to eliminate depth conflict flicker at the coplanar interface. Subpixel-level coverage-weighted smoothing is applied to the pixels at the edges of the small patch, and the front and rear frame buffers of the double-buffered swap chain are swapped when a vertical blank backtracking pulse signal is detected, outputting a three-dimensional stress cloud map of the static load of the fall arrester.

10. A method for calculating the static load of a tower fall arrester based on finite element analysis, and a system for calculating the static load of a tower fall arrester based on finite element analysis according to any one of claims 1-9, characterized in that, include: The heterogeneous finite element result file is parsed, the nodal spatial coordinates and stress data are extracted and converted into equivalent stress scalars, and the mesh topology connectivity based on the half-edge data structure is constructed in memory. Based on the mesh topology connectivity, the local neighborhood set of each node is obtained, and the three-dimensional stress gradient vector and stress gradient scalar of each node are solved. Calculate the dynamic gradient threshold based on the available video memory capacity, identify regions where the stress gradient scalar is below the threshold as low gradient regions, perform topology-safe edge folding and stress property interpolation on low gradient regions, and generate heterogeneous meshes. A hierarchical bounding box tree is constructed for the heterogeneous mesh. Invisible nodes are eliminated by performing an intersection test with the current view frustum. The visible heterogeneous mesh data is then asynchronously streamed to the video memory via a circular buffer in main memory. Physical field scalar normalization is performed on the heterogeneous mesh data in the video memory. The perspective correction interpolation engine is called to perform pixel-level depth interpolation on the normalized coordinates and find pseudo-color textures. Depth conflicts at micro-contact boundaries are handled, and a three-dimensional stress cloud map of the static load of the fall arrester is rendered and output.

Images