Python-based parametric automatic modeling method for finite element model of mixed tower structure Abaqus

Abstract

The present application relates to the technical field of wind power steel-concrete structure parameterization calculation, in particular to a Python language-based parameterized automatic modeling method for a tower structure Abaqus finite element model, which solves the problems of low efficiency, easy errors and difficult parameter adjustment of traditional manual modeling. The method comprises the following steps: reading geometric, material, modeling and load information in an Excel parameter file; automatically generating a concrete component, a steel wire body and a steel reinforcement cage; completing prestressed anchor cable system modeling; assembling each component and automatically assigning material and cross-section properties; finally performing mesh division, contact definition, boundary condition application and load loading, and saving a complete finite element model. The present application significantly improves modeling efficiency and consistency through full-process parameter driving and modular script architecture, supports flexible customization of a whole tower structure, and provides a high-reliability pre-processing scheme for complex structure simulation.

Description

Technical Field

[0001] This invention belongs to the field of parametric calculation technology for wind power steel-concrete structures. Specifically, it relates to a parametric automatic modeling method for hybrid tower structures using Abaqus finite element models based on the Python language. Background Technology

[0002] Steel-concrete hybrid structures are key load-bearing components of wind power generation systems. With the development of finite element technology, finite element analysis has become the mainstream method for engineering design in this field. As a core tool in modern structural engineering design, finite element analysis has been widely applied to the strength verification, stability assessment, and optimization design of hybrid towers. However, hybrid tower structures are characterized by complex geometry, heterogeneous materials, dense reinforcement, and integrated prestressed systems, placing extremely high demands on finite element preprocessing for their refined modeling.

[0003] While mainstream finite element software such as Abaqus offers a graphical user interface (GUI) for manual modeling, this method is highly dependent on manual operation, resulting in a lengthy process and susceptibility to human error. Especially during the iterative optimization phase of structural schemes, even minor adjustments to design parameters (such as tower segment height, wall thickness, doorway location, rebar spacing, or prestressed anchor cable layout) often require rebuilding the entire model, leading to a massive amount of repetitive work. Furthermore, mixed-type towers involve the collaborative modeling of multiple components, including concrete, steel, rebar cages, and prestressed systems. Traditional methods struggle to achieve unified management and automatic correlation of geometric, material, and load parameters, severely limiting modeling efficiency and model consistency. Summary of the Invention

[0004] To address the aforementioned problems, this invention proposes a parametric modeling method for hybrid tower structures using the Abaqus finite element model based on the Python language. This invention automates the entire process from design parameter input, finite element model generation, analysis step definition to load and boundary condition application through parameter-driven approaches. This reduces the original manual modeling work, which took several hours, to minutes, significantly improving modeling efficiency and standardization.

[0005] A parameterized automatic modeling method for hybrid tower structures of wind turbine generators using Abaqus finite element modeling based on Python language includes the following steps: S1. Enter the configuration information in the main function, including the running path, model name, and parameter file name; S2. Input the key design parameters of each component of the hybrid tower structure into the Excel parameter file, including geometric information, material properties, modeling parameters, and load information. The main function reads the parameters from the Excel file and organizes the parameters of each component into independent parameter sets. Entering the key design parameters for each component of the hybrid tower structure into the Excel parameter file includes the following steps: Sa, the Excel parameter file is divided into at least three modules, including the standard tower module, the irregular tower module, and the reinforcement module. The key design parameters of each component are entered in the corresponding module.

[0006] Sb. In the main function, the key design parameters of different modules in the Excel parameter file are read using the Abaqus built-in Python secondary development function Xlrd.open_workbook.

[0007] Sc. In the main function, create a parameterized set according to the component name, and integrate the parameters of all different components into the set.

[0008] The geometric information includes the radius, height, and thickness of each tower segment; the radius, height, and length of the critical side of the foundation; the thickness, width, and height above ground of the portal opening; the corner diameter of the portal frame; the radius of the steel strand from the tower center; the radius and height of the anchorage; the longitudinal reinforcement diameter, circumferential reinforcement diameter, and protective layer thickness of each tower segment's reinforcement; and the longitudinal reinforcement diameter, circumferential reinforcement diameter, and protective layer thickness of the portal opening reinforcement.

[0009] The material properties include the concrete strength of each tower segment, the concrete strength of the foundation, the steel grade of the steel-concrete transition section, the steel grade of the anchorage, the steel grade of the steel pad, the steel grade of the steel strand, and the steel grade of the door frame.

[0010] The modeling parameters include the modeling angle, rotation angle, and number of assembly segments for each tower segment; the number and diameter of anchors; the number and length of steel strands; the modeling angle, rotation angle, and assembly position segment number for the portal opening; the number and spacing of longitudinal bars and circumferential bars for each tower segment; and the number and spacing of longitudinal bars and circumferential bars for the portal opening.

[0011] The load information includes the load magnitude in six directions on the top surface of the tower and the prestress magnitude of the prestressed cables.

[0012] S3. In the main function, the component creation sub-function is called through the Abaqus built-in Python secondary development function Import. Based on the key design parameters of each component, the finite element model structural components such as standard concrete tower, irregular concrete tower, steel-concrete transition section, steel tower section, portal component and foundation are automatically generated. The steps for automatically generating each component are as follows: Sa, using the Abaqus built-in Python secondary development function ConstrainedSketch to create a sketch object, requires at least the outer diameter r of the nth segment in the sketch of the component. nBottom height from the ground h n and the thickness d of the tube segment n and the outer diameter r of the (n+1)th segment n+1 Bottom height from the ground h n+1 and the thickness d of the tube segment n+1 ; Sb. For a standard concrete tower, the coordinates of point A are assumed to be A(r). n , h n The coordinates of point B are B(r). n+1 ,h n+1 ), through its segment thickness d n We obtain points A' and B', where the coordinates of point A' are A'(r). n -d n , h n The coordinates of point B' are B'(r) n+1 -d n , h n+1 ); Sc. Using the Line function, a built-in Python secondary development tool in Abaqus, connect A, A', B', and B with line segments to obtain the geometric outline. Sd: Based on the component features, convert the sketch geometry into a solid. The component creation process includes drilling holes in irregularly shaped concrete towers and steel-concrete transition sections based on the input key design parameters.

[0013] The component creation process includes drilling holes at the corresponding segment locations based on the input key design parameters to automatically create tower portal openings.

[0014] S4: In the main function, the reinforcement creation sub-function is called through the Abaqus built-in Python secondary development function Import. Based on the key design parameters of the reinforcement of each component, the longitudinal reinforcement, ring reinforcement and door opening reinforcement of all components are automatically created. The steps for automatically generating the reinforcement bars for each component are as follows: Sa, using the Abaqus built-in Python secondary development function ConstrainedSketch to create a sketch object, requires at least the outer diameter r of the nth segment in the rebar sketch. n Bottom height from the ground h n and the thickness d of the tube segment n and the outer diameter r of the (n+1)th segment n+1 Bottom height from the ground h n+1 and the thickness d of the tube segment n+1 The thickness of the concrete cover for reinforcing bars, b n Segment modeling angle θ n Circular reinforcement diameter φ hnand longitudinal reinforcement diameter φ zn .

[0015] Sb. For the longitudinal reinforcement of standard concrete tower tube steel bars, the coordinates of point A are assumed to be A(r). n -b n -φ hn -φ zn / 2,h n +b n The coordinates of point B are B(r). n+1 -b n -φ hn -φ zn / 2, h n+1 -b n ), through its segment thickness d n We obtain points A' and B', where the coordinates of point A' are A'(r). n -d n +b n +φ hn +φ zn / 2, h n +b n The coordinates of point B' are B'(r) n+1 -d n +b n +φ hn +φ zn / 2,h n+1 -b n ).

[0016] Sc. Using the Line function, a built-in Python function in Abaqus, connect A, A', B', and B with line segments to obtain the geometric outline of the longitudinal reinforcement.

[0017] Sd. For the ring reinforcement of standard concrete tower tubes, the coordinates of the center of the outer ring reinforcement are assumed to be O (0, 0), and the radius is r = r n -b n -φ zn / 2, the coordinates of the center of its inner ring reinforcement are O(0, 0), and the radius is r=r n -d n +b n +φ zn / 2, using the Abaqus built-in Python secondary development function CircleByCenterPerimeter, based on the segment modeling angle θ n Draw the outer ring reinforcement curve AA' and the inner ring reinforcement curve BB'; Se, using the Line function provided by Abaqus for Python secondary development, connect A and B, and A' and B' with line segments in sequence to obtain the geometric outline of the ring reinforcement; Sf: Using the BaseWire function, a built-in Python secondary development tool in Abaqus, the sketch geometry is converted into a solid.

[0018] S5: In the main function, the sub-function for creating the steel cage is called through the Abaqus built-in Python secondary development function Import. Based on the key design parameters of the steel reinforcement of each component, the longitudinal bars and ring bars of each component are positioned at the specified positions and merged into a steel cage. The steps for automatically generating a steel reinforcement cage are as follows: Sa, the minimum number of longitudinal reinforcement bars N required for the nth segment in the reinforcement cage generation process. zn and spacing D zn Number of circumferential reinforcing bars N hn and spacing D hn The thickness of the concrete cover for reinforcing bars, b n The bottom height h of the nth segment above the ground n and modeling angle θ n ; Sb. For the longitudinal rib solid, a circular array is created using the Abaqus built-in Python secondary development function RadialPattern, with an array size of N. zn The total angle is θ n And by using Boolean operations, all entities are merged into longitudinal rib components; Sc. For the ring reinforcement solid, use the Abaqus built-in Python secondary development function Translate to translate the ring reinforcement to the elevation Y = h. n +b n Then, it is translated along the height direction to each design elevation, with a spacing of D. zn Finally, by using the secondary development function InstanceFromBooleanMerge, all entities are merged into a ring-rib component through Boolean operations. Sd, using the built-in Python secondary development function InstanceFromBooleanMerge in Abaqus, performs Boolean operations to merge the longitudinal reinforcement components and the ring reinforcement components into a steel cage.

[0019] S6: Call the component assembly sub-function in the main function. Based on the key design parameters of each component, automatically and accurately assemble the concrete components, steel-concrete transition section, steel tower section, doorway components, and foundation components to achieve integrated and coordinated modeling of concrete and steel reinforcement models. The steps for automatically assembling parts are as follows: Sa, at least the nth segment needs to be rotated by an angle θ in the assembly. rn and the number of assembled pieces N n ; Sb, using the Abaqus built-in Python secondary development function Rotate, rotates the component around the central axis of the tower, with a rotation angle of θ. rn ; Sc. Use the built-in Python function RadialPattern in Abaqus to create a circular array of N components. n The total angle is 360 degrees; S7: In the main function, the prestressed anchor system creation sub-function is called through the Abaqus built-in Python secondary development function Import. Based on the input key design parameters of the prestressed anchor system, the prestressed anchor system, including the steel strand and anchor model, is automatically created and assembled into the corresponding position. The steps for automatically creating a prestressed anchor cable system are as follows: Sa, the minimum number of anchors N in creating a prestressed anchor system. a and diameter r a The number of steel strands N s and length L; Sb. For anchorages, the default coordinates of the center are O(0, 0), and the diameter is r. a The geometric outline of the sketch can be drawn using the CircleByCenterPerimeter function, which is a built-in Python secondary development tool in Abaqus. Sc. Use the BaseSolidExtrude function, a built-in Python secondary development tool in Abaqus, to extrude the sketch geometry into a solid. Sd. For steel strands, the coordinates of point A are assumed to be A(0, 0) and the coordinates of point B are assumed to be B(0, L). The geometric outline of the steel strand can be obtained by connecting A and B with line segments using the Line function, which is a built-in Python function in Abaqus. Se, using the BaseWire function, a built-in Python secondary development tool in Abaqus, converts sketch geometry into solids; Sf. Using the built-in Python function RadialPattern in Abaqus, the steel strands and anchors are arranged in a circular array, with the number of arrays being N. s and N a The total angle is 360 degrees; The prestressed anchor cable system is assembled into the corresponding position. Based on the input key design parameters, the component assembly sub-function is called in the main function to assemble the prestressed anchor cable system. S8: Automatically assign material and section properties to each component; In S8, material properties and cross-sectional properties are assigned to each component. This is mainly achieved by calling the material property assignment sub-function and the cross-sectional property assignment sub-function in the main function, which automatically assigns material properties and cross-sectional properties to each component.

[0020] S9: Automatically completes the mesh generation, contact settings, analysis step creation, boundary condition creation, and load application for the component, and saves the model. S9 automatically completes these processes by calling corresponding sub-functions within the main function, and then saves the model.

[0021] Furthermore, when generating the concrete tower, the component creation sub-function first determines the bottom elevation of the current segment based on the ground clearance of adjacent segments, and calculates the coordinate points of the inner and outer contours in conjunction with the outer diameter and thickness. It then uses ConstrainedSketch (this command is the main command for this function and requires coordination with other commands; it is only explained here and does not imply that this command is sufficient for this function; for ease of explanation, it will not be separately annotated when such cases are involved) to create a sketch on a specified reference plane, and connects the contour points sequentially using the Line function to form a closed polygon. BaseSolidRevolve is then called to rotate the contour lines around the tower's central axis to create a solid component. For tower segments with openings or irregularly shaped tower segments, after creating the solid component, the CutExtrude or BooleanCut operation is called to cut the opening in the tower according to the size and position parameters of the opening or hole.

[0022] Furthermore, the main function imports a rebar creation sub-function module named create_rebar.py and calls the generate_rebar_wires function. This function, also taking the parameter set from step S2 as input, specifically processes the data in the rebar module. For modeling the longitudinal reinforcement in a standard concrete tower, the function first creates a new sketch object. When drawing the sketch of a single longitudinal reinforcement in the nth segment, it is necessary to extract the outer radius rn, bottom ground height hn, wall thickness dn, protective layer thickness bn, ring reinforcement diameter φhn, and longitudinal reinforcement diameter φzn. To ensure that the longitudinal reinforcement is located in the correct spatial position defined by the ring reinforcement and the protective layer, its outline point coordinates are modified multiple times. By default, the coordinates of the starting point A on the outer side of the longitudinal reinforcement are set to (rn - bn - φhn - φzn / 2, hn + bn), and the coordinates of the ending point B are set to (rn+1 - bn - φhn - φzn / 2, hn+1 - bn). Correspondingly, the coordinates of the inner point A' are (rn - dn + bn + φhn + φzn / 2, hn + bn), and the coordinates of point B' are (rn+1 - dn+1 + bn + φhn + φzn / 2, hn+1 - bn). Connecting A-A'-B'-B using the Line function forms the two-dimensional outline of the longitudinal rib, which is then converted into a one-dimensional wire entity representing a single longitudinal rib using the BaseWire function.

[0023] When generating the ring reinforcement, the plane where each ring reinforcement is located is determined according to the ring reinforcement spacing along the height direction. The radius of the ring reinforcement is calculated by combining the inner diameter and the thickness of the protective layer. A circular path is drawn using CircleByCenterPerimeter. All reinforcement paths are converted into independent line components through BaseWire.

[0024] Furthermore, when merging the reinforcing bars, the sub-function for creating the reinforcing bars and the reinforcing cage calls RadialPattern on the longitudinal reinforcement line component, using the tower's central axis as the rotation axis, and performs equiangular circular copying according to the number of longitudinal reinforcement bars. Then, it calls BooleanMerge to merge all longitudinal reinforcement bars into a single component. For each ring reinforcement line component, it first translates along the Z-axis to each design elevation, and finally merges it into an overall ring reinforcement component using BooleanMerge. The merged longitudinal reinforcement component and the merged ring reinforcement component are then combined using BooleanMerge again to form a complete reinforcing cage entity.

[0025] Furthermore, when creating the anchor, the prestressed anchor system creation sub-function draws a rectangular or circular cross-section sketch in the XY plane based on the anchor's outer diameter and thickness, and calls BaseSolidExtrude to extrude along the Z-axis to form the anchor solid. When creating the steel strand, it draws a straight or polyline path sketch in the YZ or XZ plane based on the steel strand length and anchorage position, and generates the line body through BaseWire. The anchor solid and the steel strand line body are treated as an assembly unit, and RadialPattern is called to perform a circumferential array with the tower's central axis as the rotation axis, according to the number of anchors, to complete the spatial arrangement of the entire prestressed system.

[0026] Furthermore, when the component assembly subfunction executes the ring array, it uses the tower's central axis as the rotation axis, taking the single concrete tower section, the single steel-concrete transition section, and the single steel tower section as base components, and sequentially rotating them around the tower's central axis by a rotation angle of θrn, before performing a ring array, with the array size being N. n The structure extends until it covers a 360-degree circumference, forming a complete annular tower structure; the components are seamlessly joined by precise coordinate alignment.

[0027] Furthermore, when assigning materials, the material and section property assignment sub-function calls the Material object in the Abaqus script interface to define the elastic modulus, Poisson's ratio, and density according to the concrete strength grade, and defines the corresponding mechanical parameters according to the steel grade; it creates section properties for concrete solids, steel components, and reinforcing bars respectively through HomogeneousSolidSection or TrussSection, and assigns section properties to the elements or geometric regions of the corresponding components through Part.setElementType or Part.SectionAssignment.

[0028] Furthermore, when performing mesh generation, the post-processing sub-function calls SeedPart or SeedEdge to set the global or local seed size and generates a structured or free mesh through MeshPart; in contact settings, it defines embedded constraints or surface contacts between concrete and steel reinforcement through ContactProperty or Tie; in analysis step creation, it calls StaticStep or DynamicStep to establish a static or dynamic analysis step; in boundary condition application, it applies full constraints to the foundation bottom surface through EncastreBC; in load loading, it applies load components in six directions to the reference point on the top surface of the tower through ConcentratedForce or Moment, and applies prestress to the prestressed cables through Temperature; finally, it calls Mdb.saveAs to save the model as an .inp file or a .cae database.

[0029] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. Modeling efficiency is significantly improved This invention significantly shortens the traditionally lengthy manual modeling process through parameter-driven and fully automated workflows. Users only need to modify the design variables in the Excel parameter file to generate a completely new finite element model with a single click, completely avoiding repetitive modeling and human error, and greatly accelerating the design iteration and scheme comparison cycle of hybrid tower structures.

[0030] 2. High parameter flexibility and engineering applicability This invention supports comprehensive customization of the geometry, materials, assembly, and load parameters of the entire hybrid tower structure (including standard sections, irregular sections, portals, foundations, reinforcement cages, and prestressed systems). The parameter system covers all key variables required for engineering design, and intuitive and efficient data management is achieved through a modular Excel input interface, meeting the refined modeling needs of different projects and working conditions.

[0031] 3. High model consistency and reliability This invention employs a unified parameter source to drive all modeling stages, ensuring strict consistency of geometric, material, reinforcement, prestressing, and load information within the model. This eliminates the risk of model mismatch caused by information fragmentation in traditional multi-step manual modeling. Simultaneously, the integrated and coordinated modeling mechanism for the reinforcement cage and concrete components realistically reflects the spatial nesting relationship between the reinforcement and concrete, providing a high-fidelity preprocessing model for subsequent nonlinear analysis.

[0032] 4. The system architecture is modular and has excellent scalability. This invention decomposes the modeling process into independent functional modules such as parameter reading, component generation, reinforcement modeling, assembly, attribute assignment, and preprocessing. Each module is called in an orderly manner through a main function, with clear logic and low coupling. This architecture not only facilitates maintenance and debugging but also provides a reusable technical framework for the future expansion to the automatic modeling of other complex structures (such as offshore wind turbine foundations and nuclear power plant containment vessels).

[0033] 5. This invention adopts a modular architecture design, with each functional module being independent and clear. Each module can sequentially complete geometric modeling, material property assignment, automatic mesh generation, analysis step creation, contact pair definition, boundary condition creation, and automatic load application. Attached Figure Description

[0034] Figure 1 This is a flowchart of the parametric modeling of the present invention; Figure 2 This is a schematic diagram of the Python script execution flow in one embodiment; Figure 3 This is a schematic diagram of a configuration information input interface for one embodiment; Figure 4 This is a schematic diagram of the key design parameter input interface for a standard tower module of one embodiment; Figure 5 This is a schematic diagram of the key design parameter input interface for an embodiment of an irregularly shaped tower module; Figure 6 This is a schematic diagram of the key design parameter input interface for a steel reinforcement module in one embodiment. Figure 7 This is a schematic diagram illustrating the script execution method of one embodiment; Figure 8 This is a schematic diagram of the main function and sub-function files written in Python, as shown in one embodiment. Figure 9 This is a schematic diagram of a parameterized modeling batch generation model in one embodiment; Figure 10 This is a schematic diagram of a finite element model of one embodiment. Detailed Implementation

[0035] Example 1: Please refer to the appendix. Figure 1 This invention provides a parametric automatic modeling method for hybrid tower structures using the Abaqus finite element model based on the Python language. Its core lies in the automation of the entire process, from geometric modeling, reinforcement layout, prestressed system construction to material property assignment and post-processing, through the linkage of structured program modules with external Excel parameter files. The specific implementation of this invention is described in detail below.

[0036] In the above-mentioned Python-based Abaqus finite element model parameterization automatic modeling method for hybrid tower structures, step S1 involves inputting configuration information in the main function, including the running path, model name, and parameter file name. Specifically, in step S1, by executing the main function in the Abaqus / CAE script interface environment, a string variable `working_directory` is first defined to store the absolute path specified by the user, which points to the project directory containing all input and output files. Secondly, a string variable `model_name` is defined to uniquely identify the finite element model instance generated in this modeling task. Finally, a string variable `parameter_file` is defined to specify the filename of the Excel spreadsheet containing all design parameters; this filename must include the full extension ".xlsx". These three configuration items together constitute the root directory and naming basis for all subsequent automated operations, ensuring a clear and traceable organizational structure for model files, logs, and intermediate data.

[0037] In the above method, step S2 involves reading and organizing key design parameters. Specifically, step S2 first divides the Excel parameter file into at least three independent worksheet modules: a standard tower module, a non-standard tower module, and a reinforcement module. In the standard tower module, the geometric information, material properties, and modeling parameters of each standard concrete tower segment are entered in a structured manner, either by row or column. In the non-standard tower module, the corresponding parameters for non-standard geometric components such as steel-concrete transition sections and steel tower sections are entered. In the reinforcement module, the detailed specifications of the embedded reinforcement in all concrete components are centrally managed. The geometric information includes the outer radius rn, bottom ground clearance hn, and wall thickness dn of each tower segment; the base radius, total height, and critical side length of the polygonal profile of the foundation; the wall thickness, opening width, and bottom ground clearance of the portal opening; the rounded diameter at the corner of the portal frame; the installation radius of the prestressed steel strand centerline from the tower's central axis; the outer radius and height of the anchorage; the nominal diameter φzn of the longitudinal reinforcement, the nominal diameter φhn of the circumferential reinforcement, and the concrete cover thickness bn of each tower segment; and the corresponding diameter and cover thickness of the reinforcement in the portal reinforcement area. The material properties include the design strength grade of the concrete used in each tower segment (e.g., C50, C60), the strength grade of the foundation concrete, the grade of the structural steel used in the steel-concrete transition section (e.g., Q345B, Q355), and the steel grades used in the anchorage, steel pads, steel strands, and portal frame (e.g., Q345B, Q355). The modeling parameters include the sector modeling angle θn, initial rotation angle θrn, and the number of segments Nn required for final assembly for each tower segment in a single modeling operation; the number of anchors Na and their nominal diameter ra; the number of steel strands Ns and their effective length L; the modeling angle and rotation angle of the portal opening and its specific segment number; the total number of longitudinal reinforcements Nzn and their average spacing Dzn along the circumferential direction in each tower segment; the total number of circumferential reinforcements Nhn and their average spacing Dhn along the height direction; and the corresponding number and spacing of the reinforcement bars in the portal opening. The load information includes the prestress applied to the prestressed cable and the six-degree-of-freedom load components acting on the flange connection at the top surface of the tower, namely the concentrated forces Fx, Fy, and Fz along the X, Y, and Z coordinate axes, and the concentrated bending moments Mx, My, and Mz around the X, Y, and Z coordinate axes.

[0038] After the structured entry of the parameter file is completed, the main function calls the `xlrd.open_workbook` function from the Python secondary development library included with Abaqus to open the Excel file specified by the `parameter_file` variable. Then, the program sequentially accesses the three worksheets: "Standard Tower Module," "Irregular Tower Module," and "Rebar Module." For each worksheet, the program iterates through its cells, using the parameter name as the dictionary key and the corresponding numerical or string value as the dictionary value, constructing three preliminary parameter dictionaries. Next, the main function integrates all parameters belonging to the same physical component extracted from different modules into a unified, nested parameter collection, using the logical name of the component (e.g., "Tower_Section_1," "Transition_Piece," "Rebar_Cage_Base") as the top-level key. This parameter collection is a multi-level data structure, with the component name at the top level, parameter categories (e.g., "Geometry," "Material," "Modeling") at the next level, and specific parameter name-value pairs at the bottom level. This structured data organization provides a clear, consistent, and easily searchable source of parameter inputs for subsequent sub-functions.

[0039] In the above method, step S3 automatically generates concrete structural components. Specifically, in step S3, the main function dynamically loads the component creation sub-function module named create_concrete_parts.py using the import statement and calls the generate_tower_sections function within it. This function receives the parameter set constructed in step S2 as input. For the generation of a standard concrete tower, the function first creates a new two-dimensional sketch using an Abaqus ConstrainedSketch object. When drawing the sketch of the nth segment, the function extracts the outer radius rn, bottom height hn, and wall thickness dn of the nth segment from the parameter set, as well as the outer radius rn+1, bottom height hn+1, and wall thickness dn+1 of the (n+1)th segment. Based on these parameters, four key points on the sketch outline are set by default: point A is (rn, hn), and point B is (rn+1, hn+1). Considering the segment wall thickness, the coordinates of the inner contour point A' are calculated to be (rn - dn, hn), and the coordinates of point B' are (rn+1 - dn+1, hn+1). Note that dn and dn+1 may not be equal; therefore, the radial coordinates of A' and B' are calculated independently. Subsequently, the Line function is called to connect points A to A', A' to B', B' to B, and B to A, forming a closed quadrilateral geometric contour. Finally, BaseSolidRevolve is called to rotate the contour line around the tower's central axis to create a solid component, thus obtaining the finite element solid component of the nth standard concrete tower segment.

[0040] For irregularly shaped concrete towers or steel-concrete transition sections, the modeling process adds feature operations after generating the foundation entity. For example, steel-concrete transition sections typically require reserved ducts for threading prestressed steel strands. The function reads the number, diameter, spatial coordinates, or eccentricity relative to the central axis of the ducts from the parameter set. Then, it calls Boolean cutting functions such as CutExtrude or CutRevolve, using a predefined circular or irregular section sketch, to excavate holes in the foundation entity along the specified path, thereby accurately forming the required internal duct structure. Similarly, the creation of tower portal openings is also achieved through excavation. The function locates the corresponding concrete segment entity based on the segment number to which the portal belongs, specified in the parameter set. Then, based on the width, height, ground clearance, and corner diameter of the portal opening, it constructs a rectangular cutting profile with rounded corners. This profile is precisely positioned on the outer surface of the segment, and material is removed from the segment entity using a Boolean subtraction operation (CutBoolean), generating a portal opening and smooth corner transition area that meet engineering requirements in one step, avoiding the complex chamfering operations in manual modeling.

[0041] In the above method, step S4 automatically generates the reinforcing steel structure. Specifically, in step S4, the main function imports the reinforcing steel creation sub-function module named create_rebar.py and calls the generate_rebar_wires function. This function also takes the parameter set from step S2 as input and specifically processes the data in the reinforcing steel module. For modeling the longitudinal reinforcement in a standard concrete tower, the function first creates a new sketch object. When drawing the sketch of a single longitudinal reinforcement in the nth segment, it is necessary to extract the outer radius rn, bottom ground height hn, wall thickness dn, protective layer thickness bn, ring reinforcement diameter φhn, and longitudinal reinforcement diameter φzn. To ensure the correct spatial position of the longitudinal reinforcement defined by the ring reinforcement and the protective layer, its outline point coordinates are modified multiple times. By default, the coordinates of the starting point A on the outer side of the longitudinal reinforcement are set to (rn - bn - φhn - φzn / 2, hn + bn), and the coordinates of the ending point B are set to (rn+1 - bn - φhn - φzn / 2, hn+1 - bn). Correspondingly, the coordinates of the inner point A' are (rn - dn + bn + φhn + φzn / 2, hn + bn), and the coordinates of point B' are (rn+1 - dn+1 + bn + φhn + φzn / 2, hn+1 - bn). Connecting A-A'-B'-B using the Line function forms the two-dimensional outline of the longitudinal rib, which is then converted into a one-dimensional wire entity representing a single longitudinal rib using the BaseWire function.

[0042] For modeling the ring reinforcement, its geometry is a circular arc. The function sets the center of the outer ring reinforcement to the origin (0, 0) of the global coordinate system, and its radius r_outer is calculated as rn - bn - φzn / 2. This radius ensures an appropriate gap between the outer edge of the ring reinforcement and the longitudinal reinforcement and protective layer. The center of the inner ring reinforcement is also located at (0, 0), and its radius r_inner is calculated as rn - dn + bn + φzn / 2. Next, the CircleByCenterPerimeter function is called to draw two concentric circular arc curves AA' and BB' with radii r_outer and r_inner, respectively, according to the modeling angle θn of the segment. Then, the Line function is used to connect the outer arc endpoint A and the inner arc endpoint B, as well as A' and B', forming a closed curved quadrilateral profile. Finally, the BaseWire function is used to convert this profile into a line body, representing a single ring reinforcement. This modeling logic accurately reflects the nested arrangement of the ring reinforcement in the concrete section. Its diameter and position are dynamically determined by the thickness of the protective layer and the diameter of the longitudinal reinforcement, ensuring the geometric authenticity of the model.

[0043] In the above method, step S5 involves constructing the rebar cage. Specifically, in step S5, the main function imports a rebar cage creation sub-function module named `assemble_rebar_cage.py` and calls the `build_cage_from_wires` function. This function receives all the single longitudinal bars and single-ring rebar lines generated in step S4, as well as the array parameters from the rebar module. For the longitudinal bars, the function obtains the number of longitudinal bars Nzn and the modeling angle θn of the nth segment. Since a single longitudinal bar is modeled within a sector angle, it needs to be arrayed circumferentially to form a complete circumferential distribution. The `RadialPattern` function is called to circumferentially copy the single longitudinal bar line with the global coordinate system Z-axis as the rotation axis. The array size is Nzn, and the total rotation angle is θn (usually 360 degrees or an integer fraction thereof), thereby generating the spatial distribution of all longitudinal bars. Subsequently, the `InstanceFromBooleanMerge` function is called to merge all the longitudinal bar line instances generated by the array into a single, continuous longitudinal bar component.

[0044] For the ring reinforcement section, its starting position along the tower height needs to be determined first. The function obtains the bottom height *hn* of the *n*th segment and the protective layer thickness *bn*, calculating the starting elevation of the ring reinforcement as *Y* = *hn* + *bn*. The *Translate* function is called to translate the single-ring reinforcement line along the Z-axis to this starting elevation. Next, the number of ring reinforcements *Nhn* and their spacing *Dhn* are obtained. The *LinearInstancePattern* function is called to translate each ring reinforcement along the positive Z-axis with a spacing of *Dhn*, thus generating all ring reinforcements evenly distributed along the height direction. Finally, the *InstanceFromBooleanMerge* function is used to merge all ring reinforcement lines into a single ring reinforcement component. After independently constructing the longitudinal reinforcement and ring reinforcement components, the *InstanceFromBooleanMerge* function is called again to perform a final Boolean merge operation, generating a complete, integrated steel cage line model. This steel cage, as a single component, facilitates subsequent assembly, material assignment, and mesh generation.

[0045] In the above method, step S6 involves automatically assembling the components. Specifically, in step S6, the main function imports a component assembly sub-function module named `assemble_model.py` and calls the `perform_assembly` function. This function is responsible for precisely locating and combining all concrete solid components generated in step S3 (including standard sections, irregular sections, foundations, and doorways), the reinforcing cage components generated in step S5, and steel tower sections, etc., in the Abaqus assembly module. For each concrete tower segment, the function reads its assembly segment number Nn and initial rotation angle θrn from the parameter set. First, the solid component of a single segment is instantiated into the assembly space. Then, the `RadialPattern` function is called to perform a circumferential array of the instance centered on the global Z-axis, with an array size of Nn and a total angle of 360 degrees. The initial rotation angle θrn is used to correct the orientation of the first segment, ensuring that the orientation of the entire tower is consistent with the design intent. Figure 1 Through this operation, Nn identical tunnel segments are precisely assembled into a complete circular tower segment. This process is repeated for all tower segments, and by translating along the Z-axis, the segments are stacked in order of height to ultimately form the complete tower main structure. The reinforcing cage components are directly translated into the interior of their corresponding concrete tunnel segments, achieving integrated and coordinated modeling of the concrete and reinforcing steel models, ensuring that the two are completely nested and matched in space.

[0046] In the above method, step S7 involves creating and assembling the prestressed anchor system. Specifically, in step S7, the main function imports a prestressed anchor system creation sub-function module named `create_prestressing_system.py` and calls the `generate_anchor_system` function. This function operates based on the data about the prestressed system in the parameter set. When creating the anchor, the function reads the number of anchors Na and the diameter ra. A sketch is created using `ConstrainedSketch`, and the `CircleByCenterPerimeter` function is called to draw a circular outline with the origin (0,0) as the center and ra as the radius. Subsequently, the `BaseSolidExtrude` function is called to extrude this circular sketch along the Z-axis to a specified height (which also comes from the parameter set), generating a cylindrical anchor entity. When creating the steel strands, the function reads the number of steel strands Ns and the length L. A sketch is created using ConstrainedSketch. The Line function is then called to connect point A(0, 0) and point B(0, L) (the coordinates here are simplified; the actual coordinates need to be radially offset according to the installation radius), generating a straight line segment. Then, the BaseWire function is used to convert it into a line body, representing a single steel strand.

[0047] After modeling individual anchors and single steel strands, the RadialPattern function is called to create circumferential arrays for both. The number of anchor arrays is Na, and the number of steel strand arrays is Ns, with a total angle of 360 degrees for both. The array radius is determined by the parameter "radius of the steel strand from the tower center," ensuring that all anchors and steel strands are precisely positioned on the designed installation circumference. Assembly is completed collaboratively by the assembly subfunction in step S6. After the prestressed system is created as an independent component, it is translated to a specified height position at the bottom of the foundation or tower, thus completing its integration with the main structure.

[0048] In the above method, step S8 automatically assigns material and section properties. Specifically, in step S8, the main function calls the two sub-function modules assign_materials.py and assign_sections.py respectively. The assign_materials function iterates through each component instance in the assembly, and based on its corresponding material properties in the parameter set (such as concrete strength grade C50, steel grade Q345B), automatically creates or references the corresponding material object in the Abaqus Material Library, and defines its basic mechanical properties such as elastic modulus, Poisson's ratio, and density. For concrete materials, it can also automatically associate predefined damage plasticity model parameters based on the strength grade. The assign_sections function is responsible for creating sections and assigning them to components. For solid concrete components, it creates solid sections and associates them with the assigned concrete material; for linear components such as steel cages and steel strands, it creates beam sections or truss sections, specifies their cross-sectional shape (such as circle) and size (determined by the diameter of longitudinal and circumferential reinforcement), and associates them with the corresponding steel material. Through the collaborative work of these two sub-functions, all structural components were endowed with complete physical properties, laying the foundation for subsequent numerical analysis.

[0049] In the above method, step S9 completes the preprocessing and saves the model. Specifically, in step S9, the main function sequentially calls a series of dedicated sub-functions to complete the final preprocessing settings. The mesh generation sub-function `mesh_parts.py` is called, which uses a global seed to control the overall mesh density and applies a local seed to refine the mesh in key areas such as doorways, steel-concrete interfaces, and prestressed ducts, ensuring the calculation accuracy of stress concentration areas. The contact setting sub-function `define_contacts.py` automatically identifies potential contact pairs such as concrete and reinforcing cage, concrete and steel strands, and steel-concrete interfaces in steel-concrete transition sections, and creates surface-to-surface or general contact interactions, defining contact properties such as the friction coefficient. The analysis step creation sub-function `create_steps.py` adds a static, general analysis step to the model to solve the structural response under a given load. The boundary condition sub-function `apply_bcs.py` applies fully fixed (Encastre) constraints to all nodes on the foundation bottom surface, constraining all six degrees of freedom. The load application sub-function `apply_loads.py` reads the prestressing and six directional loads (Fx, Fy, Fz, Mx, My, Mz) from the parameter set and applies prestressing to the prestressing cables, as well as corresponding concentrated forces and bending moments at reference points on the tower top surface or directly at the top surface nodes. After all preprocessing operations are completed, the Abaqus `saveAs` command is called to save the complete model database (.cae file) to the `working_directory` path specified in step S1, with the filename `model_name`, thus completing the entire automated modeling process.

[0050] Example 2: To illustrate the implementation process of the present invention more specifically, an application example is constructed. The present invention will be described in detail below with reference to the accompanying drawings, specific embodiments using Abaqus software and the Python secondary development language, to facilitate understanding by designers.

[0051] Step 1, as follows Figure 3 As shown, input the configuration information in the main function, including the running path, model name, and parameter file name; Step 2, as follows Figure 4As shown, the key design parameters of the standard tower module are entered into the Excel parameter file. The input parameters include the radius, height, thickness, modeling angle, rotation angle and number of assembly pieces for each tower segment, the concrete strength of each tower segment, the concrete strength of the foundation, the steel grade of the steel-concrete transition section, the steel grade of the anchorage, the steel grade of the steel pad, the steel grade of the steel strand, and the steel grade of the door frame.

[0052] Step 3, as follows Figure 5 As shown, input the key design parameters of the irregular tower module into the Excel parameter file. The input parameters include the radius, height, thickness, modeling angle, rotation angle, number of assembly pieces, and length of the key edge of the irregular tower segment, as well as the doorway parameters and load parameters. At the same time, input the parameters of the foundation, steel strands, and anchorages according to the prompts in the right-hand figure.

[0053] Step 4, as follows Figure 6 As shown, input the key design parameters of the reinforcement module into the Excel parameter file. The input parameters include the diameter and number of longitudinal bars, the diameter and number of circumferential bars, and the thickness of the protective layer. At the same time, input the reinforcement parameters of the door opening according to the prompts.

[0054] Step 5, as follows Figure 7 As shown, open the Abaqus software and run the Python main function script. All main functions and sub-functions written in Python are as follows: Figure 8 As shown, the model creation is implemented as follows: Figure 9 As shown, the final model created is as follows Figure 10 As shown.

[0055] Compared with traditional GUI modeling methods, this invention uses Python to perform secondary development on Abaqus and adopts a modular architecture design. It achieves an integrated "parameter-driven - automatic modeling" modeling process for finite element models of steel reinforcement and concrete in the hybrid tower structure of wind turbine generators. This reduces complex finite element modeling work from hours to minutes, significantly improving the efficiency of finite element model preprocessing. This invention enables the parameterization of the Abaqus model for steel reinforcement and concrete in the hybrid tower structure of wind turbine generators, that is, the parameters of the finite element model can be changed by modifying only the variables.

[0056] The above description only illustrates the embodiments of the present invention, but it cannot be considered as the entire scope of protection of the present invention. Any equivalent changes or modifications, or proportional enlargements or reductions made in accordance with the design spirit of the present invention should be considered to fall within the protection scope of the present invention.

Claims

1. A parameterized automatic modeling method for hybrid tower structures using Abaqus finite element model based on Python language, characterized in that... Includes the following steps: S1. In the main function, input the running path, model name and parameter file name, and use Python secondary development functions to read the geometric information, material properties, modeling parameters and load information from the Excel parameter file, and organize the parameters of each component into an independent parameter set; S2. In the main function, call the component creation sub-function. Based on the data in the parameter set, automatically generate the finite element model components of standard concrete tower, irregular concrete tower, steel-concrete transition section, steel tower section, doorway component and foundation through sketching function, geometric connection function and solid transformation function. S3. In the main function, call the sub-function to create the reinforcing bars and reinforcing cages. Based on the key design parameters of the reinforcing bars, automatically generate the longitudinal bars, ring bars and doorway bars through coordinate calculation and array function, and merge them into the reinforcing cages of each component. S4. In the main function, call the prestressed anchor system creation sub-function and component assembly sub-function to automatically create the steel strand and anchor model, and coordinate the assembly of all structural components, steel cage and prestressed system in an integrated manner according to the assembly parameters. S5. In the main function, call the corresponding sub-functions to automatically assign material and section properties, and complete mesh generation, contact settings, analysis step creation, boundary condition definition and load application, and finally save the model.

2. The method for parametric automatic modeling of hybrid tower structures using Abaqus finite element model based on Python language according to claim 1, characterized in that, In step S1, the Excel parameter file is divided into at least a standard tower module, an irregular tower module, and a reinforcement module; the geometric information includes the radius, height, and thickness of the tower segments, the radius and height of the foundation, the geometric parameters of the doorway and door frame, the geometric parameters of the steel strands and anchors, and the diameter and protective layer thickness of the reinforcement; the material properties include the concrete strength grade and the steel grade; the modeling parameters include the modeling angle, rotation angle, number of assembly pieces, number of components, and reinforcement spacing; the load information includes the load values ​​and prestress magnitude in six directions on the top surface of the tower.

3. The method for parametric automatic modeling of hybrid tower structures using Abaqus finite element model based on Python language according to claim 1, characterized in that, The steps for automatically generating each component in step S2 are as follows: Sa, create a sketch object using ConstrainedSketch, and obtain the outer diameter, ground clearance, and thickness parameters of the nth and (n+1)th segments; Sb. Calculate the coordinates of each vertex of the segment section based on the thickness parameters. For a standard concrete tower, determine the coordinates of the outer point A (rn, hn) and B (rn+1, hn+1) and the coordinates of the inner point A' (rn-dn, hn) and B' (rn+1-dn, hn+1). Sc. Connect the vertices sequentially using the Line function to obtain the geometric outline, and then convert it into a solid. Sd: Based on the input key design parameters, the system performs drilling operations on irregularly shaped concrete towers, steel-concrete transition section components, and corresponding segment locations, automatically creating tower portal openings.

4. The method for parametric automatic modeling of hybrid tower structures using Abaqus finite element model based on Python language according to claim 1, characterized in that, The steps for automatically generating longitudinal and circumferential reinforcement in step S3 are as follows: Sa, Obtain segment geometry parameters, protective layer thickness bn, modeling angle θn, and rebar diameter parameters from the rebar sketch; Sb. For longitudinal reinforcement, calculate the vertex coordinates based on the protective layer thickness and the diameter of the reinforcement, and connect them using the Line function to obtain the geometric profile of the longitudinal reinforcement. Sc. For the ring reinforcement, with (0,0) as the center, draw the inner and outer ring reinforcement curves using the CircleByCenterPerimeter function according to the segment modeling angle θn, and connect the endpoints of the curves to obtain the geometric profile of the ring reinforcement. Sd: Convert sketch geometry into solids using the BaseWire function.

5. The method for parametric automatic modeling of hybrid tower structures using Abaqus finite element model based on Python language according to claim 1, characterized in that, The steps in step S3 to merge the steel cage are as follows: Sa, obtain the number and spacing parameters of longitudinal and circumferential reinforcement bars; Sb, use the RadialPattern function to create a circular array of the longitudinal rib entities, and then merge them using Boolean operations; Sc. Use the Translate function to translate each ring reinforcement to the specified elevation, and then merge them using the InstanceFromBooleanMerge function; Sd, perform Boolean operations on the longitudinal reinforcement components and the ring reinforcement components to merge them into a whole steel cage.

6. The method for parametric automatic modeling of hybrid tower structures using Abaqus finite element model based on Python language according to claim 1, characterized in that, The steps for automatically creating the prestressed anchor cable system in step S4 are as follows: Sa, obtain the number and diameter of the anchorages, and the number and length of the steel strands; Sb. Create the anchor solid model using the CircleByCenterPerimeter and BaseSolidExtrude functions; Sc. Create a steel strand model using the Line and BaseWire functions; Sd, using the RadialPattern function, creates a circular array of steel strands and anchors at a total angle of 360 degrees.

7. The method for parametric automatic modeling of hybrid tower structures using Abaqus finite element model based on Python language according to claim 1, characterized in that, The steps for automatically assembling components in step S4 are as follows: obtain the rotation angle θrn and the number of assembly pieces Nn of each component, and use the RadialPattern function to form a circular array of each component with a total array angle of 360 degrees, thereby realizing the integrated assembly of the concrete and steel reinforcement models.

8. The method for parametric automatic modeling of hybrid tower structures using Abaqus finite element model based on Python language according to claim 1, characterized in that, In step S5, the entire process of automatic processing and model saving is achieved by calling the material property assignment sub-function, section property assignment sub-function, mesh generation sub-function, contact setting sub-function, analysis step creation sub-function, and load boundary sub-function in the main function.

Images