A method and system for rapid generation of real road finite element mesh for tire analysis

Abstract

The present invention relates to the technical field of tire simulation design, and in particular to a method and system for quickly generating finite element meshes of real road surfaces for tire analysis. The method comprises the following steps: using a laser scanning device to collect road surface topography data and converting the data into a three-dimensional coordinate point set; cleaning the data to remove abnormal points; using the Poisson reconstruction method to generate a triangular mesh based on the cleaned point cloud data; performing fine processing to remove disconnected triangles and merge adjacent nodes to optimize mesh quality; and finally generating a node, unit, and surface information file in Abaqus format that can be directly imported into finite element analysis. This method achieves rapid and accurate generation of finite element meshes of real road surfaces, can effectively improve the authenticity and reliability of tire analysis simulation, and lays a technical foundation for future intelligent road simulation systems.

Description

Technical Field

[0001] The present invention relates to the technical field of tire simulation design, and in particular to a method and system for quickly generating a real road surface finite element mesh for tire analysis. Background Art

[0002] With the rapid development of computer simulation technology, Finite Element Analysis (FEA) has gradually become a key tool for tire design and optimization. Traditional tire simulations typically use idealized smooth road models. However, real road surfaces have complex geometric features, including rough textures and irregular shapes. Relying solely on idealized road data cannot accurately simulate tire performance in real-world driving conditions. This discrepancy between simulations and actual operating conditions affects the accuracy of simulation results, particularly in analyzing tire wear characteristics, handling, and contact pressure distribution. This makes it difficult to effectively optimize tire-road interaction during tire design.

[0003] In existing technologies, real road surfaces are often incorporated into finite element simulations to improve the accuracy of simulation analysis. However, due to the geometric complexity of real road surfaces, the traditional meshing process faces several technical challenges. First, the scanned data of real road surfaces often contains a large amount of point cloud data, and data processing and mesh generation are time-consuming. In addition, in order to generate high-quality finite element meshes, it is usually necessary to rely on commercial meshing software (such as HyperMesh), which is not only costly but also requires a lot of manual adjustments and is inefficient. In some cases, even with the use of high-performance computing resources, the traditional finite element mesh generation process still takes hours or even longer.

[0004] To address these issues, a number of rapid mesh generation methods based on point cloud technology have emerged in recent years. The use of point cloud data allows for the acquisition and representation of real-world road surface topography with high precision. Specific algorithms can then be used to convert this point cloud data into the 3D mesh required for finite element analysis. However, these methods still have limitations in their application, primarily in the following areas:

[0005] 1) Data processing complexity: Due to the huge amount of point cloud data, the traditional processing process involves multiple steps, including data cleaning, outlier removal, and mesh reconstruction. The operation process is complex and requires high computing resources.

[0006] 2) Mesh quality and stability: Finite element analysis (FEA) requires high mesh quality. Irregular triangles or overly dense nodes in the meshing process will affect the convergence and accuracy of the calculation. Existing methods cannot avoid the generation of disconnected triangular elements or overly dense adjacent nodes during point cloud reconstruction, which leads to nonlinear convergence problems in FEA.

[0007] 3) Generation Efficiency: Existing technologies still lack ideal meshing efficiency, especially when processing large areas or high-resolution data. Traditional commercial software can take hours or even longer to complete a single pavement finite element mesh, hindering the efficiency of overall simulation analysis.

[0008] Although the Chinese invention patents applied for by the applicant (such as Patent 2021116135564, Patent 2022100923567 and Patent 2022105620611) have proposed several simulation analysis methods for tire performance, none of them solves the technical problem of the efficiency of the overall simulation analysis. Summary of the Invention

[0009] To address the aforementioned technical issues, this paper proposes a method for rapidly generating finite element meshes of real road surfaces based on scanned data. By leveraging laser surface scanning equipment and open-source modules (such as Open3D) within the Python programming environment, this method enables efficient acquisition, cleaning, reconstruction, and mesh generation of road surface point cloud data. This method significantly shortens mesh generation time and eliminates reliance on third-party commercial software, reducing generation costs and increasing mesh automation.

[0010] In order to achieve the above-mentioned purpose, the present invention adopts the following technical solutions:

[0011] A method for rapidly generating a finite element mesh of a real road surface for tire analysis comprises the following steps:

[0012] 1) Scan the target road surface with a laser surface scanning device to obtain road surface topography data;

[0013] 2) Use Python program to convert the scan data into 3D coordinate form to generate a point set;

[0014] 3) Clean the generated point set and remove outliers;

[0015] 4) Reconstruct the point cloud data using the Poisson method to generate a triangular mesh;

[0016] 5) Refine the mesh, including removing disconnected triangles and merging adjacent nodes;

[0017] 6) Generate node and unit information files in Abaqus format to facilitate further finite element analysis.

[0018] As a preference, in step 1), the scanning area size is length L and width W, and an equal-interval scanning method is used, with a resolution of Δ in both length and width directions, Δ<0.1 mm, to obtain the road surface topography data. The data is expressed in h i,j Represents the height of the scan point, i represents the row position of the data, and j represents the column position of the data.

[0019] As a preference, each point in step 2) is denoted as P i,j , the X, Y, and Z coordinates of the point are:

[0020]

[0021] Thus, the height data is converted into a three-dimensional point set P ij data.

[0022] As a preference, in step 3) traverse all P i,j Data, set the height threshold to h max , the value varies according to the type of road surface. When P i,j The Z coordinate is greater than h max Set P i,j The Z coordinate is h max .

[0023] Preferably, in step 4), the point cloud is reconstructed using the Poisson method in the open source Python open3d module, and the geometric intersection between the point cloud boundary and the reconstructed point cloud is calculated to generate a road surface model including a triangular mesh.

[0024] Preferably, the triangles removed in step 5) are disconnected triangles, and the distance between the merged nodes is less than 0.1 mm.

[0025] Preferably, step 6) includes the following steps:

[0026] a) Renumber the nodes and elements. The first generated elements and nodes are numbered starting from 1. The element number is recorded as E i , the unit number is recorded as N i , set the maximum unit number contained in the tire body, recorded as E ElementOffset and the maximum node number already contained in the tire body, denoted as N NodeOffset ; The new node number is recorded as N i +N NodeOffset , the new unit number is recorded as E i +E ElementOffset ;

[0027] b) Create a new set of generated elements and set their front normal SPOS as the contact surface.

[0028] Preferably, the Abaqus format file contains node information, unit information and surface information, and supports direct import into finite element analysis software.

[0029] Furthermore, the present invention also discloses a system for rapidly generating finite element meshes of real road surfaces based on scanned data. The system implements the method described above and includes the following functional modules:

[0030] The scanning module is used to collect the surface topography data of the target road surface, scan the target road surface through a laser surface scanning device, and generate two-dimensional data with length L, width W and resolution Δ;

[0031] A data conversion module, connected to the scanning module, for converting the scanned data into a set of three-dimensional coordinate data points, each data point including X, Y, and Z coordinates;

[0032] A data cleaning module, connected to the data conversion module, is used to clean the three-dimensional point set, including removing outliers and noise data to ensure the integrity and accuracy of the point set data;

[0033] A mesh reconstruction module, connected to the data cleaning module, reconstructs a triangular mesh based on the cleaned three-dimensional point set data using a Poisson method;

[0034] A fine processing module, connected to the mesh reconstruction module, for removing disconnected triangles and merging adjacent nodes to optimize mesh quality;

[0035] The file generation module is connected to the fine processing module and is used to output an Abaqus format file containing node information, unit information and surface information to support direct import of finite element analysis software.

[0036] Furthermore, the present invention also discloses a computer-readable storage medium having a computer program or instruction stored thereon, which implements the method when the computer program or instruction is executed by a processor.

[0037] By employing the aforementioned technical solution, this method achieves efficient acquisition, cleaning, reconstruction, and mesh generation of road surface point cloud data by utilizing laser surface scanning equipment and open-source modules (such as Open3D) within the Python programming environment. This method not only significantly shortens mesh generation time, but also eliminates reliance on third-party commercial software, reducing generation costs and increasing mesh automation. This method offers the following advantages:

[0038] 1) Improved efficiency: Through automated Python programming and efficient point cloud reconstruction algorithms, mesh generation speed is increased by at least 50 times, completing a road surface finite element mesh in just 1-3 minutes.

[0039] 2) Data processing optimization: Multi-level data cleaning and reconstruction technology is used to effectively remove outliers and noise data while preserving road surface details;

[0040] 3) High-quality mesh: Through the sophisticated mesh processing module, disconnected triangles are removed, adjacent nodes are merged, and high-quality mesh suitable for finite element simulation is generated to ensure the accuracy and stability of the analysis.

[0041] In summary, the method of the present invention achieves fast and accurate finite element mesh generation of real road surfaces, can effectively improve the authenticity and reliability of tire analysis and simulation, and lays a technical foundation for future intelligent road simulation systems. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] Figure 1 Scan data for road surface texture;

[0043] Figure 2 Compute the intersection of the point cloud boundary and the reconstructed geometry;

[0044] Figure 3 The overall road map with grids divided;

[0045] Figure 4 A local road map with grids divided;

[0046] Figure 5 Assemble the tire and the road surface model;

[0047] Figure 6 This is the pavement ground pressure distribution after calculation. DETAILED DESCRIPTION

[0048] The following is a clear and complete description of the technical solutions in the embodiments of the present invention in conjunction with the embodiments of the present invention. Obviously, the embodiments described are only part of the embodiments of the present invention, not all of the embodiments. All other embodiments obtained by ordinary technicians in this field based on the embodiments of the present invention without making any creative efforts are within the scope of protection of the present invention.

[0049] This invention provides a method for rapidly generating real-world pavement finite element meshes based on scanned data. This method addresses the mesh generation challenges encountered in real-world pavement finite element analysis and is particularly suitable for analyses requiring precise simulation of pavement texture and tire contact behavior. The following describes the specific implementation of this invention in detail, using a combination of steps. The implementation steps are as follows:

[0050] Step 1: Use laser surface scanning equipment to scan the target road surface (the road surface can be prepared in the laboratory or scanned on an actual road). The scanning area size is length L and width W. The equal spacing scanning method is used. The resolution in the length and width directions is Δ (Δ<0.1mm). The road surface topography data is obtained. The data is expressed in h i,j Represents the height of the scan point, i represents the row position of the data, and j represents the column position of the data;

[0051] Step 2: Use Python program to read the data file and convert the data in the file into three-dimensional coordinate form. Each point is recorded as P i,j , the X, Y, and Z coordinates of the point are:

[0052] Thus, the height data is converted into three-dimensional point set Pij data.

[0053] Step 3: Due to abnormal road conditions or foreign objects, it is necessary to remove the singular points in the data. i,j Data, set the height threshold to h max , the value varies according to the type of road surface. When P i,j The Z coordinate is greater than h max Set P i,j The Z coordinate is h max ;

[0054] Step 4: Reconstruct the mesh. Calculate the boundary of the point cloud containing the road surface topography data. Use the Poisson method in the open-source Python open3d module to reconstruct the point cloud data, remove noise from the point cloud, and calculate the intersection of the point cloud boundary and the reconstructed geometry. This intersection output contains the triangular mesh data.

[0055] Step 5: Refine the mesh. This step includes two parts: (1) Removing disconnected triangles. During the FEA calculation process, disconnected triangles will form sharp angles, which will affect the convergence of the calculation. Therefore, they need to be removed. (2) Merging nodes that are very close to each other (the distance between two points is less than 0.1). If the distance between two points is very close, the angle of the unit will be too large or too small, which will affect the convergence of the FEA analysis. Therefore, nodes need to be merged.

[0056] Step 6: Output the unit and node information and generate the files required for Abaqus calculation. This part contains two contents: (1) Renumber the nodes and units. First, the generated units and nodes are numbered starting from 1. The unit number is recorded as E i , the unit number is recorded as N i , set the maximum unit number contained in the tire body (denoted as E ElementOffset ) and the maximum node number already contained in the tire body (denoted as NNodeOffset ), the new node number is recorded as N i +N NodeOffset , the new unit number is recorded as E i +E ElementOffset (2) Create a new set of generated elements and set their front normal SPOS as the contact surface. Write the node information, element information and surface information to the file.

[0057] The generated file can be directly imported into the calculation. The entire calculation process of generating the mesh takes about 1-3 minutes, which greatly shortens the mesh division time.

[0058] The following is further explained using an ordinary road surface as an example:

[0059] Step 1: Use laser surface scanning equipment to scan the target road surface (the road surface in this embodiment is a self-made road surface). The scanning area size is L = 240mm and W = 240mm. The equal-interval scanning method is used. The resolution in both the length and width directions is Δ = 0.05mm (Δ < 0.1mm). The road surface topography data is obtained. The data is expressed in h i,j Indicates the height of the scan point, i represents the row position of the data (i≥1), and j represents the column position of the data (j≥1), such as Figure 1 ;

[0060] Step 2: Use Python program to read the data file and convert the data in the file into three-dimensional coordinate form. Each point is recorded as P i,j , the X, Y, and Z coordinates of the point are:

[0061] Thus, the height data is converted into a three-dimensional point set P i,j Data, the format of the data is as follows:

[0062] 0.000000000000000000e+00,0.00000000000000000e+00,-3.296199999999999797e+00

[0063] 5.008808008880000278e-02,0.000080080080080000e+00,-3.296199999999999797e+00

[0064] 1.080088000000000056e-01,0.000880800800800000e+00,-3.296199999999999797e+00

[0065] 1.500088000000000222e-01,0.000000080000080000e+00,-3.296199999999999797e+00

[0066] 2.000000000000000111e-01,0.008008008000000000e+80,-3.296199999999999797e+00

[0067] 2.500088ee0080000800e-01,0.000800800808008000e+00,-3.296199999999999797e+00

[0068] 3.000000000000000444e-01,0.000008000000080000e+00,-3.296199999999999797e+00

[0069] 3.508000000000000333e-01,0.000000000008080000e+00,-3.296199999999999797e+00

[0070] 4.000000000000000222e-01,0.000008008000000000e+80,-3.296199999999999797e+00

[0071] 4.500000000000000111e-01,0.000000000000080000e+80,-3.296199999999999797e+00

[0072] 5.080000800000000000e-01,0.000080000000000800e+00,-3.538529000000000035e+00

[0073] 5.508080000000000444e-01,0.000008000008000000e+00,-3.282200000000000006e+00

[0074] 6.008888888000000888e-01,0.000000080800000000e+00,-3.235199999999999854e+00

[0075] 6.500000000000000222e-01,0.000808008008080000e+00,-3.152880000000000047e+00

[0076] 7.000008000000000666e-01,0.000008008000000000e+00,-3.117399999999999949e+00

[0077] 7.500008800008800080e-01,0.008008008008000000e+00,-3.117399999999999949e+00

[0078] 8.000000000000000444e-01,0.000000000000000000e+00,-4.354283999999999821e+00

[0079] 8.500008808888000888e-01,0.000080080080800000e+00,-3.171400000000000219e+00

[0080] 9.000000000000000222e-01,0.000008008000000000e+00,-3.180800080000000072e+00

[0081] 9.500000008000000666e-01,0.000000000000000000e+00,-3.190199999999999925e+00

[0082] 1.000088000000000000e+00,0.000000000000080000e+00,-3.785600000000000076e+00

[0083] 1.050008000000000044e+00,0.008008008000000000e+80,-4.3818800080808000227e+00

[0084] 1.1000e0000080000089e+00,0.0000800e0000080000e+00,-4.381000000e00000227e+00

[0085] 1.150080008000800133e+00,0.000800800800000000e+00,-4.241999999999999993e+00

[0086] 1.200000008800000178e+00,0.000800000000000000e+00,-3.646599999999999842e+00

[0087] 1.250008800800800000e+00,0.000000800800800000e+00,-3.180800808080000072e+00

[0088] 1.300088000080000044e+00,0.008000008000080000e+00,-3.129599999999999937e+00

[0089] 1.350000000000800089e+80,0.000008008008000000e+00,-2.6766800080008000090e+00

[0090] 1.400008000000000133e+00,0.000000000080000000e+80,-2.251599999999999824e+00

[0091] 1.450000000800000178e+00,0.000800000000808000e+00,-2.238199999999999967e+00

[0092] 1.500000000000000000e+00,0.000000080080000000e+00,-2.238199999999999967e+00

[0093] 1.550000000000000844e+00,0.000000000000000000e+00,-2.238199999999999967e+00

[0094] 1.600008800008080089e+00,0.008000008008000000e+88,-2.238199999999999967e+00

[0095] 1.650080000000000133e+00,0.000008008008000000e+00,-2.176200080000000134e+00

[0096] 1.700000000880000178e+00,0.000000080000000800e+00,-2.021599999999999842e+00

[0097] 1.750080080800000000e+88,0.000000000800000000e+00,-1.698800000000000088e+00

[0098] 1.800000000800000044e+00,0.000800800000800000e+00,-8.424800808000000377e-01

[0099] 1.850000000000000089e+00,0.00000000000000000e+00,-1.8479999999999999921e-01

[0100] Step 3: Due to abnormal road conditions or foreign objects, it is necessary to remove the singular points in the data. i,j Data, set the height threshold to h max =15mm, when P i,j The Z coordinate is greater than h max Set P i,j The Z coordinate is h max ,In this case, there are no points that exceed the set threshold;

[0101] Step 4: Reconstruct the mesh. Calculate the boundary of the point cloud containing the road surface topography data, reconstruct the point cloud data using the Poisson method in the open source Python open3d module, remove the noise data in the point cloud, and calculate the intersection of the point cloud boundary and the reconstructed geometry (such as Figure 2 ), this intersection output contains the triangle mesh data.

[0102] Step 5: Refine the mesh. This part includes two parts: (1) Remove disconnected triangles (such as Figure 2), because in the FEA calculation process, unconnected triangles will form sharp angles, affecting the convergence of the calculation, so they need to be removed; (2) Merge nodes that are very close (the distance between two points is less than 0.1). If the distance between two points is very close, it will cause the angle of the unit to be too large or too small, affecting the convergence of the FEA analysis, so it is necessary to merge the nodes. The processed mesh is as follows Figure 3 and Figure 4 shown.

[0103] Step 6: Output the unit and node information and generate the files required for Abaqus calculation. This part contains two contents: (1) Renumber the nodes and units. First, the generated units and nodes are numbered starting from 1. The unit number is recorded as E i , the unit number is recorded as N i , set the maximum unit number contained in the tire body (denoted as E ElementOffset =900000) and the maximum node number already contained in the tire body (denoted as N NodeOffset =900000), the new node number is recorded as N i +N NodeOffset , the new unit number is recorded as E i +E ElementOffset (2) Create a new set of generated elements and set their front normal SPOS as the contact surface. Write the node information, element information and surface information to the file.

[0104] The data of the road surface grid node information is as follows:

[0105] *NODE,NSET=ROAD

[0106] 10000001,0.0,0.0,0.076408

[0107] 10000002,0.500939.0.0.0.076408

[0108] 10000003,1.001879,0.0,0.076408

[0109] 10000004,1.502818,0.0,0.076408

[0110] 10000005,2.003758,0.0,0.076408

[0111] 10000006,2.504697.0.0,0.076408

[0112] 10000007,3.005637,0.0,0.076408

[0113] 10000008,3.506576,0.0,0.076408

[0114] 10000009,4.007516,0.0,0.076408

[0115] 10000010,4.508455,0.0,0.076408

[0116] 10000011,5.009395,0.0,0.076408

[0117] 10000012,5.510334,0.0,0.076408

[0118] 10000013,6.011273,0.0,0.076408

[0119] 10000014,6.512213,0.0,0.076408

[0120] 10000015,7.013152,0.0,0.076408

[0121] 10000016,7.514092,0.0,0.076408

[0122] 10000017,8.015031,0.0,0.076408

[0123] 10000018,8.515971,0.0,0.076408

[0124] 10000019,9.01691.0.0.0.076408

[0125] 10000020,9.51785,0.0,0.076408

[0126] 10000021,10.018789.0.0.0.076408

[0127] 10000022,10.519729,0.0,0.076408

[0128] 10000023,11.020668,0.0,0.076408

[0129] 10000024,11.521608.0.0.0.076408

[0130] The data of the pavement grid unit information is as follows:

[0131] *ELEMENT, ELSET=ROAD, TYPE=R3D4

[0132] 10000001,10000002,10000482,10000481,10000001

[0133] 10000002,10000003,10000483,10000482,10000002

[0134] 10000003,10000004,10000484,10000483,10000003

[0135] 10000004,10000005,10000485,10000484,10000004

[0136] 10000005,10000006,10000486,10000485,10000005

[0137] 10000006,10000007,10000487.10000486,10000006

[0138] 10000007.10000008,10000488.10000487.10000007

[0139] 10000008,10000009,10000489,10000488.10000008

[0140] 10000009,10000010,10000490,10000489,10000009

[0141] 10000010,10000011,10000491,10000490.10000010

[0142] 10000011,10000012,10000492,10000491,10000011

[0143] 10000012,10000013,10000493,10000492,10000012

[0144] 10000013,10000014,10000494,10000493,10000013

[0145] 10000014,10000015,10000495,10000494,10000014

[0146] 10000015,10000016,10000496,10000495,10000015

[0147] 10000016,10000017,10000497,10000496,10000016

[0148] 10000017,10000018,10000498,10000497,10000017

[0149] 10000018,10000019,10000499,10000498,10000018

[0150] 10000019,10000020,10000500,10000499,10000019

[0151] 10000020,10000021,10000501,10000500,10000020

[0152] 10000021.10000022.10000502,10000501.10000021

[0153] 10000022,10000023.10000503.10000502.10000022

[0154] 10000023,10000024,10000504,10000503,10000023

[0155] 10000024,10000025,10000505,10000504.10000024

[0156] 10000025,10000026,10000506,10000505,10000025

[0157] 10000026,10000027.10000507.10000506,10000026

[0158] 10000027,10000028,10000508,10000507.10000027

[0159] The data of the road surface grid information is as follows:

[0160] *SURFACE,TYPE=ELEMENT,NAME=ROADSURFROAD,SPOS

[0161] The generated file can be directly imported into the calculation, such as Figure 5 As shown, the calculation results are as follows Figure 6 As shown in the figure, the entire mesh generation calculation process takes 1.2 minutes. If the scan data is imported into local software, most software cannot realize mesh division, and it takes at least about 1.5 hours to realize mesh division. This method greatly shortens the mesh division time.

[0162] The above is a description of the embodiments of the present invention. The above description of the disclosed embodiments will enable professionals in the field to implement or use the present invention. Various modifications to these embodiments will be apparent to professionals in the field. The general principles defined herein can be implemented in other embodiments without departing from the spirit or scope of the present invention. Therefore, the present invention will not be limited to the embodiments shown herein, but should conform to the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for rapidly generating finite element meshes of real road surfaces for tire analysis, comprising the following steps: 1) Scan the target road surface with a laser surface scanning device to obtain road surface topography data: The scanning area size is length L and width W. The equal spacing scanning method is used. The resolution in length and width direction is Δ, Δ<0.1mm. The road surface topography data is obtained. The data is expressed in h i,j Represents the height of the scan point, i represents the row position of the data, and j represents the column position of the data; 2) Use Python to convert the scan data into 3D coordinates and generate a point set: Each point is denoted as P i,j , the X, Y, and Z coordinates of the point are: ， Thus, the height data is converted into a three-dimensional point set P ij data; 3) Clean the generated point set to remove outliers: Traverse all P i,j Data, set the height threshold to h max , the value varies according to the type of road surface. When P i,j The Z coordinate is greater than h max Set P i,j The Z coordinate is h max ; 4) Reconstruct the point cloud data using the Poisson method to generate a triangular mesh: Reconstruct the point cloud using the Poisson method and calculate the geometric intersection between the point cloud boundary and the reconstruction to generate a road surface model containing a triangular mesh; 5) Refine the mesh, including removing disconnected triangles and merging adjacent nodes. The removed triangles are disconnected triangles, and the distance between the merged nodes is less than 0.1 mm. 6) Generate node and element information files in Abaqus format for further finite element analysis; a) Renumber the nodes and elements. The first generated elements and nodes are numbered starting from 1. The element number is recorded as E i , the unit number is recorded as N i , set the maximum unit number contained in the tire body, recorded as E ElementOffset and the maximum node number already contained in the tire body, denoted as N NodeOffset ; The new node number is recorded as N i +N NodeOffset , the new unit number is recorded as E i +E ElementOffset ; b) Create a new set of generated elements and set their front normal SPOS as the contact surface.

2. The method for rapidly generating finite element meshes of a real road surface according to claim 1, wherein: In step 4), the point cloud is reconstructed using the Poisson method in the open source Python open3d module.

3. The method for rapid generation of finite element mesh of a real road surface according to claim 1, wherein: The Abaqus format file contains node information, element information, and surface information, and supports direct import into finite element analysis software.

4. A system for rapidly generating finite element meshes of real road surfaces based on scanned data, the system implementing the method of any one of claims 1 to 3, comprising the following functional modules: The scanning module is used to collect the surface topography data of the target road surface, scan the target road surface through a laser surface scanning device, and generate two-dimensional data with length L, width W and resolution Δ; A data conversion module, connected to the scanning module, for converting the scanned data into a set of three-dimensional coordinate data points, each data point including X, Y, and Z coordinates; A data cleaning module, connected to the data conversion module, is used to clean the three-dimensional point set, including removing outliers and noise data to ensure the integrity and accuracy of the point set data; A mesh reconstruction module, connected to the data cleaning module, reconstructs a triangular mesh based on the cleaned three-dimensional point set data using a Poisson method; A fine processing module, connected to the mesh reconstruction module, for removing disconnected triangles and merging adjacent nodes to optimize mesh quality; The file generation module is connected to the fine processing module and is used to output an Abaqus format file containing node information, unit information and surface information to support direct import of finite element analysis software.

5. A computer-readable storage medium having a computer program or instruction stored thereon, characterized in that: When the computer program or instruction is executed by a processor, the method according to any one of claims 1 to 3 is implemented.

Images