A rapid modeling method for large-size composite material structures with varying thickness solid meshes based on yarn model

Abstract

This invention discloses a rapid modeling method for large-size composite structures with variable thickness solid meshes based on a yarn model, belonging to the field of finite element modeling of fiber-reinforced composite materials. Its core process includes: for a large-size component S to be analyzed, generating yarn models for each ply partition using composite material design software and batch-dividing triangular meshes; similarly, extracting smooth surface profiles from the three-dimensional geometry of the overall component S and generating a structured shell mesh as the base carrier; then, using a voxel hash-accelerated spatial Boolean intersection algorithm to automatically identify the element sets of each ply partition between each yarn mesh and the overall shell mesh, generating a stepped solid mesh through normal offset, ensuring interface compatibility through node merging, and finally assigning material properties and generating an analysis model that can be directly submitted for solution. This invention significantly reduces manual workload and error risk, providing an efficient and reliable preprocessing solution for the curing deformation and strength analysis of composite material structures.

Description

Technical Field

[0001] This invention belongs to the field of finite element modeling of fiber-reinforced composite materials, specifically involving a rapid modeling method for large-size composite material structures with variable thickness solid mesh based on a yarn model. Background Technology

[0002] Fiber-reinforced composites have been widely used in large-scale load-bearing structures in aerospace applications (such as wings and fuselage panels) due to their excellent specific strength and specific stiffness. To meet the requirements of lightweighting and performance, these structures typically employ complex variable thickness and delamination designs.

[0003] When performing solidification deformation and strength analyses using finite element software such as Abaqus, constructing a solid mesh model that balances accuracy and modeling efficiency is a key prerequisite for ensuring the reliability of simulation analysis of large-scale structures.

[0004] Currently, creating such variable-thickness solid meshes in Abaqus largely relies on manual processes: typically, the geometry is first divided into numerous partitions in CAD software to describe the layer loss boundaries, then the partitioned geometry is imported into CAE software, hexahedral meshes are generated for each partition, and mesh topology and node compatibility are ensured at the partition interfaces.

[0005] For large structures containing dozens or even hundreds of partitions, the above process has a significant bottleneck:

[0006] First, geometric partitioning is time-consuming and error-prone. Manual handling of complex layer loss boundaries can easily introduce inconsistencies and lead to high costs for subsequent modifications. Second, the automation level of structured hexahedral mesh generation is low. Mesh generation requires cutting the entity according to the layer loss boundaries, resulting in low overall efficiency, which has become an important factor restricting the simulation efficiency of large-size structures.

[0007] Therefore, there is an urgent need for a modeling method that can directly, quickly, and automatically generate variable-thickness solid meshes for analysis based on design models. Summary of the Invention

[0008] To address the aforementioned issues, this invention proposes a rapid modeling method for large-size composite material structures with variable thickness solid meshes based on a yarn model. By using the yarn model representing the shape and position of each layup in the composite material layup design as the driving source, and through automated data processing and mesh operation processes, a variable thickness solid mesh with coordinated nodes is directly generated in the Abaqus environment. This avoids tedious manual geometric partitioning and mesh generation, greatly improving preprocessing efficiency.

[0009] This invention presents a rapid modeling method for large-size composite material structures with variable thickness solid meshes based on a yarn model. The steps are as follows:

[0010] Step 1: Using the composite material design software CATIA CPD, the large component S to be analyzed is divided into several yarn geometric models in STEP format. Each yarn geometric model corresponds to a layup partition, and the models are imported into the Abaqus / CAE environment in batches.

[0011] Step 2: Use a Python script to call the Abaqus / CAE kernel to automatically divide each yarn geometric model into triangular mesh units, generate a surface mesh for spatial positioning, and export the surface mesh .inp file;

[0012] The element size of the triangular mesh is adjusted and set according to the actual size of the component S to be analyzed, and each triangular mesh element has three nodes;

[0013] Step 3: Using Abaqus / CAE software, extract the smooth surface profile of the overall three-dimensional geometry of the component S to be analyzed, perform continuous structured shell element meshing, and export the overall shell mesh .inp file as the base carrier;

[0014] The element size of the structured shell element is adjusted according to the size of the structure S. Each structured shell element mesh is quadrilateral and has four nodes.

[0015] Step 4: Call the Abaqus kernel via Python script, and use the spatial Boolean intersection algorithm accelerated by voxel hashing to perform cell-level intersection operation on the surface mesh of each ply partition and the global shell mesh. Automatically identify the global shell mesh cells and nodes covered by each ply partition, and generate a cell set that corresponds one-to-one with the ply partition.

[0016] The specific process is as follows:

[0017] Step 401: Calculate the voxel coordinates of each node within the overall shell mesh A.

[0018] For nodes in A Its voxel coordinates The calculation formula is:

[0019]

[0020]

[0021]

[0022] in, The voxel size is determined based on the size of the overall mesh A cell;

[0023] Step 402: Binn nodes according to voxel coordinates, and put nodes with the same voxel coordinates into one bin;

[0024] Step 403: Establish a fast search structure for each box;

[0025] voxel coordinates The index structure built for the bins is as follows:

[0026]

[0027] in It is located in voxel coordinates All node IDs within;

[0028] Step 404: Combine the voxel coordinates of each bin with the index structure to construct a hash table;

[0029] The hash table format is: {(voxel coordinates): [IDs of all nodes within this voxel]};

[0030] Step 405: For each surface mesh node of layup partition B, calculate its voxel coordinates according to the voxel calculation formula, and then calculate the spatial search radius. Determine the range of voxels to be retrieved for each node from the hash table;

[0031] Surface mesh nodes The voxel coordinates are ;

[0032] First, the number of search levels is calculated as follows:

[0033]

[0034] Then, the set of voxel ranges to be searched is calculated as follows:

[0035]

[0036] Step 406: For each surface mesh node of the layup partition B, perform distance determination on all the global shell mesh nodes contained in the voxels within its search range, and perform intersection calculation with the global shell mesh nodes that satisfy the distance determination to find the global shell mesh node subset corresponding to each surface mesh node.

[0037] The global shell mesh nodes in the voxel range are Surface mesh nodes are The distance is determined as follows:

[0038]

[0039] For surface mesh nodes Its overall shell mesh node subset for:

[0040]

[0041] Step 407: For each surface mesh node of ply partition B, perform intersection calculations to obtain their respective node subsets, and integrate them to obtain the node set of ply partition B. ;

[0042]

[0043] This represents the total number of surface mesh nodes in ply partition B; it also represents the subset of all surface mesh nodes in the ply partition that were retrieved during the traversal.

[0044] Step 408: Based on all structured shell elements within the overall shell mesh A, determine whether the coordinates of the four nodes of each structured shell element are located within the node set of the ply partition B. If yes, keep it; otherwise, delete it.

[0045] Step 409: Assemble all the structured shell elements within the retained overall shell mesh A into the element set corresponding to the layup partition B;

[0046] Let the element connection relationship of the integral shell mesh A be as follows: ,in It is a collection of multiple node IDs contained in this unit.

[0047] Each element in mesh A is a 4-node shell element. ,like , making If the selected element is selected, the final result is the set of elements in the overall shell mesh A corresponding to the layup partition B.

[0048] By performing the above steps for each ply partition, the overall shell mesh cell set covered by each ply partition can be obtained.

[0049] Step 5: For each set of elements in each layer partition, perform an OFFSET operation along the shell element normal to generate a "step-like" solid mesh block with three-dimensional thickness;

[0050] The number of offset layers is automatically read from the layup table, and the offset accuracy is controlled within 0.01 mm.

[0051] Step 6: Generate a coordinated solid mesh by performing a MERGE operation on the step-intersection nodes of solid mesh blocks in adjacent plies;

[0052] The criterion for merging nodes is the number of nodes. and Spatial deviation ≤ maximum layer thickness ;

[0053]

[0054] Merged node coordinates ( The calculation formula is:

[0055]

[0056]

[0057]

[0058] Step 7: Use the composite layup function of Abaqus software to assign material properties to each ply partition, and define a discrete material coordinate system according to the curvature of component S to generate an analysis model containing complete material properties, ply direction and ply partition.

[0059] The material orientation of component S tracks its curvature change through the discrete material coordinate system. The principal material orientation of the discrete material coordinate system is determined based on the principal material orientation of component S, and the normal orientation of the discrete material coordinate system is determined based on the element normal vector of the corresponding element of component S.

[0060] Step 8: Submit the analysis model to the Abaqus solver for solidification deformation and strength simulation calculations.

[0061] The advantages of this invention are:

[0062] Compared to existing technologies, this invention uses a yarn geometric model as the driving source for the ply shape and position. In the Abaqus environment, through scripted processes such as intersection identification, normal offset solidification, and interface node merging, it automatically generates a variable-thickness solid mesh with node coordination and its corresponding ply partitions directly from the design model. This eliminates the need for tedious CAD geometric segmentation and manual hexahedral mesh generation for large-size, multi-partition, and layered structures. Even if the structure contains dozens to hundreds of partitions, it can still achieve rapid modeling and consistent output through batch import and automated processing. This effectively solves the modeling problem of large-size, multi-partition, and variable-thickness structures, significantly reduces manual workload and error risk, and improves the preprocessing efficiency, model repeatability, and maintainability for the analysis of curing deformation and strength of large-size composite material structures. Attached Figure Description

[0063] Figure 1 This is a flowchart of the rapid modeling method for large-size composite material structures with variable thickness solid mesh based on a yarn model, according to the present invention.

[0064] Figure 2 This is a digital model of the large-size wing structure made of composite materials according to the present invention.

[0065] Figure 3 This is a schematic diagram of the yarn sheet model of the present invention.

[0066] Figure 4 This is a schematic diagram of the mesh of the yarn sheet shell of the present invention.

[0067] Figure 5 The wing of this invention has an overall smooth surface profile.

[0068] Figure 6 This is a schematic diagram of the base shell mesh of the present invention.

[0069] Figure 7 This is a schematic diagram of the stepped solid mesh block of the present invention.

[0070] Figure 8 This is a schematic diagram of the variable thickness solid mesh after coordination according to the present invention.

[0071] Figure 9 This is a schematic diagram of the final analytical model of the present invention, which includes material properties.

[0072] Figure 10 This is a schematic diagram illustrating how the normal direction of the discrete material coordinate system of the present invention is determined based on the element normal vector of the element corresponding to component S. Detailed Implementation

[0073] The present invention will now be described in further detail with reference to the accompanying drawings and specific embodiments.

[0074] This invention discloses a rapid modeling method for large-size composite material structures with variable thickness solid mesh based on a yarn model. It is applicable to large-size main load-bearing structures in aerospace such as aircraft wings and fuselage panels, and is used for automated modeling of large-size, multi-zone variable thickness composite material structures with variable thickness solid mesh. Addressing the bottlenecks of existing technologies that rely on manual geometric partitioning and zone-by-zone mesh generation, which are inefficient and prone to errors, this invention uses a yarn model of composite material layup design as the driving source and achieves fully automated modeling in the Abaqus environment through Python scripts.

[0075] Its core process includes: batch importing STEP format yarn geometric models and generating triangular meshes, while constructing an overall substrate shell mesh, using a voxel hash-accelerated spatial Boolean intersection algorithm to automatically identify the unit set corresponding to the ply partition, generating a stepped solid mesh by offsetting the normal direction OFFSET, ensuring interface consistency by merging nodes through MERGE, and finally assigning material properties and generating an analysis model that can be directly submitted for solution.

[0076] like Figure 1 As shown, the specific steps are as follows:

[0077] Step 1: Using the composite material design software CATIA CPD, the large component S to be analyzed is divided into several yarn geometric models in STEP format. Each yarn geometric model corresponds to a layup partition, and the models are imported into the Abaqus / CAE environment in batches.

[0078] The yarn geometric model represents the actual shape and spatial position of each layer; the yarn geometric model is a STEP format file generated by CATIACPD software, and the imported geometric tolerance is controlled within 1e-6 m.

[0079] Step 2: Use a Python script to call the Abaqus / CAE kernel to automatically divide each yarn geometric model into triangular mesh units, generate a surface mesh for spatial positioning, and export the surface mesh in .inp format.

[0080] The unit size of the triangular mesh is adaptively adjusted according to the actual size of the component S to be analyzed. Each triangular mesh unit has three nodes; the planar contour and spatial orientation of the ply are accurately recorded.

[0081] Step 3: Using Abaqus / CAE software, extract the smooth surface profile of the overall 3D geometry of the component S to be analyzed, perform continuous structured shell element meshing (without considering internal layer loss details), and export the overall shell mesh .inp file as the base carrier;

[0082] The element size of the structured shell element is adjusted according to the size of the structure S. Each structured shell element mesh is quadrilateral and has four nodes.

[0083] Step 4: Call the Abaqus kernel via Python script, and use the spatial Boolean intersection algorithm accelerated by voxel hashing to perform cell-level intersection operations on the triangular mesh cells and structured shell cells of each ply partition. Automatically identify the overall shell mesh cells and nodes covered by each ply partition, and generate a cell set that corresponds one-to-one with the ply partition.

[0084] The specific process is as follows:

[0085] Step 401: Calculate the voxel coordinates of each node within the overall shell mesh A.

[0086] For nodes in A Its voxel coordinates The calculation formula is:

[0087]

[0088]

[0089]

[0090] in, The voxel size is determined based on the size of the overall mesh A cell;

[0091] Step 402: Binn nodes according to voxel coordinates, and put nodes with the same voxel coordinates into one bin;

[0092] Step 403: Establish a fast search structure for each box;

[0093] voxel coordinates The index structure built for the bins is as follows:

[0094]

[0095] in It is located in voxel coordinates All node IDs within;

[0096] Step 404: Combine the voxel coordinates of each bin with the index structure to construct a hash table;

[0097] The hash table format is: {(voxel coordinates): [IDs of all nodes within this voxel]};

[0098] Step 405: For each surface mesh node of layup partition B, calculate its voxel coordinates according to the voxel calculation formula, and then calculate the spatial search radius. Determine the range of voxels to be retrieved for each node from the hash table;

[0099] Surface mesh nodes The voxel coordinates are ;

[0100] First, the number of search levels is calculated as follows:

[0101]

[0102] Then, the set of voxel ranges to be searched is calculated as follows:

[0103]

[0104] Step 406: For each surface mesh node of the layup partition B, perform distance determination on all the global shell mesh nodes contained in the voxels within its search range, and perform intersection calculation with the global shell mesh nodes that satisfy the distance determination to find the global shell mesh node subset corresponding to each surface mesh node.

[0105] The global shell mesh nodes in the voxel range are Surface mesh nodes are The distance is determined as follows:

[0106]

[0107] For surface mesh nodes Its overall shell mesh node subset for:

[0108]

[0109] Step 407: For each surface mesh node of ply partition B, perform intersection calculations to obtain their respective node subsets, and integrate them to obtain the node set of ply partition B. ;

[0110]

[0111] This represents the total number of surface mesh nodes in ply partition B; it also represents the subset of all surface mesh nodes in the ply partition that were retrieved during the traversal.

[0112] Step 408: Based on all structured shell elements within the overall shell mesh A, determine whether the coordinates of the four nodes of each structured shell element are located within the node set of the ply partition B. If yes, keep it; otherwise, delete it.

[0113] Step 409: Assemble all the structured shell elements within the retained overall shell mesh A into the element set corresponding to the layup partition B;

[0114] Let the element connection relationship of the integral shell mesh A be as follows: ,in It is a collection of multiple node IDs contained in this unit.

[0115] Each element in mesh A is a 4-node shell element. ,like , making If the selected element is selected, the final result is the set of elements in the overall shell mesh A corresponding to the layup partition B.

[0116] By performing the above steps for each ply partition, the overall shell mesh cell set covered by each ply partition can be obtained.

[0117] Step 5: For each set of elements in each ply section, perform an OFFSET operation along the shell element normal (thickness direction) to generate a "step-like" solid mesh block with three-dimensional thickness, thereby achieving a direct mapping of the thickness of each ply section.

[0118] The number of offset layers is automatically read from the layup table, and the offset accuracy is controlled within 0.01 mm, enabling direct mapping of variable thickness designs.

[0119] Step 6: Use a script to perform a MERGE operation on the nodes at the step boundaries of adjacent ply solid mesh blocks to generate a coordinated solid mesh;

[0120] The MERGE operation uses a node coordinate tolerance matching algorithm (tolerance set to the maximum layer thickness) to automatically merge gradient nodes, ensuring mesh continuity and mechanical compatibility at different layup interfaces.

[0121] The criterion for merging nodes is the number of nodes. and Spatial deviation ≤ maximum layer thickness ;

[0122]

[0123] Merged node coordinates ( The calculation formula is:

[0124]

[0125]

[0126]

[0127] Step 7: Use the composite layup function of Abaqus software to assign material properties to each ply partition, and define a discrete material coordinate system according to the curvature of component S to generate an analysis model containing complete material properties, ply direction and ply partition.

[0128] The material orientation of component S tracks its curvature change through the discrete material coordinate system. The principal material orientation of the discrete material coordinate system is determined based on the principal material orientation of component S, and the normal orientation of the discrete material coordinate system is determined based on the element normal vector of the corresponding element of component S.

[0129] Step 8: Submit the analysis model to the Abaqus solver for solidification deformation and strength simulation calculations.

[0130] Example:

[0131] This invention uses Abaqus to create variable thickness solid meshes for large-size composite material structures. The modeling process is as follows: Figure 1 As shown, the specific steps are as follows:

[0132] Step 1: Taking the wing structure shown in Figure 2 as an example, automatically export the CATIA-generated gauze surface model (e.g., ...) using a script. Figure 3 (As shown) is in STEP format and is imported in batches into Abaqus / CAE to ensure that the yarn geometry is completely consistent with the design;

[0133] Step 2: Record a script using Abaqus macros to batch divide each yarn surface into triangular meshes (unit size 100 mm), generating... Figure 4 The mesh of the gauze shell shown is exported as a .inp file;

[0134] Step 3: Extract the smooth surface profile of the overall three-dimensional geometry of the wing, such as... Figure 5 As shown, a structured shell element mesh (element size 100mm) is generated to produce the base shell mesh shown in Figure 6, and then exported as a .inp file;

[0135] Step 4: Call the voxel hash-accelerated spatial intersection algorithm to perform element-level intersection between the yarn shell mesh and the substrate shell mesh, automatically identify the substrate shell element set corresponding to each yarn, and generate an element set that corresponds one-to-one with the designed layup;

[0136] Step 5: For the unit set of each ply partition, perform an OFFSET operation along the normal direction (the number of offset layers is read from the ply table) to generate the "step-like" solid mesh block shown in Figure 7, realizing the direct mapping of variable thickness design;

[0137] Step 6: Perform the MERGE operation on the nodes at the intersection of adjacent ply mesh blocks to generate the coordinated solid mesh shown in Figure 8, ensuring the mechanical continuity of the ply interface;

[0138] Step 7: Read the ply table, assign material properties to each ply partition using the composite layup function, and define a discrete material coordinate system based on the wing curvature to generate the analysis model with complete properties shown in Figure 9;

[0139] The normal direction of the discrete material coordinate system is determined based on the element normal vector of the element corresponding to component S, such as... Figure 10 As shown.

[0140] Step 8: The final generated analysis model can be directly submitted to the Abaqus solver for simulation calculations of solidification deformation, strength, etc.

[0141] Through the above steps, rapid modeling of large-size composite material structures with varying thickness solid meshes based on the yarn model was achieved.

[0142] The preferred embodiments of the present invention have been described in detail above with reference to the accompanying drawings. It should be noted that the scope of protection of the present invention is not limited to the specific details in the above embodiments. For those skilled in the art, they can still modify the technical solutions described in the foregoing examples or make equivalent substitutions for some of the technical features. However, any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A rapid modeling method for large-size composite material structures with variable thickness solid meshes based on a yarn model, characterized in that, The steps are as follows: Step 1: Using the composite material design software CATIA CPD, the large component S to be analyzed is divided into several yarn geometric models. Each yarn geometric model corresponds to a layup partition, and the models are imported into the Abaqus / CAE environment in batches. Step 2: Use a Python script to call the Abaqus / CAE kernel to automatically divide each yarn geometric model into triangular mesh units, generate a surface mesh for spatial positioning, and export the surface mesh .inp file; Each triangular mesh cell has three nodes; Step 3: Using Abaqus / CAE software, extract the smooth surface profile of the overall three-dimensional geometry of the component S to be analyzed, perform continuous structured shell element meshing, and export the overall shell mesh .inp file as the base carrier; Each structured shell cell mesh uses a quadrilateral shape and has four nodes; Step 4: Call the Abaqus kernel through a Python script, and use the spatial Boolean intersection algorithm accelerated by voxel hashing to perform cell-level intersection operations on triangular mesh cells and structured shell cells. Automatically identify the structured shell cells and nodes covered by each ply partition, and generate a cell set that corresponds one-to-one with the ply partition. The specific process is as follows: Step 401: Calculate the voxel coordinates of each node within the overall shell mesh A. For nodes in A Its voxel coordinates The calculation formula is: in, The voxel dimensions are determined based on the dimensions of the elements in the overall shell mesh A. Step 402: Binn nodes according to voxel coordinates, and put nodes with the same voxel coordinates into one bin; Step 403: Establish a fast index structure for each box; voxel coordinates The index structure built by binning is as follows: in It is located in voxel coordinates All node IDs within; Step 404: Combine the voxel coordinates of each bin with the index structure to construct a hash table; The hash table format is: {(voxel coordinates): [IDs of all nodes within this voxel]} Step 405: For each node within the surface mesh of layup partition B, calculate its voxel coordinates according to the voxel calculation formula, and then calculate the coordinates based on the spatial search radius. Determine the range of voxels to be retrieved for each node from the hash table; Nodes of surface mesh The voxel coordinates are ; First, the number of search levels is calculated as follows: Then, the set of voxel ranges to be searched is calculated as follows: Step 406: For each node of the surface mesh of the layup partition B, perform distance determination on all nodes in the overall shell mesh contained in the voxels within the search range, and perform intersection calculation with the nodes in the overall shell mesh that satisfy the distance determination to find the node subset of the overall shell mesh corresponding to each node in the surface mesh. The lattice nodes of the global shell mesh in the voxel range are The nodes of the surface mesh are The distance is determined as follows: For nodes of the surface mesh The set of nodes of its overall shell mesh for: Step 407: For each node of the surface mesh in layup partition B, perform intersection calculations to obtain the node subset of the global shell mesh for each node, and integrate them to obtain the node set of layup partition B. ; This represents the total number of nodes within the surface mesh of ply partition B; it also represents the subset of all nodes corresponding to the surface mesh of the ply partition that were traversed and retrieved. Step 408: Based on all structured shell elements within the overall shell mesh A, determine whether the coordinates of the four nodes of each structured shell element and their corresponding connectivity are located within the node set of the layup partition B. If yes, keep it; otherwise, delete it. Step 409: Assemble all the structured shell elements within the retained overall shell mesh A into the element set corresponding to the layup partition B; Step 5: For each set of elements in each layer partition, perform an OFFSET operation along the shell element normal to generate a "stepped" solid mesh block with three-dimensional thickness; Step 6: Generate a coordinated solid mesh by performing a MERGE operation on the step-intersection nodes of adjacent ply solid mesh blocks; Step 7: Use the composite layup function of Abaqus software to assign material properties to each ply partition, and define a discrete material coordinate system according to the curvature of component S to generate an analysis model containing complete material properties, ply direction and ply partition. Step 8: Submit the analysis model to the Abaqus solver for solidification deformation and strength simulation calculations.

2. The method according to claim 1, characterized in that, The geometric model of the yarn sheet mentioned in step 1 is a STEP format file.

3. The method according to claim 1, characterized in that: The element size of the triangular mesh described in step 2 is adaptively adjusted according to the actual size of the component S to be analyzed.

4. The method according to claim 1, characterized in that: In step 3, the element size of the structured shell unit is adjusted and set according to the size of component S.

5. The method according to claim 1, characterized in that: The number of offset layers in the OFFSET operation described in step 5 is automatically read from the layup table, and the offset accuracy is controlled within 0.01 mm, realizing direct mapping of variable thickness design.

6. The method according to claim 1, characterized in that: The MERGE operation described in step 6 uses a node coordinate tolerance matching algorithm, with the tolerance set to the maximum lost layer thickness to ensure the mechanical continuity of the layup interface.

7. The method according to claim 1, characterized in that: In step 7, the material orientation of component S is tracked by the curvature change of itself through the discrete material coordinate system to ensure that the ply orientation is completely consistent with the design; the principal material orientation of the discrete material coordinate system is determined based on the principal material orientation of component S, and the normal orientation of the discrete material coordinate system is determined based on the element normal vector of the corresponding element of component S.

Images