Method and device for analyzing lateral stiffness of skew grid structure

Abstract

The present application relates to the field of computer aided engineering analysis, and discloses a method and device for analyzing lateral stiffness of a skew grid structure, the method comprising: obtaining geometric parameters and an initial model file through a modeling script; the modeling script comprising a reading interface of the initial model file, a model iteration algorithm and a calling interface of a structure analysis software; the initial model file comprising basic definition information required for modeling; executing the model iteration algorithm on the geometric parameters and the basic definition information through the modeling script to generate basic component information of the model, the basic component information being used to represent grid data of the skew grid structure model; writing the basic component information into the initial model file to obtain a complete model file; and calling an application program interface of the structure analysis software through the modeling script to perform structure lateral stiffness calculation, the present application realizing full-process automation from input of geometric parameters to output of lateral stiffness and avoiding the cumbersome process of manual modeling and cross-software operation.

Description

Technical Field

[0001] This invention relates to the field of computer-aided engineering analysis, and specifically to a method and apparatus for analyzing the lateral stiffness of an oblique mesh structure. Background Technology

[0002] Due to their excellent lateral resistance and architectural aesthetics, oblique grid structures are widely used in high-rise buildings. During the structural design process, it is necessary to repeatedly adjust geometric parameters such as the angle of the oblique columns and the number of floors, and to obtain the lateral stiffness of the structure through finite element analysis for scheme comparison and optimization.

[0003] In related technologies, modeling and analyzing oblique mesh structures typically relies on engineers manually defining nodes and elements in structural analysis software. This requires repeated modeling when geometric parameters change, resulting in tedious, inefficient, and error-prone operations. Some methods attempt to achieve parametric modeling using built-in software scripts, but these scripts are tightly bound to specific software, making cross-platform use difficult and hindering direct and efficient communication with the structural analysis software's application programming interface (API). Furthermore, models generated using external visual programming tools often need to be exported to an intermediate format before being imported into the analysis software, leading to fragmented modeling, analysis, and result extraction processes, preventing the formation of a fully automated closed-loop workflow. Summary of the Invention

[0004] This invention provides a method and apparatus for analyzing the lateral stiffness of oblique mesh structures, thereby solving the problem that the analysis of the lateral stiffness of oblique mesh structures requires manual modeling and switching between multiple software programs, resulting in low analysis efficiency.

[0005] In a first aspect, the present invention provides a method for analyzing the lateral stiffness of an oblique mesh structure. The method includes: obtaining geometric parameters and an initial model file through a modeling script; the modeling script includes an interface for reading the initial model file, a model iteration algorithm, and an interface for calling structural analysis software; the initial model file includes basic definition information required for modeling; executing the model iteration algorithm on the geometric parameters and basic definition information through the modeling script to generate basic component information of the model, the basic component information being used to represent the mesh data of the oblique mesh structure model; writing the basic component information into the initial model file to obtain a complete model file; and calling the application programming interface of the structural analysis software through the modeling script to calculate the lateral stiffness of the structure.

[0006] In one optional implementation, the basic definition information includes node identification information, material identification information, section identification information, and structural geometric constraints; the command flow format of the structural analysis software is the Midas command flow format.

[0007] In one alternative implementation, obtaining geometric parameters and an initial model file via a modeling script includes: popping up an interactive window via the modeling script, the interactive window containing a file selection control and a parameter input control; obtaining the initial model file selected by the user in response to a trigger command from the file selection control; and receiving geometric parameters input by the user in response to an input command from the parameter input control.

[0008] In one alternative implementation, the initial model file is an MGT format file; the structural analysis software is MidasGen software.

[0009] In one optional implementation, a model iteration algorithm is executed on the geometric parameters and basic definition information using a modeling script to generate basic component information of the model, including: generating node coordinate data and element mapping relationship data through the model iteration algorithm; generating a node command list based on the node coordinate data according to the command flow format of the structural analysis software; generating an element command list based on the element mapping relationship data, material identification information, and section identification information; and writing the node command list and element command list into the corresponding fields of the initial model file to obtain a complete model file.

[0010] In one optional implementation, the recursive step size of the node coordinates is calculated based on the width of the outer frame, the story height, the angle of the inclined column, and the number of stories between adjacent main ring beams. Using the starting point coordinates in the node identification information as a reference, new nodes are generated point by point in combination with the recursive step size until all nodes are generated. The number of the new nodes starts from the largest node number in the basic definition information. Based on the generated new nodes, the node mapping relationship corresponding to the inclined column unit and the adjacent node relationship corresponding to the beam unit are established to obtain the unit mapping relationship data.

[0011] In one optional implementation, based on the generated new nodes, a node mapping relationship is established for the inclined column units and an adjacent node relationship is established for the beam units, generating unit mapping relationship data. This includes: determining the node number of each layer's nodes based on the generated node coordinate data for each layer; for the inclined column units, traversing each layer except the top layer, matching each node number in the current layer with the node number in the previous layer to form an inclined column node pair, with the node mapping relationship including all inclined column nodes; for the beam units, traversing each layer, pairing the node numbers of two adjacent nodes in the current layer sequentially, and pairing the first and last nodes to form a beam node pair, with the adjacent node relationship including all beam nodes; merging and storing the inclined column node pairs and beam node pairs as unit mapping relationship data.

[0012] In one optional implementation, the initial model includes node definition fields and element definition fields. The node command list and element command list are written into the corresponding fields of the initial model file to obtain a complete model file. This includes: reading the starting lines of the node definition fields and element definition fields of the initial model file, where the node definition field starting line is used to locate the starting position of the node data area, and the element definition field starting line is used to locate the starting position of the node data area; inserting the node command list after the node definition field starting line, and then inserting the element command list after the element definition field starting line, to obtain a complete model file.

[0013] In one alternative implementation, the structural lateral stiffness is calculated by calling the application programming interface (API) of the structural analysis software through the modeling script. This includes: calling the import interface of the Midas Gen API to import the complete model file into the structural analysis software; calling the analysis interface of the Midas Gen API to trigger static analysis; extracting displacement data from the static analysis results returned by the API; and calculating the structural lateral stiffness.

[0014] Secondly, the present invention provides a device for analyzing the lateral stiffness of an oblique mesh structure, the device comprising: The data acquisition module is used to acquire geometric parameters and the initial model file through the modeling script. The modeling script includes an interface for reading the initial model file, a model iteration algorithm, and an interface for calling the structural analysis software. The initial model file includes the basic definition information required for modeling. The modeling module is used to execute the model iteration algorithm on the geometric parameters and basic definition information through the modeling script to generate the basic component information of the model. The basic component information is used to represent the mesh data of the oblique mesh structure model. The complete model file acquisition module is used to write the basic component information into the initial model file to obtain the complete model file. The analysis module is used to call the application programming interface of the structural analysis software through the modeling script to perform structural lateral stiffness calculation.

[0015] Thirdly, the present invention provides an electronic device, comprising: a memory and a processor, wherein the memory and the processor are communicatively connected to each other, the memory stores computer instructions, and the processor executes the computer instructions to perform the lateral stiffness analysis method of the oblique mesh structure described in the first aspect or any corresponding embodiment.

[0016] Fourthly, the present invention provides a computer-readable storage medium storing computer instructions for causing a computer to execute the lateral stiffness analysis method for the oblique mesh structure described in the first aspect or any corresponding embodiment thereof.

[0017] Fifthly, the present invention provides a computer program product, including computer instructions for causing a computer to execute the lateral stiffness analysis method for the oblique mesh structure described in the first aspect or any corresponding embodiment.

[0018] This invention achieves full automation from geometric parameter input to lateral stiffness output by integrating a modeling script reading interface, iterative algorithm, and software call interface. It eliminates the tedious manual modeling and cross-software data transfer, reduces the risk of errors when entering node coordinates and member topology, and improves the efficiency and reliability of lateral stiffness analysis of oblique mesh structures. Attached Figure Description

[0019] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0020] Figure 1 This is a schematic diagram of the first process for analyzing the lateral stiffness of an oblique mesh structure according to an embodiment of the present invention; Figure 2 This is a schematic diagram of a visualization interface for a method of analyzing the lateral stiffness of an oblique mesh structure according to an embodiment of the present invention; Figure 3 This is a schematic diagram of the modeling structure for the lateral stiffness analysis method of the oblique mesh structure according to an embodiment of the present invention. Figure 4 This is a flowchart illustrating a specific implementation of the lateral stiffness analysis method for oblique mesh structures according to an embodiment of the present invention; Figure 5 This is a structural block diagram of a device for analyzing the lateral stiffness of an oblique mesh structure according to an embodiment of the present invention; Figure 6 This is a schematic diagram of the hardware structure of an electronic device according to an embodiment of the present invention. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0022] It is understood that before using the technical solutions disclosed in the various embodiments of the present invention, users should be informed of the types, scope of use, and usage scenarios of the personal information involved in the present invention and their authorization should be obtained in accordance with relevant laws and regulations through appropriate means.

[0023] In related technologies, the lateral stiffness analysis of oblique mesh structures typically relies on designers manually building finite element models. This requires defining node coordinates layer by layer in structural analysis software, arranging the connections between oblique columns and ring beams one by one, and repeatedly adjusting geometric parameters based on the structural height and mesh division. For high-rise or super high-rise oblique mesh structures, the number of mesh elements is enormous and the topological relationships are complex. Manual operation is not only time-consuming but also prone to introducing data errors in node numbering or member pairing. When the structural geometric parameters change, the entire model needs to be manually modified or even rebuilt, making rapid iteration with multiple schemes difficult.

[0024] Furthermore, in oblique mesh structures, all members are arranged at an angle, and the offset angles and geometric constraints between nodes in each layer must be precisely satisfied. During manual modeling, it is difficult to ensure that the inclination angle of each oblique column remains consistent with the design value, making modeling accuracy highly dependent on individual operational experience. After modeling, subsequent lateral stiffness calculations still require manually applying horizontal loads, setting analysis cases, and extracting displacement results. The entire process involves multiple independent operational steps and lacks automated means to connect parameter input to stiffness output. Therefore, how to achieve automated modeling and efficient calculation of lateral stiffness analysis for oblique mesh structures has become an urgent technical problem to be solved.

[0025] According to an embodiment of the present invention, an embodiment of a method for analyzing the lateral stiffness of an oblique mesh structure is provided. It should be noted that the steps shown in the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions. Furthermore, although a logical order is shown in the flowchart, in some cases, the steps shown or described may be executed in a different order than that shown here.

[0026] This embodiment provides a method for analyzing the lateral stiffness of an oblique mesh structure, which can be used in the aforementioned electronic equipment. Figure 1 This is a flowchart of a method for analyzing the lateral stiffness of an oblique mesh structure according to an embodiment of the present invention, such as... Figure 1 As shown, the process includes the following steps: Step S101: Obtain geometric parameters and initial model file through modeling script; the modeling script includes an interface for reading the initial model file, a model iteration algorithm, and an interface for calling structural analysis software; the initial model file includes basic definition information required for modeling.

[0027] Step S102: The model iterative algorithm is executed on the geometric parameters and basic definition information through the modeling script to generate the basic component information of the model. The basic component information is used to represent the mesh data of the oblique mesh structure model.

[0028] Step S103: Write the basic component information into the initial model file to obtain the complete model file.

[0029] Step S104: The structural lateral stiffness is calculated by calling the application programming interface of the structural analysis software through the modeling script.

[0030] Specifically, the modeling script program internally encapsulates an interface for reading the initial model file, which is used to import the initial model file. The initial model file contains the basic definition information required for modeling. This basic definition information refers to the set of fundamental parameters necessary for establishing the structural numerical model; the specific field content varies depending on the analysis software and data format, and it serves as an existing data source for subsequent calls. Simultaneously, the script receives externally input geometric parameters, which are numerical descriptions of the overall shape of the oblique mesh structure, such as the total building height, planar outline radius, standard floor height, number of circumferential divisions, and the angle between the oblique columns and the vertical axis. The geometric parameters and the basic definition information together serve as input data for the model iterative algorithm.

[0031] In this embodiment of the invention, the modeling script is a JAVA program. The initial model file can be obtained in various ways, including manual selection via an interactive window, passing command-line parameters, specifying a configuration file, automatic loading from a preset path, reading from shared network storage, retrieving from database storage, directly exporting from the design software interface, and receiving from a message queue. These methods can be flexibly selected or combined according to the actual application scenario to diversify and automate the sources of input data for the modeling script; no limitations are imposed here.

[0032] The embedded model iteration algorithm in the script generates basic component information based on geometric parameters and fundamental definition information. This basic component information is a structured dataset describing the mesh data of the oblique mesh structure model. Its core content is the topological relationship of all members, including the starting node number, ending node number, and corresponding three-dimensional spatial coordinates of each oblique column and ring beam. The execution process of the iterative algorithm follows geometric logic: based on the given floor height sequence and the number of circumferential segments, it progresses layer by layer from the bottom floor upwards. Within each layer, the offset of the nodes on the horizontal plane is calculated based on the oblique column inclination angle, forming a predetermined mesh unit shape between adjacent layer nodes. Simultaneously, the member connection relationships and coordinate data generated in each layer are stored sequentially.

[0033] After obtaining the basic component information, the script writes it into the initial model file. The initial model file itself has a format framework recognizable by structural analysis software, and it internally reserves blocks for describing data such as nodes, elements, sections, and materials. The script fills in the node blocks with the node coordinates from the basic component information, fills in the element blocks with the member connection relationships, and ensures that all data items are consistent with the existing definitions in the initial model file, thereby completing the missing mesh description portion of the file and forming a complete model file. The complete model file now contains complete structural geometry, topology, and basic settings, which can be directly read and used by structural analysis software for numerical solutions.

[0034] Subsequently, the modeling script calls the application programming interface (API) of the structural analysis software to calculate the lateral stiffness of the complete model file. This API is a function or process call method provided by the structural analysis software, allowing external scripts to send analysis commands to the software and retrieve the calculation results. Lateral stiffness calculation refers to determining the structure's resistance to lateral deformation under horizontal loads. This typically involves applying a unit horizontal force or specifying a seismic action spectrum, running the solver to obtain the vertex displacement or inter-story drift angle, and then calculating the overall stiffness value.

[0035] In one alternative implementation, the initial model file is an MGT format file; the structural analysis software is MidasGen software.

[0036] Specifically, the initial model file is specified as an MGT format file, a standard text-based input file format used by specific structural analysis software. Internally, it organizes node segments, element segments, load segments, and load case segments according to a fixed order and syntax. The initial model export involves creating an initial model containing a basic coordinate system. This file includes key fields such as *NODE (node ​​definition) and *ELEMENT (element definition). The structural analysis software is specifically designated as Midas Gen, a general-purpose finite element analysis program commonly used for the design of high-rise buildings and large-span spatial structures. During implementation, the modeling script's reading interface is specifically written for the syntax rules of the MGT format, correctly recognizing keywords, data line separators, and annotation markers in this format, thereby accurately extracting basic definition information. After generating the complete model file, because the file format is fully compatible with Midas Gen, the software can directly read the model using its own file opening function without additional format conversion.

[0037] This invention, by limiting the initial model file to the MGT format and specifying Midas Gen as the structural analysis software, allows the modeling script reading interface to be customized to the syntax rules of this format, accurately identifying keywords, data line separators, and annotation markers, thus improving the accuracy and efficiency of data reading and parsing. Furthermore, since the MGT format is inherently compatible with Midas Gen software, the generated complete model file can be directly read by the software without additional format conversion, reducing data conversion losses and error probabilities in intermediate steps, and improving the smoothness and reliability of the entire analysis process.

[0038] In one optional implementation, the basic definition information includes node identification information, material identification information, section identification information, and structural geometric constraints; the command flow format of the structural analysis software is the Midas command flow format.

[0039] Specifically, the basic definition information is clearly divided into node identification information, material identification information, section identification information, and structural geometric constraints. Node identification information uniquely identifies the number and spatial location of each node in the structural model. Material identification information points to different material types and their mechanical property parameters, such as material properties (elastic modulus, Poisson's ratio). Section identification information corresponds to the cross-sectional shape and size specifications of various members, such as the cross-sectional parameters of inclined columns and beams (e.g., H-beam dimensions). Structural geometric constraints define the boundary dimensions and shape restrictions of the overall structure. Simultaneously, the command flow format of the structural analysis software is limited to the Midas command flow format, which has specific text syntax rules for describing node definitions, element definitions, load application, and analysis control commands. In practice, the modeling script parses the aforementioned identification information from the initial model file, using it as the index for subsequent mesh generation and attribute assignment. All data generated by write operations must be organized into text lines that can be directly parsed by the software, following the Midas command flow format.

[0040] In this embodiment of the invention, the cross-sectional dimensions of the diagonal columns and beams in the oblique grid structure are first determined in the Midas program. For the diagonal columns, a cross-section of H300×300×10×15 is selected, while the beams use an H250×250×8×12 cross-section. Regarding materials, Q345 steel is uniformly used, possessing an elastic modulus of 206 GPa and a Poisson's ratio of 0.3. After accurately defining these cross-sectional dimensions and material properties in the Midas program, an MGT file containing the basic information is exported.

[0041] This invention, through explicit definition of node identifiers, material identifiers, section identifiers, and structural geometric constraints in the basic definition information, and by providing dedicated support for the Midas command flow format, enables the modeling script to uniformly parse various identifier information from the initial model file as the index basis for subsequent mesh generation and attribute assignment. This partitioning method ensures the accurate correlation between material properties, section dimensions, and member topology, avoiding modeling errors caused by confused attribute references. All write operations are organized into text lines that can be directly parsed by the software according to the Midas command flow format, ensuring the syntactic correctness and structural integrity of the generated data.

[0042] In one optional implementation, step S101 includes: Step a1: An interactive window pops up via the modeling script. The interactive window contains a file selection control and a parameter input control.

[0043] Step a2: In response to the trigger command of the file selection control, obtain the initial model file selected by the user.

[0044] Step a3: In response to the input command of the parameter input control, receive the geometric parameters input by the user.

[0045] Specifically, the modeling script acquires geometric parameters and the initial model file through an interactive window. Upon startup, the script displays a graphical interface containing a file selection control and parameter input controls. The file selection control browses the local file system; clicking it triggers a file selection command, and the script responds by retrieving the user-specified initial model file path and loading the file. The parameter input controls provide numerical input boxes or drop-down menus, allowing users to enter specific values ​​for various geometric parameters, such as height, number of layers, and angle. The script receives these values ​​and stores them as internal variables. This interactive method allows non-professional programmers to complete input directly through the graphical interface without manually modifying the script code.

[0046] In one optional implementation, the MGT file exported in the first step is read and written using the JAVA language. At this point, the two key parameters—the inclined column angle of 60° and the number of floors between adjacent main ring beams (2)—become the core basis, such as... Figure 2 As shown. Based on the geometric layout information such as the width of the outer frame of the structure (36,000 mm) and the floor height (3,500 mm), iterative calculations are carried out according to the pre-defined model node allocation rules.

[0047] This invention provides an interactive window that pops up with a file selection control and a parameter input control via a modeling script. This allows users to select the initial model file and input geometric parameters without manually modifying the script code. The graphical interaction lowers the barrier to entry, enabling non-professional programmers to independently prepare the model input, reducing human errors caused by directly modifying the code, and improving the convenience and user-friendliness of the parameter input process.

[0048] In one optional implementation, step S102 includes: Step b1: Generate node coordinate data and unit mapping relationship data through model iterative algorithm.

[0049] Step b2: Generate a list of node commands based on the node coordinate data, following the command flow format of the structural analysis software.

[0050] Step b3: Generate a list of element commands based on element mapping relationship data, material identification information, and section identification information.

[0051] Step b4: Write the node command list and the unit command list into the corresponding fields of the initial model file to obtain the complete model file.

[0052] Specifically, in the process of generating basic component information, node coordinate data and element mapping relationship data are first generated through a model iterative algorithm. The node coordinate data records the X, Y, and Z values ​​of each node in the model in the global coordinate system, while the element mapping relationship data records the node number pairs connected to both ends of each member.

[0053] Subsequently, following the command flow format of the structural analysis software, a list of node commands is generated based on the node coordinate data. Each command in this list corresponds to a complete definition line of a node.

[0054] Then, based on the element mapping relationship data, the material identification information and section identification information obtained from the basic definition information, an element command list is generated. Each element command not only includes the node numbers at both ends, but also references the corresponding material name and section name.

[0055] In one example, when generating element commands, based on the material and section properties of the inclined columns and beams, element commands are generated using the format iEL, TYPE, iMAT, iPRO, iN1, iN2, ANGLE (where iEL is the element number, TYPE is the element type, iMAT is the material number, iPRO is the section number, iN1 and iN2 are the connection node numbers, and ANGLE is the angle) within the command flow system of the MGT file. Element commands for the inclined columns and beams are generated in batches based on node mapping relationships and adjacent node relationships, and then stored in the element list.

[0056] Finally, the node command list and the unit command list are written into the corresponding fields of the initial model file to obtain a complete analyzable model file.

[0057] The lateral stiffness analysis method for oblique mesh structures provided in this embodiment first generates node coordinate data and element mapping relationship data through a model iterative algorithm. Then, it generates node command lists and element command lists according to the command flow format of the structural analysis software. This decouples mesh data generation from command format conversion. The step-by-step processing method allows each type of data to be independently verified and debugged before being written, reducing the difficulty of troubleshooting after program errors. Finally, the two types of command lists are written into the corresponding fields of the initial model file, ensuring the orderly organization of node and element definitions in the file, which facilitates rapid reading and parsing by the subsequent analysis software.

[0058] In one optional implementation, the geometric parameters include the inclined column angle and the number of floors between adjacent main ring beams, and the structural geometric constraints include the width of the outer frame and the floor height, where the floor height represents the height of each floor. Step b1 includes: Step b11: Calculate the recursive step size of the node coordinates based on the width of the outer frame, the story height, the angle of the inclined column, and the number of stories between adjacent main ring beams.

[0059] Step b12: Using the starting point coordinates in the node identification information as a reference, new nodes are generated point by point in combination with the recursive step size until all nodes are generated; the number of the new node starts from the largest node number in the basic definition information.

[0060] Step b13: Based on the generated new nodes, establish the node mapping relationship corresponding to the inclined column element and the adjacent node relationship corresponding to the beam element to obtain the element mapping relationship data.

[0061] The implementation process of this invention will now be described in detail using a three-story oblique grid structure as an example. The oblique column angle of this structure is 60°, the number of floors between adjacent main ring beams is 2, the floor height is 3500mm, and the width of the outer frame is 36000mm.

[0062] Specifically, in the process of generating node coordinates and element mapping data, the geometric parameters are the inclined column angle and the number of floors between adjacent main ring beams. The structural geometric constraints include the width of the outer frame and the floor height, where the floor height represents the height of each floor. The inclined column angle determines the degree of inclination of the inclined column from the vertical axis, and the number of floors between adjacent main ring beams specifies the interval between ring beams. Figure 3 This is an example of an embodiment of the present invention where there are 4 floors between adjacent main ring beams. After modeling, the oblique network structure diagram shows that 4 floor platforms can be clearly counted between the two main ring beams.

[0063] During implementation, the recursive step size of the node coordinates is calculated based on the width of the outer frame, the floor height, the angle of the inclined column, and the number of floors between adjacent main ring beams. This step size determines the incremental movement of the node in the horizontal and vertical directions when advancing one floor.

[0064] Based on the starting point coordinates in the node identification information, starting from the bottom of the structure or a known node, new nodes are generated point by point along the height and circumferential directions by combining the recursive step size, until all nodes covering the entire height of the structure are generated. The newly generated node numbers are counted from the largest node number already existing in the basic definition information to avoid conflicts with the original node numbers.

[0065] In one example, when generating node coordinates, the existing node information in the MGT file is read, and the largest node number is parsed out. Using trigonometric relationships, the offset of the node on the plane is calculated based on the angle of the inclined prism.

[0066] Based on these newly generated nodes, establish the upper and lower layer node mapping relationships for the inclined column elements and the adjacent node relationships for the same layer for the beam elements, and summarize to obtain complete element mapping relationship data.

[0067] In one example, the core of the model iterative algorithm is to divide the node spacing of the oblique mesh structure in the horizontal direction into two alternating regions. One region corresponds to the section through which the oblique column passes, and the other region corresponds to the section through which the oblique column does not pass. The two regions are combined to cover the width of the outer frame of the structure.

[0068] In this embodiment, the model iterative algorithm uses a hierarchical loop strategy to generate all node coordinate data. The algorithm first calculates two key spacing parameters based on the width of the outer frame, the height of the floor, and the angle of the inclined column: the spacing in the non-inclined column area is a = (width - 6 × h × cot) / 5, and the spacing in the inclined column area is b = a + 2 × h × cot, where cot = 1 / tan(angle). These two parameters determine the step size combination of the horizontal contour recursion, while the generation process of node coordinates follows a nested loop sequence. Taking the floor height h as the reference, the floor height z = k × 2h is controlled by the loop variable k to achieve the vertical distribution of multi-layer nodes. The generation process of node coordinates takes the floor height h as the basic vertical unit, where h represents the actual height of each floor. However, the geometric structure of the oblique grid uses 2h as the vertical calculation span of the oblique column tilting law. That is, the tilting direction and horizontal offset of the oblique column form a complete geometric loop unit every two floors. The loop variable k controls the reference floor sequence with a step size of 2h. An intermediate floor with a height of h is inserted between each reference floor, so as to achieve the regular arrangement of the oblique column network under the premise that there are nodes distributed on each floor.

[0069] The inner loop is nested within the outer loop and is responsible for generating a row of nodes vertically layer by layer at each planar reference point. For any fixed planar reference point (X,Y), the inner loop uses the floor height h as the basic unit, controlling the vertical coordinates to take values ​​of 0, 2h, 4h... up to the total structural height, with nodes generated every two floors at a height of 2h. At each height position, the algorithm applies alternating horizontal offsets to the node coordinates based on the floor number relative to the 2h cycle period: nodes in the reference layer (z=0, 4h, 8h..., corresponding to k=0, 2, 4...) maintain the reference planar coordinates (X,Y), while nodes in intermediate layers (z=2h, 6h, 10h...) have an offset 'a' added to their reference coordinates in the Y direction, i.e., their coordinates become (X,Y+a). Taking the first set of plane reference (0,0) as an example, the inner loop generates a full height node sequence at this position in batches as (0,0,0), (0,a,2h), (0,0,4h), (0,a,6h), (0,0,8h)... The Y value of the floor (reference floor) corresponding to the even number k is 0, and the Y value of the floor (intermediate floor) corresponding to the odd number k is a. The nodes of adjacent floors at the same vertical position are alternately misaligned in the horizontal direction. The inclined column crosses the intermediate floor from a reference floor node and connects to the reference floor node 2h above, forming an inclined network.

[0070] Once all vertical nodes under the first set of planar reference points have been generated, the inner loop exits, and the outer loop performs horizontal recursion, updating the planar reference to the next position. Taking the recursion increment 2a+b as an example, the new reference plane coordinates are (0,2a+b). Then, the inner loop re-enters, generating a full-height node sequence under this reference: (0,2a+b,0), (0,a+b,2h), (0,2a+b,4h), (0,a+b,6h), (0,2a+b,8h)... where the Y-coordinate at the intermediate layer height is (2a+b)-a=a+b. A shrinkage offset 'a' is applied to the intermediate layer, the opposite of the previous inner loop process. After each inner loop ends, the offset is handled in the opposite way. The outer loop continuously switches the planar reference points, triggering a complete generation of vertical nodes in the inner loop each time. This process is repeated alternately until the horizontal contour is closed.

[0071] The connection of the inclined column elements is based on the vertical node sequence generated by the inner loop, and strictly follows the vertical step size of 2h. Nodes of adjacent height layers under the same plane datum are paired, i.e., height 0 is paired with 2h, 2h with 4h, 4h with 6h, and so on, forming a continuous inclined column path. Taking the first set of plane datums as an example, the node sequence is (0,0,0), (0,a,2h), (0,0,4h), (0,a,6h), (0,0,8h)..., where (0,0,0) and (0,a,2h) form the first inclined column, (0,a,2h) and (0,0,4h) form the second inclined column, (0,0,4h) and (0,a,6h) form the third inclined column, and so on. Nodes of adjacent layers are alternately connected, with a height difference of Δz=2h and a horizontal Y-axis offset of ΔY=a. The tilt angle is constrained by the trigonometric function relationship between a, 2h, and cot. Simultaneously, corresponding height layer nodes between adjacent plane datums can also be paired to form inclined columns in another direction. For example, the connection between the first datum (0,0,0) and the adjacent datum (0,2a+b,0) forms a transverse inclined column network in the horizontal profile direction. There are no vertical members in the height direction throughout the entire process. Each inclined column spans a height of 2h between adjacent height layers within the same plane datum, and the connection relationship is continuously staggered, thus forming a continuous oblique grid extending from the bottom to the top.

[0072] The overall generation process is designed to control the switching of horizontal reference points through an outer loop and the generation of vertical nodes through an inner loop. In different directions, a progressive step size consisting of combinations of a and b is used to combine the two-dimensional horizontal contour with the vertical layered offset to form a complete oblique mesh node coordinate sequence. Based on this design, various variations and adjustments to the loop execution order, step size combination method, offset direction and pairing rules are all included within the protection scope of this scheme.

[0073] This invention calculates the recursive step size based on the width of the outer frame, story height, inclined column angle, and the number of stories between adjacent main ring beams. New nodes are generated point-by-point using the starting point coordinates as a reference. This ensures that the generation of node coordinates has a clear geometric basis and recursive logic, guaranteeing that the spatial position of each node is strictly consistent with the design parameters. New node numbers are counted from the maximum node number in the basic definition information, effectively avoiding node number conflicts and ensuring that newly generated nodes can correctly establish connections with existing nodes. Furthermore, the invention simultaneously establishes the mapping relationship between upper and lower level nodes of inclined column units and the relationship between adjacent nodes on the same level of beam units, achieving integrated processing of node generation and topology establishment, thus improving overall modeling efficiency.

[0074] In one alternative implementation, step b13 includes: Step c1: Determine the node number of each layer of nodes based on the generated node coordinate data of each layer.

[0075] Step c2: For the inclined column element, traverse each layer except the top layer, and match each node number in the current layer with the node number in the previous layer to form an inclined column node pair. The node mapping relationship includes all inclined column nodes.

[0076] Step c3: Merge and store the inclined column node pairs and the beam node pairs as element mapping relationship data.

[0077] Specifically, in one example, the recursive step size for node coordinates is determined by calculating the slope parameter and combining it with the floor height and outer frame width. In the programming implementation, a loop statement is used, starting from the origin and generating node coordinates layer by layer and point by point according to the calculated step size rule. For each node generated, the command to create the node is generated using the command ;iNO,X,Y,Z (where iNO is the node number, and X, Y, and Z are the coordinate values) in the Midas command flow format, and stored in the node list, precisely specifying the position information of each node in three-dimensional space.

[0078] Based on the generated node coordinate data for each layer, the set of node numbers for all nodes within each layer is first determined. For inclined column elements, each floor except the top floor is traversed. The node number of each node in the current layer is extracted and paired with the corresponding node number in the previous layer to form inclined column node pairs. These node pairs all belong to the inclined column element type. For beam elements, each floor is traversed. In the current layer, adjacent node numbers are paired sequentially along a circular path. Simultaneously, the first and last nodes of the circular sequence are paired with each other to form beam node pairs. These node pairs belong to the beam element type. All inclined column node pairs and all beam node pairs are merged and stored in the same data structure, serving as the final element mapping relationship data for subsequent writing steps.

[0079] For example, the number of (0,0,0) is iN0 11, The number of (0, a, 2h) is iN0 12。 iN0 when connected ij and iN0 ij+1 Connected elements are inclined column units.

[0080] In one alternative implementation, when establishing node mapping relationships, the node correspondence rules for inclined cylindrical elements at different positions are predefined. For example, for inclined cylindrical elements in a specific region, the mapping method between their start and end nodes and existing node numbers is explicitly specified. In the programming implementation, a Map collection is used to store these mapping relationships for convenient and quick subsequent lookup and retrieval.

[0081] This invention, through traversing the node numbers of each layer and forming inclined column node pairs and beam node pairs according to preset pairing rules, achieves the automatic generation of the mapping relationship between inclined column and beam units. This pairing logic clearly distinguishes the upper and lower layer correspondence of inclined columns and the same-layer adjacent relationship of beams, ensuring the correctness of connection methods for different types of members. Merging and storing the two types of node pairs in the same data structure facilitates unified traversal and batch processing during subsequent unit command list generation, improving the orderliness of data management and the efficiency of program execution.

[0082] In one alternative implementation, the initial model includes node definition fields and cell definition fields, and step b4 includes: Step e1: Read the starting line of the node definition field and the starting line of the element definition field of the initial model file. The starting line of the node definition field is used to locate the starting position of the node data area, and the starting line of the element definition field is used to locate the starting position of the node data area.

[0083] Step e2: Insert the node command list after the starting line of the node definition field, and insert the element command list after the starting line of the element definition field to obtain the complete model file.

[0084] Specifically, in the operation of writing the command list to the initial model file, the initial model has pre-defined node definition fields and element definition fields. The script first reads the starting lines of the node definition fields and element definition fields of the initial model file. The starting lines of the node definition fields are used to locate the starting positions of the node data regions in the file, and the starting lines of the element definition fields are used to locate the starting positions of the element data regions. After obtaining these two starting positions, the script inserts the previously generated node command list completely after the starting lines of the node definition fields, and then inserts the element command list after the starting lines of the element definition fields, while leaving the contents of other fields in the original file unchanged. Through this insertion method, the original basic definition information in the initial model file is preserved, and complete mesh topology data is added, ultimately forming a complete model file that can be fully recognized by analysis software.

[0085] In one optional implementation, the generated list of node commands and the list of element commands are accurately written into the initially exported MGT file. Specifically, these newly generated commands are added to the corresponding node definition fields (starting with *NODE) ​​and element definition fields (starting with *ELEMENT) in the MGT file, thus updating the model file. This ensures that the file contains newly generated node and element information based on the input parameters, providing accurate and complete model data for subsequent analysis.

[0086] When writing commands, the contents of the MGT file are first read into memory and stored as a list, line by line. The list is then traversed to locate the lines containing the *NODE and *ELEMENT fields. Commands from the node list are then inserted line by line after the *NODE field, and commands from the cell list are inserted line by line after the *ELEMENT field. Finally, the updated list contents are written back to the MGT file to ensure correct file format and data integrity.

[0087] This invention, through reading the starting lines of the node definition fields and the starting lines of the element definition fields of the initial model file, precisely inserts the node command list and the element command list into the corresponding fields, thereby achieving the fusion of newly added mesh data with the original basic definition information. This insertion method retains the original content of other fields in the initial model file, only supplementing the missing mesh description parts, avoiding the risk of data loss caused by duplicate definitions or field overwriting. The final complete model file not only retains the initial settings but also contains the complete structural topology, with clear data organization and compliant format.

[0088] In one optional implementation, step S104 includes: Step d1: Call the import interface of the Midas Gen API to import the complete model file into the structural analysis software.

[0089] Step d2: Call the analysis interface of the Midas Gen API to trigger static analysis; Step d3: Extract displacement data from the static analysis results returned by the application interface and calculate the lateral stiffness of the structure.

[0090] Specifically, during the calculation of the structural lateral stiffness, the modeling script calls the import interface of the Midas GenAPI. This import interface is responsible for reading the complete model file from external storage into the internal database of the Midas Gen software, completing the model initialization. Subsequently, the script calls the analysis interface of the Midas Gen API, which triggers the software to perform static analysis. During the solution process, the software calculates the displacement response of each node under load based on the load definitions and boundary conditions in the model.

[0091] After the solution is completed, the script extracts the displacement data of key nodes from the static analysis results returned by the application interface, especially the displacement value of the top of the structure in the direction of the horizontal load. Based on the ratio of unit force to displacement, it calculates the lateral stiffness of the structure, which can be directly output for design evaluation. The script calls the static solution module of the analysis software through the interface, applies a unit concentrated force in the X direction to the center node at the top of the structure, and the software returns the X-direction displacement of that node. The script records the displacement value and divides the unit force by the displacement to obtain the X-direction lateral stiffness. If other directions need to be evaluated, a horizontal force in the Y direction or a torque about the vertical axis can be applied sequentially. Each time, submission and result retrieval are automatically completed through the interface. Throughout the process, designers can adjust the geometric parameters and re-execute the script to compare the stiffness response under different parameter configurations. All intermediate steps are executed sequentially by the script.

[0092] In one example, the server's Midas API is accessed via the HTTP protocol. First, the updated MGT file from step four is imported into the Midas analysis environment through the API's relevant interface. Upon successful import, the model analysis is triggered, allowing the Midas program to perform a mechanical performance analysis on the three-layer oblique mesh structure based on the model's structural characteristics and the applied default analysis conditions.

[0093] After the analysis is completed, the load-condition displacement data of the layer nodes is obtained again through a specific interface of the Midas API. This load-condition displacement data is a key indicator for measuring the lateral stiffness of the oblique mesh structure. By further processing and analyzing this displacement data, the specific numerical value of the lateral stiffness of the structure under specific load conditions can be obtained, thus providing important data support for the design optimization and performance evaluation of the structure.

[0094] When importing files using the Midas API, the OkHttp library is used to construct the HTTP request. The request URL is set to the ` / doc / importmxt` interface address of the Midas API, and the updated MGT file path is passed as a parameter, encapsulated in JSON format in the request body. Necessary authentication information, such as the MAPI-Key, is added to the request header to ensure the request's legitimacy and security. After sending the request, the success of the file import is determined by the returned response status code.

[0095] When retrieving layer node displacement data, the Midas API's ` / post / table` interface is called. The request is constructed using the OkHttp library, setting the request URL to the interface address and specifying the required displacement data parameters, such as node number and load case name, in JSON format within the request body. After sending the request, the returned JSON data is received, parsed using a JSON parsing tool, and the displacement values ​​of the layer nodes are extracted for subsequent lateral stiffness calculations.

[0096] This invention automates the process of importing a complete model file into structural analysis software via the Midas Gen API import interface, and then triggering static analysis by calling the analysis interface. The script directly extracts displacement data and calculates lateral stiffness from the API results, eliminating the need for manual model loading, load setting, and result export in the software's graphical interface. This reduces operational steps and time consumption, ensuring the accuracy of data extraction and the repeatability of the calculation process.

[0097] As a specific embodiment of the present invention, such as Figure 4 As shown, in this embodiment, the local client undertakes the tasks of parameter definition, modeling script execution, and result post-processing, while the structural analysis software Midas Gen provides finite element solution services as the computing engine. The two communicate with each other via the HTTP protocol.

[0098] First, the user defines structural parameters on the local client, including geometric parameters and foundation definition information. Geometric parameters cover the total structural height, planar profile dimensions, story height, number of circumferential segments, and inclination angle of inclined columns, while foundation definition information includes material elastic modulus, Poisson's ratio, component section type, and support boundary conditions. Simultaneously, the client reads existing foundation definition information from the initial model file or directly exports an initial model file containing foundation definition information, preparing input data for subsequent parametric modeling.

[0099] Subsequently, the local client executes a parametric modeling script written in Java code, namely the modeling script in this embodiment of the invention. This script encapsulates a model iteration algorithm, generating basic component information based on geometric parameters and fundamental definition information, namely the node coordinates, connection relationships, and attribute indices of all members in the oblique mesh structure. Following the MGT format recognized by the Midas Gen software, the script organizes the basic component information into node command lists and element command lists, and writes them into the corresponding fields of the initial model file, forming a complete MGT format model file.

[0100] After the complete model file is generated, the local client establishes a communication connection with the Midas Gen software by calling the Midas Gen API via the HTTP protocol. The client sends an HTTP request to the Midas Gen server interface, containing instructions to import the model and the model file path. Upon receiving the request, Midas Gen reads the complete model file in MGT format and completes model reconstruction internally, including loading node, element, section properties, material properties, and boundary conditions. After the model import is complete, the client continues to call the Midas Gen API analysis interface via the HTTP protocol to trigger static analysis. Midas Gen performs finite element analysis based on the load definitions and constraints in the model, calculating the displacement response of the structure under horizontal loads.

[0101] After the solution is completed, Midas Gen returns the top-level displacement data of the structure to the local client via an HTTP response. The client receives this displacement data and outputs it to the MATLAB environment for further processing. In MATLAB, users can calculate the lateral stiffness of the structure based on the ratio of unit force to top-level displacement, or further conduct design work such as parameter sensitivity analysis and comparison of multiple schemes.

[0102] In the above process, all interactions between the local client and Midas Gen are completed through the HTTP protocol request and response mechanism. There is no need to manually open the Midas Gen graphical interface for operation. The entire modeling, analysis and data extraction process is automatically scheduled and executed by the client script.

[0103] This embodiment also provides a device for analyzing the lateral stiffness of an oblique mesh structure. This device is used to implement the above embodiments and preferred embodiments, and details already described will not be repeated. As used below, the term "module" can refer to a combination of software and / or hardware that performs a predetermined function. Although the device described in the following embodiments is preferably implemented in software, hardware implementation, or a combination of software and hardware, is also possible and contemplated.

[0104] This embodiment provides a device for analyzing the lateral stiffness of an oblique mesh structure, such as... Figure 5 As shown, it includes: The data acquisition module 501 is used to acquire geometric parameters and the initial model file through the modeling script. The modeling script includes an interface for reading the initial model file, a model iteration algorithm, and an interface for calling the structural analysis software. The initial model file includes the basic definition information required for modeling. Modeling module 502 is used to execute model iteration algorithms on geometric parameters and basic definition information through modeling scripts to generate basic component information of the model. The basic component information is used to represent the mesh data of the oblique mesh structure model. The module 503 for obtaining the complete model file is used to write the basic component information into the initial model file to obtain the complete model file. Analysis module 504 is used to call the application programming interface of structural analysis software through modeling scripts to calculate the lateral stiffness of the structure.

[0105] The lateral stiffness analysis device for oblique mesh structures provided in this embodiment of the invention can execute the lateral stiffness analysis method for oblique mesh structures provided in any embodiment of the invention, and has the corresponding functional modules and beneficial effects for executing the method. Further functional descriptions of the various modules and units are the same as in the corresponding embodiments described above, and will not be repeated here.

[0106] Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present invention.

[0107] The following is a detailed reference. Figure 6 This diagram illustrates a suitable structural design for implementing an electronic device according to embodiments of the present invention. The electronic device may include a processor (e.g., a central processing unit, graphics processor, etc.) 601, which can perform various appropriate actions and processes based on a program stored in read-only memory (ROM) 602 or a program loaded from memory 608 into random access memory (RAM) 603. RAM 603 also stores various programs and data required for the operation of the electronic device. The processor 601, ROM 602, and RAM 603 are interconnected via a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0108] Typically, the following devices can be connected to I / O interface 605: input devices 606 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 607 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; memory devices 608 including, for example, magnetic tapes, hard disks, etc.; and communication devices 609. Communication device 609 allows electronic devices to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 6 Electronic devices with various devices are shown, but it should be understood that it is not required to implement or have all of the devices shown, and more or fewer devices may be implemented or have instead.

[0109] In particular, according to embodiments of the present invention, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present invention include a computer program product comprising a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device 609, or installed from a memory 608, or installed from a ROM 602. When the computer program is executed by the processor 601, it performs the functions defined in the lateral stiffness analysis method for oblique mesh structures according to embodiments of the present invention.

[0110] Figure 6 The electronic device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments of the present invention.

[0111] This invention also provides a computer-readable storage medium. The methods described above according to embodiments of the invention can be implemented in hardware or firmware, or implemented as recordable on a storage medium, or implemented as computer code downloaded via a network and originally stored on a remote storage medium or a non-transitory machine-readable storage medium and subsequently stored on a local storage medium. Thus, the methods described herein can be processed by software stored on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. The storage medium can be a magnetic disk, optical disk, read-only memory, random access memory, flash memory, hard disk, or solid-state drive, etc.; further, the storage medium can also include combinations of the above types of memory. It is understood that computers, processors, microprocessor controllers, or programmable hardware include storage components capable of storing or receiving software or computer code. When the software or computer code is accessed and executed by the computer, processor, or hardware, the lateral stiffness analysis method for the oblique mesh structure shown in the above embodiments is implemented.

[0112] A portion of this invention can be applied as a computer program product, such as computer program instructions, which, when executed by a computer, can invoke or provide the methods and / or technical solutions according to the invention through the operation of the computer. Those skilled in the art will understand that the forms in which computer program instructions exist in a computer-readable medium include, but are not limited to, source files, executable files, installation package files, etc. Correspondingly, the ways in which computer program instructions are executed by a computer include, but are not limited to: the computer directly executing the instructions, or the computer compiling the instructions and then executing the corresponding compiled program, or the computer reading and executing the instructions, or the computer reading and installing the instructions and then executing the corresponding installed program. Here, the computer-readable medium can be any available computer-readable storage medium or communication medium accessible to a computer.

[0113] Although embodiments of the invention have been described in conjunction with the accompanying drawings, those skilled in the art can make various modifications and variations without departing from the spirit and scope of the invention, and such modifications and variations all fall within the scope defined by the appended claims.

Claims

1. A method for analyzing the lateral stiffness of an oblique mesh structure, characterized in that, The method includes: Geometric parameters and an initial model file are obtained through a modeling script; the modeling script includes an interface for reading the initial model file, a model iteration algorithm, and an interface for calling structural analysis software; the initial model file includes basic definition information required for modeling. The model iterative algorithm is executed on the geometric parameters and the basic definition information by the modeling script to generate the basic component information of the model. The basic component information is used to represent the mesh data of the oblique mesh structure model. The basic component information is written into the initial model file to obtain the complete model file; The structural lateral stiffness is calculated by calling the application programming interface of the structural analysis software through the modeling script.

2. The method according to claim 1, characterized in that, The basic definition information includes node identification information, material identification information, section identification information, and structural geometric constraints; the command flow format of the structural analysis software is the Midas command flow format.

3. The method according to claim 1, characterized in that, The process of obtaining geometric parameters and initial model files through modeling scripts includes: An interactive window pops up through the modeling script, and the interactive window contains a file selection control and a parameter input control. In response to the trigger command of the file selection control, the initial model file selected by the user is obtained; In response to the input command of the parameter input control, the system receives geometric parameters input by the user.

4. The method according to claim 1, characterized in that, The initial model file is an MGT format file; the structural analysis software is Midas Gen software.

5. The method according to claim 2, characterized in that, The step of executing the model iteration algorithm on the geometric parameters and the basic definition information through the modeling script to generate the basic component information of the model includes: The model iterative algorithm generates node coordinate data and cell mapping relationship data. Generate a list of node commands based on the node coordinate data according to the command flow format of the structural analysis software. A list of unit commands is generated based on the unit mapping relationship data, the material identification information, and the cross-section identification information; Write the node command list and the unit command list into the corresponding fields of the initial model file to obtain the complete model file.

6. The method according to claim 5, characterized in that, The geometric parameters include the inclined column angle and the number of floors between adjacent main ring beams. The structural geometric constraints include the width of the outer frame and the floor height, whereby the floor height represents the height of each floor. The generation of node coordinate data and element mapping relationship data through the model iteration algorithm includes: The recursive step size of the node coordinates is calculated based on the width of the outer frame of the structure, the floor height, the angle of the inclined column, and the number of floors between adjacent main ring beams. Based on the starting point coordinates in the node identification information, new nodes are generated point by point in combination with the recursive step size until all nodes are generated; the number of the new node is counted from the maximum node number in the basic definition information; Based on the newly generated nodes, establish the node mapping relationship corresponding to the inclined column element and the adjacent node relationship corresponding to the beam element to obtain the element mapping relationship data.

7. The method according to claim 6, characterized in that, The step of establishing node mapping relationships for inclined column elements and adjacent node relationships for beam elements based on the generated new nodes, and generating element mapping relationship data, includes: Based on the generated node coordinate data for each layer, determine the node number for each layer. For the inclined column element, traverse each layer except the top layer, and match each node number in the current layer with the node number in the previous layer to form an inclined column node pair. The node mapping relationship includes all inclined column nodes. For the beam unit, traverse each layer, sequentially pair the numbers of two adjacent nodes in the current layer, and pair the first and last nodes to form beam node pairs. The adjacent node relationship includes all beam nodes. The inclined column node pairs and the beam node pairs are merged and stored as unit mapping relationship data.

8. The method according to claim 5, characterized in that, The initial model includes node definition fields and element definition fields. Writing the node command list and the element command list into the corresponding fields of the initial model file yields a complete model file, including: Read the starting line of the node definition field and the starting line of the unit definition field of the initial model file. The starting line of the node definition field is used to locate the starting position of the node data area. Insert the node command list after the starting line of the node definition field, and then insert the unit command list after the starting line of the unit definition field to obtain the complete model file.

9. The method according to claim 4, characterized in that, The step of calling the application programming interface of the structural analysis software through the modeling script to calculate the lateral stiffness of the structure includes: Call the import interface of the Midas Gen API to import the complete model file into the structural analysis software; Call the analysis interface of the Midas Gen API to trigger static analysis; Displacement data is extracted from the static analysis results returned by the application interface, and the lateral stiffness of the structure is calculated.

10. A device for analyzing the lateral stiffness of an oblique mesh structure, characterized in that, The device includes: The data acquisition module is used to acquire geometric parameters and an initial model file through a modeling script; the modeling script includes an interface for reading the initial model file, a model iteration algorithm, and an interface for calling structural analysis software; the initial model file includes basic definition information required for modeling. The modeling module is used to execute the model iteration algorithm on the geometric parameters and the basic definition information through the modeling script to generate basic component information of the model, wherein the basic component information is used to represent the mesh data of the oblique mesh structure model; The module for obtaining a complete model file is used to write the basic component information into the initial model file to obtain a complete model file; The analysis module is used to call the application programming interface of the structural analysis software through the modeling script to calculate the lateral stiffness of the structure.

Images