Method and system for automatically generating a framework grid of a structural system of a building

Abstract

In various implementations, a grid generation application generates one or more frame grids for a building's structural system. The grid generation application determines an edge set based on a computer-aided design of the structural system. The grid generation application then performs one or more clustering operations based on the edge set to determine at least a first fundamental direction and a second fundamental direction. The grid generation application determines a subset of edges based on the edge set and the first fundamental direction. Subsequently, the grid generation application performs one or more clustering operations based on the edge subset to determine a first set of grid lines associated with the first fundamental direction. Based on the first set of grid lines and a second set of grid lines associated with the second fundamental direction, the grid generation application generates the frame grid of the structural system.

Description

Technical Field

[0001] The various implementation schemes generally involve structural engineering and computer-aided design, and more specifically, techniques for automatically generating frame grids for the structural systems of buildings. Background Technology

[0002] In a typical building design process, architects generate building plans that specify the building's outline, one or more outlines for each floor, and any number of building elements to be included. Examples of building elements include, but are not limited to, walls, elevators, and staircases. Once the building plans are complete, structural engineers then design the building's structural system based on the plans, various design constraints imposed on the building, different design objectives, and various design variables. The structural system comprises any number of structural members that work together to enable the building to resist various loads according to design constraints. For example, a given building's structural system may include slabs, beams, and columns, enabling the building to resist vertical loads caused by gravity and lateral loads caused by hurricane-force winds, provided that the stress does not exceed allowable limits. If any changes are made to the building plans, design constraints, design objectives, design variables, or loads during the design process, the structural engineer must redesign the structural system to accommodate these changes.

[0003] In one approach to designing a building's structural system, structural engineers independently use conventional computer-aided design ("CAD") applications to generate different designs of the structural system, each satisfying various design constraints imposed on the building. To generate a given design for the structural system, structural engineers typically create a baseline design based on building plans, design and structural engineering fundamentals, and design insights derived from their overall design experience. The baseline design specifically specifies the layout of the building's structural members and the sizes used for them. Using CAD applications, structural engineers then iteratively refine the baseline design, typically implementing a finite element analysis solver to evaluate design decisions and validate the resulting final design. After the structural engineer has generated multiple final designs for the structural system, the designs are compared based on different design objectives for the building, and a single final design for the structural system is selected.

[0004] One drawback of the aforementioned methods for generating the final design of a building's structural system is that conventional CAD applications are not configured to effectively explore the overall design space of a given structural system. Therefore, the final design of a structural system generated using conventional CAD applications is often not properly optimized for the different design objectives of the relevant building. In this regard, the process of refining baseline designs is often very time-consuming, as evaluating design decisions involves performing computationally complex finite element analyses on many refined designs. Consequently, in a typical design process, only a few baseline designs for a given structural system can be generated and refined. Furthermore, structural engineers may make conservative design decisions to reduce the time required to generate the final design, but at the expense of any number of design objectives. For example, a structural engineer might overestimate the required size of some structural elements to increase the likelihood that these elements will be included in the final design without further modifications. In this case, the structural engineer deliberately neglects to explore and evaluate structural system designs that converge more towards the design objective of minimizing weight.

[0005] The above problems are exacerbated by the increasing complexity and scale of buildings. For example, for a typical multi-story building, the total number of different combinations of relevant design variables may exceed half a million, each of which would lead to a different design of the building's structural system. Using conventional CAD applications, it is impossible to ensure that structural engineers consider all these different combinations and the resulting designs when generating the final design of the building's structural system. In fact, as mentioned above, in such cases, structural engineers are likely to consider only a small fraction of the total possible designs, which significantly reduces the likelihood that the final design will be properly optimized.

[0006] As explained above, there is a need in the art for more efficient techniques for generating designs of structural systems for buildings. Summary of the Invention

[0007] One embodiment of the present invention describes a computer-implemented method for generating one or more frame grids of a structural system of a building. The method includes: determining an edge set based on a computer-aided design of the structural system; performing one or more clustering operations based on the edge set to determine a first set of basic directions; determining a first subset of edges based on the edge set and the first basic directions included in the first set of basic directions; performing one or more clustering operations based on the first subset of edges to determine a first set of grid lines associated with the first basic directions; and generating a first frame grid of the structural system based on the first set of grid lines and a second set of grid lines associated with a second basic direction included in the first set of basic directions.

[0008] At least one technical advantage of the disclosed technology over existing technologies lies in its ability to be incorporated into CAD applications, enabling these applications to automatically explore the design space to identify areas for optimizing the structural system of a building for any number of design objectives. In this respect, utilizing the disclosed technology, CAD applications can decompose complex overall design optimization problems into simpler optimization problems involving different aspects of the structural system design. Therefore, CAD applications can explore the overall design in a more efficient and systematic manner. This functionality, unavailable in conventional CAD applications, increases the possibility of identifying and generating optimized designs of the structural system that converge to the building's design objectives. These technical advantages provide one or more technical improvements over existing methods. Attached Figure Description

[0009] To gain a detailed understanding of the features described above in the various embodiments, reference can be made to the various embodiments for a more specific description of the inventive concept briefly outlined above, some of which are illustrated in the accompanying drawings. However, it should be noted that the drawings only show typical embodiments of the inventive concept and should therefore not be considered as limiting the scope, and that other equally effective embodiments exist.

[0010] Figure 1 It is a conceptual diagram of a system configured to implement one or more aspects of various implementation schemes;

[0011] Figure 2 It is based on various implementation plans. Figure 1 More detailed illustrations of the gravity design application;

[0012] Figure 3 It is based on various implementation plans. Figure 2 More detailed illustrations of the gravity design optimizer;

[0013] Figure 4 It is based on various implementation plans. Figure 1 More detailed illustrations of the raster generation application;

[0014] Figure 5 It is based on various implementation plans. Figure 1 A more detailed illustration of the framework specification application;

[0015] Figure 6 It is based on various implementation plans. Figure 1 A more detailed illustration of the application's iteration size setting;

[0016] Figures 7A to 7B A flowchart illustrating the steps of the method for designing structural systems for buildings according to various implementation schemes;

[0017] Figures 8A to 8B A flowchart illustrating the steps of a method for generating a frame grid for a building's structural system, based on various implementation schemes;

[0018] Figure 9 It is a flowchart of the method steps for generating a design of a frame system associated with a building, based on various implementation schemes; and

[0019] Figures 10A to 10B The flowchart illustrates the steps of designing structural systems for buildings to resist lateral loads according to various implementation schemes. Detailed Implementation

[0020] In the following description, numerous specific details are set forth to provide a more thorough understanding of various embodiments. However, it will be apparent to those skilled in the art that the inventive concept can be practiced without one or more of these specific details.

[0021] System Overview

[0022] Figure 1 This is a conceptual illustration of a system 100 configured to implement one or more aspects of various implementation schemes. As shown, system 100 includes, but is not limited to, a display device 104 and a computing instance 110. For illustrative purposes, multiple instances of similar objects are indicated by reference numerals identifying the objects and, where necessary, by bracketed alphanumeric characters identifying the instances.

[0023] Any number of components of system 100 may be distributed across multiple geographical locations or implemented in any combination within one or more cloud computing environments (i.e., encapsulated shared resources, software, data, etc.). In some embodiments, system 100 may include, but is not limited to, any number (including zero) instances of display device 104 and any number of instances of compute instance 110. In the same or other embodiments, each instance of compute instance 110 may be implemented in a cloud computing environment, as part of any other distributed computing environment, or independently.

[0024] As shown in the figure, computing instance 110 includes, but is not limited to, processor 112 and memory 116. Processor 112 can be any instruction execution system, device, or apparatus capable of executing instructions. For example, processor 112 may include a central processing unit, graphics processing unit, controller, microcontroller, state machine, or any combination thereof. Memory 116 stores content used by processor 112, such as software applications and data. In some alternative embodiments, each of any number of instances of computing instance 110 may include any number of instances of processor 112 and any number of instances of memory 116 in any combination. In particular, any number of instances of computing instance 110 (including one) may provide a multiprocessing environment in any technically feasible manner.

[0025] Memory 116 may be one or more readily available memories, such as random access memory, read-only memory, floppy disk, hard disk, or any other form of local or remote digital storage device. In some embodiments, a storage device (not shown) may supplement or replace memory 116. The storage device may include any number and type of external memory accessible to processor 112. For example, but not limited to, the storage device may include a secure digital card, external flash memory, portable optical disc read-only memory, optical storage device, magnetic storage device, or any suitable combination of the foregoing.

[0026] As shown in the figure, in some embodiments, computing instance 110 is associated with display device 104. Display device 104 can be any device capable of displaying images and / or any other type of visual content. For example, display device 104 can be, but is not limited to, a liquid crystal display, a light-emitting diode display, a projection display, a plasma display panel, etc. In some embodiments, display device 104 is a touchscreen capable of displaying visual content and receiving input (e.g., from a user).

[0027] In some implementations, computing instance 110 may be integrated into a user device along with any number and / or type of other devices (e.g., other instances of computing instance 110, input devices, output devices, input / output devices, etc.). Some examples of user devices include, but are not limited to, desktop computers, laptop computers, smartphones, smart TVs, game consoles, tablets, etc.

[0028] Generally, each instance of computing instance 110 is configured to implement one or more software applications. For illustrative purposes only, each software application is described as residing in the memory 116 of computing instance 110 and executing on the processor 112 of computing instance 110. However, in some embodiments, the functionality of any number of software applications may be distributed across any number of other software applications residing in the memory 116 of any number of instances of computing instance 110 and executing in any combination on any number of instances of the processor 112 of any number of instances of computing instance 110. Furthermore, the functionality of any number of software applications may be combined into a single software application.

[0029] Specifically, computational instance 110 is configured to implement one or more computer-aided design (“CAD”) applications that can be used to automatically design the structural systems of buildings. As previously described herein, in a conventional approach to designing the structural systems of buildings, structural engineers use one or more conventional CAD applications to independently generate multiple baseline designs based on building plans, design and structural engineering fundamentals, and design insights derived from the structural engineer’s overall design experience. The structural engineer then uses the conventional CAD applications to progressively refine the baseline designs, typically executing a finite element analysis solver to evaluate design decisions and validate the resulting final design. After the structural engineer has generated multiple final designs for the structural system, the designs are compared based on different design objectives for the building, and a single final design for the structural system is selected.

[0030] One drawback of the aforementioned method for generating the final design of a building's structural system is that conventional CAD applications are not configured to effectively explore the overall design space of a given structural system. In particular, the process of refining baseline designs is typically very time-consuming, as evaluating design decisions involves performing computationally complex finite element analyses on many refined designs. Therefore, in a typical design process, only a few baseline designs for a given structural system can be generated and refined. Consequently, the final design of a structural system generated using conventional CAD applications is often not properly optimized for the different design objectives of the associated building.

[0031] Generative design technology for structural systems of buildings

[0032] To address the aforementioned issues, in some implementations, computational instance 110 includes, but is not limited to, structural design application 120. Structural design application 120 is a CAD application that implements generative design techniques to generate designs for the structural systems of buildings based on any number and / or type of design objectives and any and / or type of design constraints. As described in more detail below, structural design application 120 defines a general optimization design problem and then decomposes the general optimization design problem into multiple, less complex optimization problems, referred to herein as component optimization problems. Each component optimization problem is associated with a different aspect of the structural system design. To solve the general optimization design problems, structural design application 120 executes a general design process that dynamically adjusts itself based on the results generated in solving the component optimization problems.

[0033] In some implementations, the architecture design application 120 resides in the memory 116 of the computing instance 110 and executes on the processor 112 of the computing instance 110. Generally, the functionality of the architecture design application 120 can be distributed across any number of software applications. Each software application can reside in any number of instances of the memory 116 of any number of instances of the computing instance 110 and execute in any combination on any number of instances of the processor 112 of any number of instances of the computing instance 110.

[0034] As shown in the figure, in some embodiments, the structural design application 120 includes, but is not limited to, any number of instances (not explicitly shown) of the interface engine 108, gravity design application 140, grid generation application 150, iterative optimization application 172, and overall ranking engine 190. In the same or other embodiments, the iterative optimization application 172 includes, but is not limited to, the framework specification application 170 and the iteration size setting application 180.

[0035] In some embodiments, the interface engine 108 displays a graphical user interface (“GUI”) 106 via a display device 104. The interface engine 108 may receive a number and / or type of input via the GUI 106 and may display any number and / or type of output via the GUI 106. In some embodiments, the interface engine 108 receives any number and / or type of design constraints (not shown) and / or any number and / or type of design objectives (not shown) via the GUI 106. In the same or other embodiments, the interface engine 108 displays any number of solutions to the overall optimization design problem and / or a portion (including none or all) of any number of solutions to the optimization problem via the GUI 106.

[0036] In some embodiments, structural design application 120 generates a design problem definition 122 that describes an overall design optimization problem and specifies, but is not limited to, any amount and / or type of auxiliary data. Structural design application 120 can generate design problem definition 122 based on any amount and / or type of input data in any technically feasible manner. As shown, in some embodiments, structural design application 120 generates design problem definition 122 at least in part based on input received via GUI 106. In the same or other embodiments, interface engine 108 can display a portion (including none or all) of design problem definition 122 via GUI 106.

[0037] The overall design optimization problem is to generate any number of designs for the structural system of a building based on any number and / or type of design objectives and any number and / or type of design constraints. In some implementations, the design problem definition 122 includes, but is not limited to, building floor plans 124, design instructions 130, wind directions 164(1) to 164(W), and building wind load data 162 included in the computer-aided design of the building (not shown), where W can be any positive integer.

[0038] In some embodiments, building plan 124 includes, but is not limited to, building outline 126 and floor outlines 128(1) to 128(F), where F can be any positive integer. Building outline 126 is the outline of a building having F floors. For purposes of explanation only, “building” as used herein refers to the building associated with building plan 124. Each of the floor outlines 128(1) to 128(F) is the outline of a different floor of the building. For purposes of explanation only, floor outlines 128(1) to 128(F) are also individually referred to herein as “floor outline 128” and collectively as “floor outline 128”.

[0039] In the same or other embodiments, instead of building outline 126 and / or floor outline 128, or otherwise, building floor plan 124 may include any amount and / or type of data relating to the structural system of the building. For example, in some embodiments, building floor plan 124 includes, but is not limited to, floor plans (not shown) for each floor, wherein each floor plan specifies floor outline 128, any number of rooms, the occupancy type of each room, and / or any number of walls. In the same or other embodiments, building floor plan 124 includes, but is not limited to, a predefined column grid (not shown), wherein the location of the frames is limited to the grid lines included in the predefined column grid.

[0040] As shown in the figure, in some embodiments, design instructions 130 include, but are not limited to, constraints 132, objective function 134, design variable data 136, and parameter data 138. Constraint 132 may specify any quantity and / or type of limitation associated with the building. For example, in some embodiments, constraint 132 includes, but is not limited to, any number of design constraints specified by the user at the upper level (e.g., via GUI 106), any number of limitations derived from design constraints and / or any other type of user input, any number and / or type of limitations associated with the building plan 124, any number and / or type of limitations associated with any number and / or type of building regulations and / or zoning regulations, and / or any number and / or type of limitations associated with any aspect of the construction.

[0041] The structural design application 120 can generate constraints 132 in any technically feasible manner. For example, in some embodiments, the user specifies a predefined column grid via GUI 106. Based on the predefined column grid, the structural design application 120 generates any number of constraints 132 that restrict the position of columns according to the predefined column grid and / or adds the predefined column grid to design instructions 130.

[0042] In the same or other embodiments, the structural design application 120 generates any number of constraints 132 that specify, but are not limited to, any number of design safety factors associated with any number and / or type of building regulations. In some embodiments, each of the design safety factors specifies, but is not limited to, the maximum allowable stress (e.g., shear stress, bending stress, etc.) of a type of structural member under one or more types of loads. Some examples of design safety factors include, but are not limited to, bending and vertical deflection safety factors for beams and slabs, shear safety factors for beams and slabs, vibration safety factors for slabs, and lateral deflection limits for frames. In some embodiments, design safety factors may be defined separately for the serviceability limit state and the maximum limit state.

[0043] Objective function 134 encapsulates any number and / or type of design objectives in any technically feasible manner. Some examples of design objectives include, but are not limited to, minimizing total weight, minimizing occult carbon, minimizing material cost, and minimizing material waste, to name a few. In some embodiments, structural design application 120 receives objective function 134 as user input (e.g., via GUI 106). In other embodiments, structural design application 120 may generate objective function 134 in any technically feasible manner.

[0044] In some embodiments, objective function 134 quantifies the degree of convergence of the design or any part thereof with the design objective. Objective function 134 can be expressed in any technically feasible manner. In some embodiments, objective function 134 is a composite function. In the same or other embodiments, objective function 134 is a set of measures, each associated with one or more design objectives.

[0045] The value of objective function 134 is also collectively referred to herein as the "objective value" and is specifically referred to as the "objective value". In some embodiments, structural design application 120 attempts to maximize objective function 134. In some other embodiments, structural design application 120 attempts to minimize objective function 134. In some embodiments, structural design application 120 incorporates any number and / or type of constraints 132 into objective function 134 as penalties in any technically feasible manner. In the same or other embodiments, any number of penalties are ignored during different optimization operations, depending on the design variables being optimized during the optimization operation. For example, in some embodiments, iteration size setting application 180 ignores any penalties associated with grid spacing.

[0046] Design variable data 136 includes, but is not limited to, any quantity and / or type of data that at least partially defines the design space of the structural system associated with design problem definition 122. For example, in some embodiments, design variable data 136 includes, but is not limited to, any number of cross-section databases of any number of structural members of any number of types, any number and / or type of permissible size ranges of any number of structural members of any number of types, local availability and relative and / or actual cost of each material (reinforced concrete, precast concrete, reinforced masonry, structural steel, cold-formed steel, timber, etc.), implicit carbon, or any combination thereof.

[0047] Parameter data 138 includes, but is not limited to, values ​​of any number and / or type of parameters associated with structural design application 120, gravity design application 140, grid generation application 150, iterative optimization application 172, frame specification application 170, iterative size setting application 180, or any combination thereof. In some embodiments, parameter data 138 includes, but is not limited to, a maximum change count (not shown), denoted herein as N, which limits the total number of options retained at any number of points in the overall design flow and / or at any number of points in any number of design flows associated with any number of composition optimization problems. In the same or other embodiments, parameter data 138 includes, but is not limited to, any number and / or type of completion criteria associated with any number of iterative portions of any number of design flows associated with any number of composition optimization problems. In some embodiments, parameter data 138 may include any number and / or type of set of settings based on a trade-off between accuracy and speed.

[0048] Wind directions 164(1) to 164(W) specify any number of directions associated with wind loads to be considered by the structural design application 120. In some embodiments, each of the wind loads is a load imposed on the building by wind. For purposes of explanation only, wind directions 164(1) to 164(W) are also referred to herein individually as “wind direction 164” and collectively as “wind direction 164”. In some embodiments, the structural design application 120 determines wind direction 164 based on user input (e.g., received via GUI 106). In the same or other embodiments, the structural design application 120 may determine wind direction 164 in any technically feasible manner.

[0049] Building wind load data 162 specifies, but is not limited to, any amount and / or type of lateral load caused by wind that the building is designed to resist. In some embodiments, building wind load data 162 includes, but is not limited to, different building wind loads (not shown) for each of the wind directions 164(1) to 164(W). Structural design application 120 or iterative sizing application 180 may determine building wind load data 162 in any technically feasible manner. For example, in some embodiments, structural design application 120 or iterative sizing application 180 calculates building wind load data 162 based on building profile 126, wall locations, the structural system being created, and user input (e.g., received via GUI 106) specifying, but not limited to, average wind speed, structural factors, terrain category, mountain factors, or any combination thereof.

[0050] In some implementations, after generating the design problem definition 122, the structural design application 120 defines the overall design optimization problem as generating any number of designs for the building's structural system based on objective function 134 and constraints 132, while taking into account gravity and building wind loads. The structural design application 120 then decomposes the overall design problem into component optimization problems. In some implementations, the structural design application 120 decomposes the overall design problem into layout and gravity design optimization problems, frame grid optimization problems, frame system definition optimization problems, vertical and lateral load design optimization problems, or any combination thereof.

[0051] In some implementations, to initiate the overall design process, the structural design application 120 configures the gravity design application 140 to address layout and gravity design optimization issues. More specifically, in some implementations, the structural design application 120 configures the gravity design application 140 to generate gravity designs 148(1) to 148(N) and optionally evaluates gravity design target values ​​146(1) to 146(N) based on building plan 124 and design instructions 130, where N can be any positive integer. For illustrative purposes only, gravity designs 148(1) to 148(N) are also referred to herein individually as “gravity design 148” and collectively as “gravity design 148”. Similarly, gravity design target values ​​146(1) to 146(N) are also referred to herein individually as “gravity design target value 146” and collectively as “gravity design target value 146”.

[0052] Each gravity design 148 is a different CAD design of the building's structural system optimized based on objective function 134 and constraints 132, while taking gravity into account but not the building's wind load. "CAD design" is also referred to herein as "design". In some implementations, the design of any part (including all) of the structural system specifies, but is not limited to, the CAD layout of that part of the structural system. Figure 1 (not shown in the image) and any quantity and / or type of size setting data ( Figure 1 (Not shown in the diagram). In the same or other embodiments, each design of any part (including all) of the structural system may additionally specify, but is not limited to, any amount and / or type of connection data (…). Figure 1 (not shown in the image), frame system ( Figure 1 (not shown in the image), any quantity and / or type of load data ( Figure 1 (not shown in the image), or any combination thereof.

[0053] The term "CAD layout" is also referred to herein as "layout". In some embodiments, a "layout" for any part (including all) of a structural system specifies, but is not limited to, the location, type, and material of each of any number of structural members included in that part of the structural system. In some embodiments, the structural members specified in each layout include, but are not limited to, any number of slabs, beams, and columns in any combination.

[0054] In some embodiments, sizing data includes, but is not limited to, sizing settings for any number and / or type of structural members specified in the layout. As described herein, the sizing setting for a given structural element may specify, but is not limited to, any amount and / or type of data that affects the size of the structural element. For example, in some embodiments, the sizing setting for a reinforced concrete slab specifies the grade of concrete, the thickness of the slab, and the thickness and distribution of the reinforcing steel. In the same or other embodiments, the sizing setting for a steel column specifies the cross-sectional profile.

[0055] In some implementations, the connection data specifies, but is not limited to, any number and / or type of joints. Examples of joint types include, but are not limited to, rigid joints, semi-rigid joints, hinged joints, pin joints, etc. In the same or other implementations, the frame system includes, but is not limited to, any number and / or type of frame ( Figure 1 (not shown in the diagram), where each frame resists both vertical and lateral loads. In some embodiments, each frame includes, but is not limited to, any number and / or type of beams and any number and / or type of columns interconnected via moment-resisting joints. In some embodiments, in order to specify the frame system, the design includes, but is not limited to, any number of frame specifications ( Figure 1 (not shown in the image), where each framework specification specifies different frameworks in the framework system.

[0056] Since the gravity design application 140 does not consider any lateral loads (e.g., building wind loads) when generating the gravity design 148, the gravity design 148 may not include frame system specifications. The gravity design target values ​​146(1) to 146(N) are the target values ​​for gravity designs 148(1) to 148(N), respectively. The gravity design application 140 can generate the gravity design 148 in any technically feasible manner.

[0057] Combined with the following text Figure 2 In more detail, in some implementations, the gravity design application 140 implements a branch-merge design flow to generate a gravity design 148. During the branching phase, the gravity design application 140 divides each floor of the structural system into multiple segments ( Figure 1 (Not shown in the image). In some implementations, the gravity design application 140 implements a rule-based expert system to generate multiple segment layouts for each segment (not shown in the image). Figure 1(Not shown in the text). In the same or other implementations, the rule-based expert system is based on domain knowledge. For illustrative purposes only, the rules included in the domain knowledge-based rule-based expert system are also referred to herein as "domain knowledge-based rules". Each segment layout specifies, but is not limited to, the location, type, and material of any number of slabs, any number of beams, and any number of columns.

[0058] In some implementations, the gravity design application 140 independently initializes and optimizes the size setting data for each segment layout to generate an optimized segment design. Figure 1 (Not shown in the diagram). Before optimizing the sizing data, the gravity design application 140 can determine any quantity (including none) and / or type of relevant data in any technically feasible manner. For example, in some embodiments, the gravity design application 140 uses domain-knowledge-based rules to determine the slab span type (e.g., one-way span, two-way span, cantilever, etc.). In the same or other embodiments, the gravity design application 140 uses domain-knowledge-based rules to select any number of continuous beam systems (e.g., multiple groups of aligned edges) as treated as a single beam. To optimize the sizing data for a given segment design, the gravity design application 140 sequentially optimizes the sizing data of the constituent slabs, beams, and columns based on constraint 132 and objective function 134, taking gravity into account but not the building's wind load. The gravity design application 140 also calculates the target value for the optimized segment design.

[0059] During the merging phase, in some implementations, the gravity design application 140 generates multiple optimized floor designs (not shown) for each floor. To generate an optimized floor design for a given floor, the gravity design application 140 performs incremental merging of each segment based on the optimized segment design and associated target values. After each incremental merging, the gravity design application optimizes the size setting data of the merged design (not shown) and calculates the associated target values.

[0060] In some implementations, gravity design application 140 determines different combinations of optimized floor designs to generate gravity design 148. Gravity design application 140 may determine different combinations of optimized floor designs in any technically feasible manner. In some implementations, gravity design application 140 implements a genetic algorithm to combine optimized floor designs based on associated target values ​​to generate gravity design 148. For example, in some implementations, gravity design application 140 performs a genetic algorithm on target values ​​associated with a first set of values ​​for a combination of specified optimized floor designs to determine a second set of values ​​for another combination of specified optimized floor designs that is more convergent with respect to the design target. Gravity design application 140 then computes gravity design target values ​​146(1) to 146(N) based on objective function 134 and gravity designs 148(1) to 148(N), respectively.

[0061] Although not shown, in some embodiments, the structural design application 120 may not necessarily solve the frame grid optimization problem and / or the frame optimization problem. The structural design application may determine whether the frame grid optimization problem and / or the frame optimization problem has been solved in any technically feasible manner. In some embodiments, the structural design application 120 solves the frame grid optimization problem and the frame optimization problem by default. In the same or other embodiments, if the design instruction 130 includes a predefined column grid, the structural design application 120 does not solve the frame grid optimization problem. Instead, the structural design application 120 uses predefined column grid lines to determine one or more frame grids, rather than solving the frame grid optimization problem, and the techniques described herein are modified accordingly.

[0062] As those skilled in the art will recognize, beams and columns in reinforced concrete frame structural systems are typically connected via rigid joints, and thus the frame system is inherently defined. For this reason, in some embodiments, if gravity design 148 specifies a reinforced concrete frame structural system, then structural design application 120 does not address either the frame grid optimization problem or the frame optimization problem. Instead, the structural design application configures iteration size setting application 180 to generate frame specifications specifying frames in all possible locations, while simultaneously addressing vertical and lateral load design optimization problems. The techniques described herein are modified accordingly.

[0063] As shown in the figure, in some embodiments, the structural design application 120 configures the grid generation application 150 to solve a frame grid optimization problem. More specifically, in some embodiments, the structural design application 120 configures the grid generation application 150 to generate frame grids 158(1) to 158(M) based on gravity designs 148(1) to 148(N) and optionally gravity design target values ​​146(1) to 146(N) and / or any amount of parameter data 138, where M can be any positive integer. In some embodiments, each frame grid 158(1) to 158(N) is associated with each floor of the building. In some other embodiments, different subsets of frame grids 158(1) to 158(N) are associated with different subsets of floors. For example, in some implementations, some of the frame grids 158(1) to 158(N) are associated with any number of floors intended for parking, while the remainder of the frame grids 158(1) to 158(N) are associated with any number of floors intended for residential use.

[0064] Each frame grid 158(1) to 158(N) includes, but is not limited to, any number of grid line groups (not shown), wherein each group of grid lines is associated with a different direction. The grid lines collectively specify the permissible location of the frame of the building’s structural system. For purposes of explanation only, frame grids 158(1) to 158(M) are also referred to herein individually as “frame grid 158” and collectively as “frame grid 158”.

[0065] Combined with the following text Figure 4 In more detail, in some embodiments, the raster generation application 150 implements any number and / or type of unsupervised clustering techniques to generate frame raster 158. In some embodiments, the raster generation application 150 determines the edge set based on gravity design 148. Figure 1 (Not shown). The edge set includes, but is not limited to, any number of edges (not shown), where each edge corresponds to a beam connected to at least one column. In some embodiments, the grid generation application 150 generates different edge groups for each gravity design 148, and then determines the edge set based on the union of the edge groups.

[0066] Subsequently, in some implementations, the raster generation application 150 generates a weighted direction set based on the orientation of the edges included in the edge set. Figure 1 (Not shown in the image). The raster generation application 150 then applies any number and / or type of unsupervised clustering techniques to the weighted direction set to generate the base direction set (…). Figure 1 (not shown in the image), this set of basic directions includes, but is not limited to, any number of basic directions ( Figure 1 (Not shown in the image).

[0067] In the same or other implementations, the raster generation application 150 generates a weighted set of equations based on the equations of the edges included in the edge set and optionally the gravity design target value 146. Figure 1 (Not shown in the image). For each fundamental direction, the raster generation application determines a corresponding subset (not shown) of the weighted equation set, including but not limited to any number of weighted equations generally parallel to the fundamental direction.

[0068] For each subset of weighted equations, the raster generation application 150 applies any number and / or type of unsupervised clustering techniques to the subset to determine any number of raster line groups in the associated fundamental directions. Based on the raster line groups in the fundamental directions, the raster generation application 150 generates a frame raster 158. In some embodiments, each frame raster 158 includes different combinations of raster line groups for each fundamental direction.

[0069] In some implementations, the structural design application 120 generates configurations 168(1) to 168(Z) based on gravity designs 148(1) to 148(N) and frame grids 158(1) to 158(M), where Z can be any positive integer. As shown, in some implementations, configuration 168(1) includes, but is not limited to, gravity designs 148(1), frame grids 158(1), building wind load data 162, and design instructions 130. Also as shown, in some implementations, configuration 168(Z) includes, but is not limited to, gravity designs 148(N), frame grids 158(M), building wind load data 162, and design instructions 130. Generally, each configuration 168(1) to 168(N) represents a different combination of gravity designs 148(1) to 148(N) and frame grids 158(1) to 158(M). The structural design application 120 can generate configurations 168(1) to 168(Z) in any technically feasible manner. For example, in some embodiments, the structural design application 120 generates an exhaustive combination of gravity designs 148(1) to 148(N) and frame grids 158(1) to 158(M), and therefore Z equals the product of N and M. In some other embodiments, the structural design application 120 generates an exhaustive combination of the best X gravity designs from gravity designs 148(1) to 148(N) and the best X frame grids from frame grids 158(1) to 158(M), and therefore Z equals the square of X, where X can be any integer (e.g., X can be N).

[0070] In some implementations, the structural design application 120 configures the iterative optimization application 172 to independently and collaboratively solve the frame system optimization problem and the vertical and lateral load design optimization problem for each of the configurations 168(1) to 168(Z). More specifically, in some implementations, the structural design application 120 may configure any number of instances of the iterative optimization application 172 to generate structural designs 188(1) to 188(Z) and building target values ​​186(1) to 186(Z) based on the configurations 168(1) to 168(Z) sequentially, simultaneously, or in any combination thereof.

[0071] As shown in the figure, in some embodiments, the structural design application 120 configures the iterative optimization applications 172(1) to 172(Z) to independently generate corresponding structural designs 188(1) to 188(Z) and corresponding building target values ​​186(1) to 186(Z) based on configurations 168(1) to 168(Z), respectively. In some other embodiments, the structural design application 120 configures a single instance of the iterative optimization application 172 to generate structural designs 188(1) to 188(Z) and building target values ​​186(1) to 186(Z) sequentially. For illustrative purposes only, instances of the iterative optimization application 172 are also referred to herein as "iterative optimization application 172" individually and collectively as "iterative optimization application 172".

[0072] Structural designs 188(1) to 188(Z) are designs of the building's structural system optimized by the iterative optimization application 172 based on objective function 134 and constraints 132, while taking into account gravity and building wind loads. For illustrative purposes only, structural designs 188(1) to 188(Z) are also referred to individually as "structural designs 188" and collectively as "structural designs 188" in this document. Building target values ​​186(1) to 186(Z) are the target values ​​of structural designs 188(1) to 188(Z). For illustrative purposes only, building target values ​​186(1) to 186(Z) are also referred to individually as "building target values ​​186" and collectively as "building target values ​​186" in this document.

[0073] In some implementations, each instance of the iterative optimization application 172 includes, but is not limited to, different instances of the framework specification application 170 and different instances of the iteration size setting application 180. In operation, the iterative optimization application 172 coordinates any number of design optimization iterations via the framework specification application 170 and the iteration size setting application 180. The following is in conjunction with... Figure 5 A more detailed description of the framework specification application 170 is provided below. Figure 6The iteration size setting application 180 is described in more detail. For illustrative purposes only, it is combined with the context of the iterative optimization application 172(1) that generates the structural design 188(1) and the building target value 186(1) based on configuration 168(1). Figure 1 Describe the functionality of iteratively optimizing application 172.

[0074] In some implementations, to initiate the first design optimization iteration, the iterative optimization application 172(1) inputs the gravity design 148(1), the frame grid 158(1), and the wind direction 164 into the frame specification application 170. In response, the frame specification application 170 determines different sets of potential frame locations for each wind direction 164 based on the gravity design 148(1) and the frame grid 158(1). Figure 1 (Not shown in the image). For each wind direction 164, the frame specification application 170 is based on the building load centroid ( Figure 1 (Not shown in the image) The associated set of potential frame locations is divided into left frame groups ( Figure 1 (not shown in the middle) and the right frame group ( Figure 1 (Not shown in the image).

[0075] In some implementations, the framework specification application 170 will use a genetic algorithm ( Figure 1 (Not shown in the image) is configured to iterate and jointly optimize the left frame counts of the left and right frame groups respectively based on the building target value 186(1) associated with the previous design optimization iteration (if any). Figure 1 (not shown in the image) and right frame count ( Figure 1 (Not shown in the text). For the first design optimization iteration, in some implementations, the genetic algorithm randomly determines the left frame count and the right frame count. As described in more detail below, the iteration size setting application 180 generates structural designs 188(1) and calculates the building target value 186(1) to complete each design optimization iteration.

[0076] For each left frame group, the frame specification application 170 selects the associated left frame counts from locations within the left frame group in descending order of distance from the building's load center of mass. Similarly, for each right frame group, the frame specification application 170 selects the associated right frame counts from locations within the right frame group in descending order of distance from the building's load center of mass. The frame specification application 170 then generates the frame system specification 178(1) based on the selected locations. In some embodiments, for each selected location, the frame system specification 178(1) specifies, but is not limited to, that the structural members associated with the selected location included in the gravity design 148(1) will be interconnected via moment joints.

[0077] To initiate each subsequent design optimization iteration, the iterative optimization application 172(1) inputs the building target value 186(1) generated by the iteration size setting application 180 during the previous design optimization iteration into the frame specification application 170. In response, the frame specification application 170 inputs the building target value 186(1) into a genetic algorithm. The genetic algorithm redetermines the left frame count and the right frame count. Subsequently, the frame specification application 170 regenerates the frame system specification 178(1) based on the redetermined left frame count and the redetermined right frame count.

[0078] In some other implementations, the frame specification application 170 does not divide the set of potential frame locations into left and right frame groups. Instead, the frame specification application 180 configures a genetic algorithm to iteratively and collectively optimize the Boolean value of each potential frame location on the set of potential frame locations based on a building target value 186(1) associated with a previous design optimization iteration (if any). During each design optimization iteration, after determining the Boolean value of a potential frame location using the genetic algorithm, the frame specification application 170 selects the location from the set of potential frame locations whose Boolean value is true. Subsequently, the frame specification application 170 generates a frame system specification 178(1) for the frame system, which specifies, but is not limited to, the different frames at each selected location.

[0079] To complete each design optimization iteration (including the first design optimization iteration), the iterative optimization application 172(1) inputs the frame system specification 178(1), gravity design 148(1), design instructions 130, and building wind load data 162 into the iterative sizing application 180. In response, in some embodiments, the iterative sizing application 180 adds the frame specification according to the frame system specification 178(1) to the gravity design 148(1) to generate the current structural design (not shown). In this way, the current structural design specifies a frame system including, but not limited to, any number of frames.

[0080] In some implementations, the iterative sizing application 180 defines and iteratively solves a nested optimization problem to optimize the sizing settings of beams and columns included in the current structural design based on constraints 132 and an objective function 134, while taking into account gravity and building wind loads. To begin each top-level iteration of the nested optimization problem, the iterative sizing application 180 iteratively optimizes the column sizing data based on constraints 132 and the objective function 134, thereby updating the dead loads after each iteration while keeping the wind loads on the structural members constant. The iterative sizing application 180 then iteratively performs any number of intermediate iterations.

[0081] To initiate each intermediate-level iteration, the iteration sizing application 180 distributes the building wind loads across the frames corresponding to the frame code of the current structural design to generate fixed lateral loads for each frame. For each frame, the iteration sizing application 180 initiates any number of bottom-level iterations. During each bottom-level iteration for a given frame, the iteration sizing application 180 iteratively optimizes the sizing settings of the columns and beams within the frame based on the fixed lateral loads associated with the frame. It should be noted that during each bottom-level iteration, the iteration sizing application 180 iteratively redistributes the fixed lateral loads across the structural elements within the associated frame.

[0082] After solving the nested optimization problem, the iteration size setting application 180 sets the structural design 188(1,1) to be equal to the current structural design. The iteration size setting application 180 then calculates the building target value 186(1) based on the structural design 188(1) and the objective function 134.

[0083] The iterative optimization application 172(1) then determines whether to begin another design optimization iteration. The iterative optimization application 172(1) may determine whether to begin another design optimization iteration in any technically feasible manner. In some embodiments, the iterative optimization application 172(1) determines whether to mimic another design optimization iteration based on any number and / or type of completion criteria specified via parameter data 138. In some embodiments, if the iterative optimization application 172(1) determines to begin another design optimization iteration, then the iterative optimization application 172(1) inputs the building target value 186(1) into the frame specification application 170. Otherwise, the iterative optimization application 172(1) transmits the structural design 188(1) and the building target value 186(1) to the overall ranking engine 190.

[0084] In some implementations, after the overall ranking engine 190 receives structural designs 188(1) to 188(Z) and building target values ​​186(1) to 186(Z), the overall ranking engine 190 generates a ranked list of structural designs 198. The ranked list of structural designs 198 includes, but is not limited to, structural designs 188 and building target values ​​186 associated with structural designs 188. In some implementations, the overall ranking engine 190 assigns structural designs 188 in the ranked list of structural designs 198 in descending order of convergence with the design target based on the building target values ​​186.

[0085] As shown in the figure, in some embodiments, the overall ranking engine 190 transmits the ranked structural design list 198 to the interface engine 108 for display via the GUI 106. In the same or other embodiments, the structural design application 120 stores any part (including none or all) and / or any number of solutions to any number of composition optimization problems from the ranked structural design list 198 in any memory available to at least one other software application. In some embodiments, the structural design application 120 transmits any part (including none or all) and / or any number of solutions to any number of composition optimization problems from the ranked structural design list 198 to any number of other software applications in any technically feasible manner.

[0086] In some implementations, structural design application 120, gravity design application 140, grid generation application 150, iterative optimization application 172, frame specification application 170, iterative sizing application 180, or any combination thereof, use any number and / or type of trained machine learning models to design, optimize, and / or analyze any number and / or type of structural elements, layouts, designs, frame systems, frames, or any combination thereof. In the same or other implementations, structural design application 120, gravity design application 140, grid generation application 150, iterative optimization application 172, frame specification application 172, iterative sizing application 180, or any combination thereof, store any amount of training data for training and / or retraining any number and / or type of machine learning models.

[0087] It should be noted that in some implementations, structural design application 120, gravity design application 140, grid generation application 150, iterative optimization application 172, frame specification application 170, iterative sizing application 180, or any combination thereof, apply any number and / or type of design and / or structural engineering foundations to design, optimize, and / or analyze any number and / or type of structural elements, layouts, designs, frame systems, frames, or any combination thereof.

[0088] Examples of design and structural engineering fundamentals include, but are not limited to, the concept of displacement, structural idealization, the superposition principle, and the compatibility of the portal method and the section method. For example, in some implementations, structural design application 120, gravity design application 140, and iterative sizing application 180 generate idealized structures of slabs, beams, columns, frames, and / or frame systems to simplify the analysis and / or design of different parts (including all) of the structural system.

[0089] Advantageously, incorporating the functionality of any quantity (inclusive) described herein in the context of structural design application 120, gravity design application 140, grid generation application 150, iterative optimization application 172, frame specification application 170, and iterative sizing application 180 into the CAD application increases the likelihood that the CAD application can generate optimized designs of the structural system that are more convergent to the design objectives. In this regard, compared to existing techniques that use finite element analysis to evaluate designs manually created based on designer intuition, using trained machine learning models and / or design and structural engine foundations to evaluate design decisions can significantly reduce the time required to optimize the design. Furthermore, compared to conventional CAD applications, structural design application 120 can explore the design space of the structural system more effectively and systematically because it decomposes the overall optimization design problem into multiple component optimization problems. In the same or other implementations, because any number of interface engines 108, gravity design applications 140, grid generation applications 150, frame specification applications 170, and iteration size setting applications 180 can be configured to retain only the best solution, the design space of the structural system can be explored in a more direct and therefore more efficient manner.

[0090] It should be noted that the techniques described herein are illustrative and not restrictive, and changes may be made without departing from the broader spirit and scope of the invention. Many modifications and variations to the functionality provided by the structural design application 120, interface engine 108, gravity design application 140, grid generation application 150, iterative optimization application 172, frame specification application 170, iterative sizing application 180, and overall ranking engine 190 will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. For example, in some embodiments, the functionality of any number of the structural design application 120, grid generation application 150, iterative optimization application 172, frame specification application 170, and iterative sizing application 180 may be modified to perform optimization operations based on any number and / or type of lateral loads, in addition to or instead of building wind loads.

[0091] It should be understood that the system 100 shown herein is illustrative, and variations and modifications are possible. For example, the functionality provided by the structural design application 120, interface engine 108, gravity design application 140, grid generation application 150, iterative optimization application 172, frame specification application 170, iterative sizing application 180, and overall ranking engine 190 as described herein can be integrated into or distributed across any number of software applications (including one) and any number of components of system 100. Furthermore, modifications can be made as needed. Figure 1 The connection topology between various units in the system.

[0092] In some implementations, any number of gravity design applications 140, grid generation applications 150, iterative optimization applications 172, frame specification applications 170, and iterative sizing applications 180 can be executed independently by any number of software applications and / or users in any technically feasible manner.

[0093] Gravity design generated through a branch-merge design process

[0094] Figure 2 It is based on various implementation plans. Figure 1 More detailed illustrations of the gravity design application 140. As previously combined in this article Figure 1 The gravity design application 140 addresses layout and gravity design optimization issues. In some implementations, to address layout and gravity design optimization issues, the gravity design application 140 generates a gravity design 148 and a gravity design target value 146 based on the building plan 124 and design instructions 130.

[0095] As previously mentioned in this article Figure 1 Each of the gravity designs 148 is a different design of the structural system optimized based on constraints 132 and objective function 134 without considering building wind loads. In some embodiments, the gravity design application 140 implements a branch-merge design flow to generate the gravity design 148. In the same or other embodiments, the gravity design application 140 includes, but is not limited to, any number of instances (not explicitly shown) of a design concept engine 220, a floor design engine 210, and a multi-floor optimizer 290.

[0096] In some implementations, the design concept engine 220 divides the layout and gravity design optimization problem into different floor optimization problems for each floor of the building. As shown in the figure, in some implementations, the design concept engine 220 generates floor structure templates 222(1) to 222(F) based on floor profiles 128(1) to 128(F) and design instructions 130, respectively. For illustrative purposes only, floor structure templates 222(1) to 222(F) are also referred to herein as “floor structure template 222” and collectively as “floor structure template 222”.

[0097] Each floor structure template 222 is a template for a layout corresponding to a portion of the structural system for a different floor. The portion of the structural system corresponding to each floor in the building is also individually referred to herein as a “floor structure” and collectively as “floor structure”. In some embodiments, each layout of a given floor structure includes, but is not limited to, any number and / or type of horizontal structural members associated with the corresponding floor and any number and / or type of vertical structural members designed as part of the floor structure. In the same or other embodiments, the vertical structural members designed as part of a given floor structure include, but are not limited to, any number and / or type of vertical members extending downwards from the floor to the adjacent lower floor (if present) or the foundation. In some embodiments, each layout of a given floor structure specifies, but is not limited to, the location, type, and material of slabs, any number of beams, and any number of columns.

[0098] Design concept engine 220 can generate floor structure templates 222 in any technically feasible manner. In some embodiments, design concept engine 220 generates floor structure templates 222(1) to 222(W), each floor structure template specifying, but not limited to, a slab (not shown), characterized by a slab material / type (not shown) and having a location with dimensions respectively specified in relation to the dimensions of floor profiles 128(1) to 128(W). In the same or other embodiments, the horizontal cross-sections of the slabs specified in floor structure templates 222(1) to 222(W) respectively match the floor profiles 128(1) to 128(W).

[0099] An example of slab material / type is a two-way reinforced concrete slab with reinforced concrete beams constructed using square panels with an aspect ratio of 1.0. Another example of slab material / type is a precast hollow slab with precast beams constructed using rectangular panels with an aspect ratio of 1.25. Yet another example of slab material / type is a post-tensioned slab constructed using rectangular panels with an aspect ratio of 1.5. The Design Concept Engine 220 can determine slab material / type in any technically feasible manner.

[0100] In some implementations, the panel material / type is specified in design instruction 130. In other implementations, design concept engine 220 implements any number of expert system techniques to determine the panel material / type. For example, in some implementations, design concept engine 220 determines the panel material / type based on one or more rules included in a knowledge base (not shown) based on the dimensions of floor profile 128, constraints 132, objective function 134, design variable data 136, or any combination thereof.

[0101] In some implementations, the design concept engine 220 configures the floor design engine 210 to independently address the floor optimization problem for each floor structure. More precisely, the design concept engine 220 configures the floor design engine 210 to generate ranked floor design lists 288(1) to 288(F) based on floor structure templates 222(1) to 222(F) and design instructions 130, respectively. For illustrative purposes only, the ranked floor design lists 288(1) to 288(F) are also referred to herein separately as “ranked floor design list 288” and collectively as “ranked floor design list 288”.

[0102] Although not shown, each of the ranked floor design list 288 is associated with a different floor structure, and specifies, but is not limited to, any number of instances of the optimized local design 268. Figure 2 (not explicitly shown in the text) and the corresponding instance of the local target value 266 ( Figure 2 (Not explicitly shown in the text). For illustrative purposes only, instances of optimized local design 268 are also referred to herein as "optimized local design 268" and collectively as "optimized local design 268". Similarly, for illustrative purposes only, instances of local target value 266 are also referred to herein as "local target value 266" and collectively as "local target value 266".

[0103] Each optimized local design 268 is a design of at least a portion of the structural system, and specifies, but is not limited to, size setting data for the constituent structural members optimized based on constraints 132 and objective function 134 without considering lateral loads. Each local objective value 266 corresponds to a different one of the optimized local designs 268 and is the value of objective function 134 of the optimized local design 268.

[0104] Each optimized local design 268 included in the ranked list 288 of floor designs associated with a given floor structure is a different design of the floor structure. For illustrative purposes only, the optimized local design 268 corresponding to a given floor structure is also referred to herein as “optimized local design 286 of the floor structure” and collectively as “optimized local design 268 of the floor structure”.

[0105] Design concept engine 220 can configure any number of instances of floor design engine 210 to generate ranked floor design lists 288(1) to 288(F) in any technically feasible manner, sequentially, simultaneously, or in any combination thereof. For purposes of explanation only, instances of floor design engine 210 are also referred to herein individually as “floor design engine 210” and collectively as “floor design engine 210”.

[0106] As shown in the figure, in some embodiments, the gravity design application 140 configures the floor design engines 210(1) to 210(F) to simultaneously generate ranked floor design lists 288(1) to 288(F) based on floor structure templates 222(1) to 222(F) and design instructions 130, respectively. In some other embodiments, the design concept engine 220 configures a single instance of the floor design engine 210 to generate ranked floor design lists 288(1) to 288(F) sequentially.

[0107] The floor design engine 210 can generate a ranked list 288 of floor designs for a given floor structure based on the floor structure template 222 and design instructions 130, in any technically feasible manner. For illustrative purposes only, the following... Figure 2 The functionality of the floor design engine 210(1) in some embodiments is described in more detail within the context of the floor design engine 210(1) that generates a ranked list of floor designs 288(1) based on the floor structure template 222(1) and design instructions 130. For illustrative purposes only, both the floor structure template 222(1) and the floor structure template 222(1) are associated with the first floor structure.

[0108] In some implementations, the floor design engine 210(1) includes, but is not limited to, any number of instances (not explicitly shown) of the partitioning engine 224, the segment design engine 240, and the incremental merging engine 280. The partitioning engine 224 divides the floor optimization problem associated with a given floor structure into multiple distinct segment optimization problems. In some implementations, the partitioning engine 224 may divide each floor optimization problem into a different number of segment optimization problems.

[0109] In some implementations, for each floor structure, each segment optimization problem is associated with a different portion of the floor structure, represented as segment 230 (not explicitly shown). For illustrative purposes only, instances of segment 230 are also referred to individually as "segment 230" and collectively as "segment 230" herein. The partitioning engine 224 can generate segments 230 associated with a given floor structure in any technically feasible manner.

[0110] As shown in the figure, in some embodiments, the partitioning engine 224 generates segments 230(1) to 230(S) based on the floor structure template 222(1) and design instructions 130, where S can be any positive integer. In the same or other embodiments, each segment 230(1) to 230(S) associated with the floor structure template 222(1) is associated with a different portion of the slab specified in the floor structure template 222(1). In some embodiments, the partitioning engine 224 determines the value of S before generating segments 230(1) to 230(S). For example, in some embodiments, the partitioning engine 224 sets S to be equal to the maximum change count (denoted as N) specified in parameter data 138. In some other embodiments, the value of S is indirectly defined by the number of segments 230 generated by the partitioning engine 224 based on the floor structure template 222(1).

[0111] In some embodiments, the partitioning engine 224 implements a rule-based expert system to partition the floor structure template 222(1) into segments 230(1) to 230(S) based on any amount and / or type of data included in the design instructions 130. In the same or other embodiments, the partitioning engine 224(1) partitions the floor structure template 222(1) into segments 230(1) to 230(S) at least in part based on the shape of the floor structure template 222 and / or the associated board material / type.

[0112] For example, in some embodiments, if the floor is U-shaped, then the partitioning engine 224 partitions the floor structure template 222 into at least one or more east wings, one or more center wings, and one or more west wings. In the same or other embodiments, if the panel material / type corresponding to the floor structure template 222 specifies that the panel is constructed of panels, then the partitioning engine 224 partitions the floor structure template 222 into segments 230(1) to 230(S) at least in part based on the size of each panel.

[0113] The partitioning engine 224 configures the segment design engine 240 to independently solve the segment optimization problem for each segment 230(1) to 230(S). In some implementations, in order to solve the segment optimization problem for segments 230(1) to 230(S), the partitioning engine 224 configures the segment design engine 240 to generate ranked segment design lists 278(1) to 278(S) based on segments 230(1) to 230(S) and design instructions 130, respectively.

[0114] The ranked segment design lists 278(1) to 278(S) are subsets (not explicitly shown) of instances of the ranked segment design list 278 associated with the floor structure template 222(1). Generally, each instance of the segment design list 278 is associated with a different instance of the segment 230. For illustrative purposes only, instances of the ranked segment design list 278 are also referred to individually herein as “ranked segment design list 278” and collectively as “ranked segment design list 278”. Although not shown, each ranked segment design list 278 specifies, but is not limited to, any number of optimized local designs 268 and corresponding instances of local target values ​​266 of the associated segment 230.

[0115] The partitioning engine 224 can configure any number of instances of the segment design engine 240 to generate ranked lists of segment designs 278(1) to 278(S) in any technically feasible manner, sequentially, simultaneously, or in any combination thereof. For purposes of explanation only, instances of the segment design engine 240 are also referred to herein individually as “segment design engine 240” and collectively as “segment design engine 240”.

[0116] As shown in the figure, in some implementations, the partitioning engine 224(1) configures the segment design engines 240(1) to 240(S) to simultaneously generate ranked segment design lists 278(1) to 278(S) based on segments 230(1) to 230(S) and design instructions 130, respectively. In some other implementations, the partitioning engine 224(1) configures a single instance of the segment design engine 240 to generate ranked segment design lists 278(1) to 278(S) sequentially.

[0117] The segment design engine 240 can generate each of the ranked segment designs in the list 278 in any technically feasible manner. For illustrative purposes only, the following... Figure 2 The functionality of the segment design engine 240 in some embodiments is described in more detail within the context of the segment design engine 240(1) that generates a ranked list of segment designs 278(1) based on segment 230(1) and design instructions 130. As shown in the figure, in some embodiments, the segment design engine 240 includes, but is not limited to, any number of instances of a layout variation engine 250, a gravity design optimizer 260, and a segment design ranking engine 270.

[0118] In some implementations, the layout variation engine 250 generates local designs 258(1) to 258(K) based on segment 230(1) and design instructions 130, where K can be any positive integer. Local designs 258(1) to 258(K) are subsets of instances of local designs 258 associated with segment 230(1). Figure 2(Not explicitly shown). In some implementations, the layout variation engine 250 can generate a different number of instances of local designs 258 for each segment 230.

[0119] For illustrative purposes only, instances of local design 258 are also referred to individually as "local design 258" and collectively as "local design 258" herein. Each local design 258 is a design of at least a part of the structural system. For each segment 230, the local design 258 generated by the layout variation engine 250 based on segment 230 is a different design of segment 230 and is also referred to herein as "local design 258 of segment 230".

[0120] The layout variation engine 250 can determine the value of K in any technically feasible manner. For example, in some embodiments, the layout variation engine 250 sets K to be equal to the maximum variation count (denoted as N) specified in parameter data 138. In some other embodiments, the value of K is indirectly defined by the number of local designs 258 generated by the layout variation engine 250 for segment 230 (1). The layout variation engine 250 can generate any number of local designs 258 for each segment 230 in any technically feasible manner.

[0121] In some implementations, the layout variation engine 250 includes, but is not limited to, any number of instances of segment layout 252 (not explicitly shown), and the layout variation engine 250 generates a partial design 258 of segment 230 based on instances of segment layout 252. For illustrative purposes only, instances of segment layout 252 are also individually referred to herein as “segment layout 252” and collectively as “segment layout 252”. Each segment layout 252 is a layout of segment 230. Each segment layout 252 generated by the layout variation engine 250 based on segment 230 is a different layout of segment 230. The layout variation engine 250 can generate segment layout 252 in any technically feasible manner.

[0122] In some embodiments, the layout variation engine 250 implements any number and / or type of expert system technology to generate any number of segment layouts 252 based on segment 230 and optionally any amount (including none) of design instructions 130. For example, in some embodiments, the layout variation engine 250 generates any number of segment layouts 252 based on segment 230, any number of rules included in a knowledge database (not shown), and any amount (including none) of design instructions 130.

[0123] In the same or other implementations, the layout variation engine 250 uses a “filtered” trained machine learning model to predict which (if any) segments of the layout 252 are below standard. The layout variation engine 250 then discards any segment layouts 252 predicted to be below standard. In some implementations, the layout variation engine 250 and / or the gravity design application 140 store any amount and / or type of training data for retraining the filtered trained machine learning model.

[0124] For illustrative purposes only, in some embodiments, the layout change engine 250 generates and subsequently does not discard segment layouts 252(1) to 252(K) based on segment 230(1). The layout change engine 250 initializes each of the local designs 258(1) to 258(K) to an empty design. The layout change engine 250 then copies the segment layouts 252(1) to 252(K) to the local designs 258(1) to 258(K), respectively. In some embodiments, the layout change engine 250 specifies default values ​​for any quantity and / or type of size setting data and / or any quantity and / or type of connection data in the segment layout 252. For example, in some embodiments, the layout change engine 250 specifies that each connection between structural members of each local design 258 is a rigid joint. In some other embodiments, for each local design 258, the layout change engine 250 specifies that each of the connections on the outer perimeter of the building is a rigid joint and the other connections are hinged joints or pin joints.

[0125] As shown in the figure, in some implementations, the layout variation engine 250 configures the gravity design optimizer 260 to generate optimized local designs 268(1) to 268(K) and local target values ​​266(1) to 266(K) based on local designs 258(1) to 258(K) and design instructions 130. The layout variation engine 250 can configure any number of instances of the gravity design optimizer 260 to generate optimized local designs 268(1) to 268(K) and local target values ​​266(1) to 266(K) in any technically feasible manner, sequentially, simultaneously, or in any combination thereof. For purposes of explanation only, instances of the gravity design optimizer 260 are also referred to herein individually as "gravity design optimizer 260" and collectively as "gravity design optimizer 260".

[0126] As shown in the figure, in some embodiments, the layout variation engine 250 configures gravity design optimizers 260(1) to 260(K) to generate optimized local designs 268(1) to 268(K) and local target values ​​266(1) to 266(K) respectively based on local designs 258(1) to 258(K) and design instructions 130. In some other embodiments, the layout variation engine 250 configures a single instance of gravity design optimizer 260 to generate optimized local designs 268(1) to 268(K) and local target values ​​266(1) to 266(K) sequentially.

[0127] The gravity design optimizer 260 can perform any number and / or type of optimization operations on the size settings of the structural components included in the local design 258 to generate an optimized local design 268. (See below for reference.) Figure 3 In more detail, in some implementations, the gravity design optimizer 260 sequentially optimizes the size settings of the plates, beams and columns included in the local design 258 to generate an optimized local design 268.

[0128] As shown in the figure, in some implementations, the segment design ranking engine 270 generates a ranked list of segment designs 278(1) based on optimized local designs 268(1) to 268(K) and local target values ​​266(1) to 266(K). The segment design ranking engine 270 can generate the ranked list of segment designs 278(1) in any technically feasible manner. For example, in some implementations, the segment design ranking engine 270 ranks the optimized local designs 268(1) to 268(K) based on local target values ​​266(1) to 266(K).

[0129] In some implementations, the segment design ranking engine 270 filters out any number of optimized local designs 268(1) to 268(K) based on any number and / or type of filtering criteria when generating a ranked segment design list 278(1). Therefore, in such an implementation, the total number of optimized local designs 268 specified in the ranked segment design list 278(1) is less than K. The optimized local designs 268(1) to 268(K) are also referred to herein as “potential segment designs”, and the optimized local designs 268 specified in the ranked segment design list 178(1) are also referred to herein as “segment designs”. For example, in some implementations, the filtering criteria are N best items among the local target values ​​266(1) to 266(K) and associated optimized local designs 268(1) to 268(K) specified via the ranked segment design list 278(1), where N is the maximum change count. The segment design ranking engine 270 discards the remaining local target values ​​266(1) to 266(K) and the associated optimized local designs 268(1) to 268(K).

[0130] In some implementations, for each floor, the floor design engine 210 configures the incremental merging engine 280 to generate a ranked floor design list 288 associated with the floor based on a ranked segment design list 278 and design instructions 130. In the same or other implementations, the incremental merging engine 280 includes, but is not limited to, any number of instances of the gravity design optimizer 260. The incremental merging engine 280 can generate the ranked floor design lists 288(1) to 288(S) in any technically feasible manner.

[0131] In some implementations, the floor design engine 210(1) configures the incremental merging engine 280 to generate a ranked floor design list 288(1) based on the ranked segment design lists 278(1) to 278(S) and design instructions 130. Each optimized local design 268 included in the ranked floor design list 288(1) is a design of the first floor structure optimized based on constraints 132 and objective function 134 without considering lateral loads. In some implementations, each optimized local design 268 included in the ranked floor design list 288(1) is generated based on a different set of S instances of optimized local designs 268. Each set of S instances includes, but is not limited to, one of the optimized local designs 268 from each of the ranked segment design lists 278(1) to 278(S) associated with the first floor structure.

[0132] In some implementations, the incremental merging engine 280 performs (S-1) different expansion iterations to generate a ranked list of floor designs 288(1). During the first expansion iteration, the incremental merging engine 280 sets the segment ranking value of each segment 230(1) to 230(S) to be equal to the best value among the local objective values ​​266 included in the ranked list of segment designs 278(1) to 278(S), respectively. The incremental merging engine 280 selects segment 230 with the worst segment ranking value from segments 230(1) to 230(S) as the first merging participant. In some implementations, the structural design application 120 attempts to maximize the objective function 134, and the worst segment ranking value is the lowest value among the segment ranking values. In some other implementations, the structural design application 120 attempts to minimize the objective function 134, and the worst segment ranking value is the highest value among the segment ranking values. The incremental merging engine 280 then selects the segment with the worst segment ranking from a subset of segments 230(1) to 230(S) adjacent to the first merging participant as the second merging participant.

[0133] The incremental merging engine 280 performs any number of merging operations between the optimized local design 268 of the first merging participant and the optimized local design 268 of the second merging participant to generate any number of new instances of local design 258. Each new instance of local design 258 represents both merging participants and is also referred to herein as a “local floor design”. The incremental merging engine 280 then configures the gravity design optimizer 260 to generate new instances of optimized local design 268 and new instances of local target values ​​266 based on the new instances of local design 258 and design instructions 130. The incremental merging engine 280 generates a ranked list of merged designs (not shown), which includes, but is not limited to, N new instances of optimized local design 268 corresponding to N best new local target values.

[0134] For each subsequent expansion iteration, the incremental merging engine 280 selects a new merging participant with the worst segment ranking value from a subset of segments 230(1) to 230(S) that are adjacent to one of the previously selected merging participants and have not yet been selected as a merging participant. The incremental merging engine 280 then performs any number of merging operations between the optimized local design 268 of the new merging participant and the ranked list of merged designs to generate any number of new instances of local design 258. The incremental merging engine 280 regenerates the ranked list of merged designs based on the new instances of local design 258. After completing (S-1) expansion iterations, the incremental merging engine 280 sets the ranked list of floor designs 288(1) to be equal to the ranked list of merged designs.

[0135] In some other embodiments, the incremental merging engine 280 executes any number and / or type of search algorithms and / or optimization algorithms to generate a ranked list of floor designs 288 (1). For example, in some embodiments, the incremental merging engine 280 may execute any number and / or type of genetic algorithms, any number and / or type of harmony search algorithms, any number and / or type of integer optimization algorithms, gravity design optimizer 260, or any combination thereof to generate a ranked list of floor designs 288 (1).

[0136] As shown in the figure, in some implementations, the gravity design application 140 configures multi-floor optimization 290 to generate gravity designs 148(1) to 148(N) and gravity design target values ​​146(1) to 146(N) based on a ranked list of floor designs 288(1) to 288(F). In some implementations, the gravity design application 140 generates each gravity design 148(1) to 148(N) based on a different set of F optimized local designs in the optimized local designs 268. Each set of the F optimized local designs of the optimized local designs 268 includes, but is not limited to, one of the optimized local designs 268 from each ranked list of floor designs 288(1) to 288(F).

[0137] In some implementations, the multi-floor optimizer 290 performs any number and / or type of incremental merging and / or aggregation operations based on a ranked list of floor designs 288(1) to 288(F) to generate gravity designs 148(1) to 148(N). In the same or other implementations, the multi-floor optimizer 290 performs any number and / or type of search algorithms in any combination to generate gravity designs 148. For example, in some implementations, the multi-floor optimizer 290 performs any number and / or type of genetic algorithms, any number and / or type of harmony search algorithms, any number and / or type of integer optimization algorithms, or any combination thereof to generate gravity designs 148.

[0138] The multi-story optimizer 290 calculates the gravity design target values ​​146(1) to 146(N) corresponding to gravity designs 148(1) to 148(N) in any technically feasible manner. For example, in some embodiments, the multi-story optimizer 290 applies objective function 134 to gravity designs 148(1) to 148(N) to calculate the gravity design target values ​​146(1) to 146(N) respectively. Because the multi-story optimizer 290 combines optimized local designs 268 corresponding to different floor structures, and the optimized local designs 268 are not necessarily optimized for lateral loads, in some embodiments, the multi-story optimizer 290 does not optimize the size setting of any structural member.

[0139] In the same or other embodiments, the multi-story optimizer 290 calculates and specifies any number of vertical loads for each gravity design 148 based on any number of vertical loads specified in the optimized local designs 268 associated with the gravity design 148. For example, in some embodiments, the multi-story optimizer 290 adds the vertical loads of the optimized local designs 268 associated with the gravity design 148 at the column interface to determine the corresponding vertical load for the gravity design 148. In the same or other embodiments, for an optimized local design 268 corresponding to a given floor structure, when there are no columns in the optimized local design 268 corresponding to a floor structure one floor lower than that floor structure, the multi-story optimizer 390 uses transfer beams. The transfer beams receive loads from such “isolated” columns and transfer the loads to one or more existing columns and / or beams in the optimized local design 268 corresponding to a floor structure one floor lower than that floor structure.

[0140] In some embodiments, the gravity design application 140 transmits any number of gravity designs 148 and / or any number of gravity design target values ​​146 to any number of other software applications in any technically feasible manner. In the same or other embodiments, the gravity design application 140 stores any number of gravity designs 148 and / or any number of gravity design target values ​​146 in memory accessible to at least one other software application. In some embodiments, the gravity design application 140 stores the gravity designs 148 and gravity design target values ​​146 in memory accessible to the structural design application 120.

[0141] Figure 3 It is based on various implementation plans. Figure 2 A more detailed illustration of the gravity design optimizer 260 is provided. As shown, in some embodiments, the gravity design optimizer 260 generates an optimized local design 268 and local target values ​​266 based on local design 258 and design instructions 130. (As previously illustrated herein...) Figure 1 Each instance of the local design 258 is a design of at least a portion of the structural system. More specifically, in some embodiments, each instance of the local design 258 received by the gravity design optimizer 260 is a design of at least a portion of one of the floor structures.

[0142] As shown in the figure, in some embodiments, the gravity design optimizer 260 generates a floor design dataset 368 based on a local design 258. In the same or other embodiments, the floor design dataset 368 includes, but is not limited to, floor layout 310, floor size setting data 320, floor live load data 322, and floor dead load data 324. In some embodiments, the floor layout 310 includes, but is not limited to, slab data 312, a beam list 314, and a column list 316. The slab data 312 specifies, but is not limited to, the location, material, and type of slabs (not shown). The beam list 314 specifies, but is not limited to, the location, material, and type of any number of beams (not shown). The column list 316 specifies, but is not limited to, the location, material, and type of any number of columns (not shown). As depicted in italics, in some embodiments, the floor layout 310 is fixed.

[0143] Floor size setting data 320 specifies, but is not limited to, any quantity and / or type of size setting data for slabs, beams, and columns specified in floor layout 310. In some embodiments, floor live load data 322 includes, but is not limited to, any quantity and / or type of live load for each room included in floor layout 310. Floor dead load data 324 includes, but is not limited to, any quantity and / or type of dead load associated with floor layout 310.

[0144] Although not shown, in some embodiments, floor design dataset 368 specifies any number and / or type of default connections between structural members specified in floor layout 310. For example, in some embodiments, floor design dataset 368 specifies that each connection between structural members specified in floor layout 310 is a rigid joint. It should be noted that floor design dataset 368 does not specify any lateral loads, and gravity design optimizer 260 does not consider any lateral loads (e.g., building wind loads).

[0145] As shown in the figure, in some embodiments, the gravity design optimizer 260 includes, but is not limited to, a gravity plate optimizer 360, a gravity beam optimizer 370, and a gravity column optimizer 380. In some embodiments, the gravity design optimizer 260 configures the gravity plate optimizer 360 to optimize the plate size settings specified in the plate data 312 based on constraint 132 and objective function 134 without considering any lateral loads. The gravity plate optimizer 360 can optimize the plate size settings in any technically feasible manner.

[0146] In some implementations, the gravity slab optimizer 360 categorizes different design options from best to worst based on corresponding target values. The gravity slab optimizer 360 then performs a binary search algorithm to find the design option with the optimal target value that satisfies constraint 132. In some other implementations, the gravity slab optimizer 360 iteratively optimizes the slab size setting via a non-gradient-based optimization algorithm. For example, in some implementations, the gravity slab optimizer 360 determines the available thickness of the slab and the available thickness of the reinforcing steel based on design variable data 136 and the type of slab. The gravity slab optimizer 360 uses structural engineering foundations to determine the minimum thickness and the minimum reinforcing steel required to satisfy constraint 132.

[0147] In some implementations, before modifying the slab size setting, the gravity slab optimizer 360 calculates initial values ​​for live and dead loads. As the gravity slab optimizer 360 iteratively modifies the slab size setting, it recalculates the associated dead loads. In some implementations, in addition to the contribution from the slab's self-weight recalculated by the gravity slab optimizer 360 when modifying the slab size setting, the initial values ​​for dead loads also include, but are not limited to, contributions from surface layers (e.g., floor tiles) that the gravity slab optimizer 360 will not subsequently change. In some implementations, after the gravity slab optimizer 360 completes modifying the slab size setting, it updates the floor size setting data 320, floor live load data 322, and floor dead load data 324. In the same or other implementations, the gravity design application 140 uses domain-knowledge-based rules to determine the slab span type (e.g., one-way span, two-way span, cantilever, etc.).

[0148] Subsequently, in some implementations, the gravity design optimizer 260 distributes dead and live loads across a subset of beams specified in beam list 314 based on slab span type. The gravity design optimizer 260 updates the floor live load data 322 and floor dead load data 324 accordingly. The gravity design optimizer 260 then configures the gravity beam optimizer 370 to optimize the beam size settings specified in beam list 314 based on constraint 132 and objective function 134, without considering any lateral loads. The gravity beam optimizer 370 can optimize the beam size settings in any technically feasible manner. For example, in some implementations, the beam optimizer 370 may use a bisection algorithm to optimize the beam size settings.

[0149] For example, in some embodiments, the gravity beam optimizer 370 iteratively optimizes the beam size setting via a binary algorithm and any number and / or type of structural engineering foundations. In the same or other embodiments, the gravity beam optimizer 370 optimizes the beam size setting via any number and / or type of expert systems and / or trained machine learning models. In some embodiments, after the gravity beam optimizer 370 has completed modifying the beam size setting, the gravity beam optimizer 370 updates the floor size setting data 320 and the floor dead load data 324.

[0150] Subsequently, in some implementations, the gravity design optimizer 260 distributes dead and live loads onto the columns specified in the column list 316 and updates the floor live load data 322 and floor dead load data 324 accordingly. The gravity design optimizer 260 then configures the gravity column optimizer 380 to optimize the column size settings specified in the column list 316 based on constraint 132 and objective function 134, without considering any lateral loads. The gravity column optimizer 380 can optimize the column size settings in any technically feasible manner.

[0151] For example, in some embodiments, the gravity column optimizer 380 iteratively optimizes the column size settings via a binary algorithm and any number and / or type of structural engineering foundations. In the same or other embodiments, the gravity column optimizer 380 optimizes the column size settings via any number and / or type of expert systems and / or trained machine learning models. In some embodiments, after the gravity column optimizer 380 has completed modifying the column size settings, the gravity column optimizer 380 updates the floor size setting data 320 and the floor dead load data 324.

[0152] As shown in the figure, in some embodiments, the gravity design optimizer 260 then generates an optimized local design 268 based on the floor design dataset 368. In some embodiments, the gravity design optimizer 260 computes a local objective value 266 based on the floor design dataset 368 and the objective function 134. In some other embodiments, the gravity design optimizer 260 computes the local objective value 266 based on the optimized local design 268 and the objective function 134.

[0153] In some embodiments, the gravity design optimizer 260 transfers the optimized local design 268 and / or local target value 266 to any number of other software applications in any technically feasible manner. In the same or other embodiments, the gravity design optimizer 260 stores the optimized local design 268 and / or local target value 266 in memory accessible to at least one other software application. In some embodiments, the gravity design optimizer 260 stores the optimized local design 268 and local target value 266 in memory accessible to the gravity design application 140.

[0154] It should be noted that the techniques described herein are illustrative and not restrictive, and may be modified without departing from the broader spirit and scope of the invention. For example, in some embodiments, gravity design optimizer 260 omits floor design dataset 368 and configures gravity plate optimizer 360, gravity beam optimizer 370, and gravity column optimizer 380 to modify local design 258 in any technically feasible manner.

[0155] Use unsupervised clustering to generate frame grids

[0156] Figure 4 It is based on various implementation plans. Figure 1 A more detailed illustration of the raster generation application 150. For illustrative purposes only. Figure 4 The described implementation scheme addresses the issues previously discussed herein. Figure 1 The raster generation application 150 is described in the context of the frame raster optimization problem.

[0157] In some embodiments, the structural design application 120 inputs gravity design values ​​148(1) to 148(N) and optionally gravity design target values ​​146(1) to 146(N) and / or any amount of parameter data 138 into the grid generation application 150. In response, the grid generation application 150 generates and outputs frame grids 158(1) to 158(M). In some other embodiments, the grid generation application 150 may be configured to generate any number and / or type of grids for any type of structural element resisting lateral loads, based at least in part on any number and / or type of design of the structural system resisting vertical loads.

[0158] As previously described herein, each gravity design 148 specifies, but is not limited to, the location, type, and material of any number of structural members that collectively resist vertical loads. In some embodiments, the gravity design target value 146(x) is related to the degree of convergence between the gravity design 148(x) and the design target, where x is an integer between 1 and N. A portion of the parameter data 138 input to the raster generation application 150 specifies, but is not limited to, parameter values ​​for any number and / or type of parameters associated with generating the frame raster 158.

[0159] As shown in the figure, in some implementations, the raster generation application 150 includes, but is not limited to, a basic orientation engine 410, a raster equation engine 440, and a raster specification engine 490. Upon receiving a gravity design 148, the raster generation application 150 generates an edge set 402. To generate the edge set 402, the raster generation application 150 initializes the edge set 402 as an empty list. For each gravity design 148, the raster generation application 150 adds beams (not shown) attached to at least one column (not shown) to the edge set 402 as edges (not shown). Therefore, the edge set 402 includes, but is not limited to, any number of edges each corresponding to a different beam. Each edge is associated with both direction and length.

[0160] In some implementations, the grid generation application 150 associates each edge with a gravity design 148 that includes a corresponding beam. In the same or other implementations, the grid generation application 150 represents each edge on the boundary of the gravity design 148, which includes a corresponding beam as a boundary edge. The grid generation application 150 may associate edges with the gravity design 148 and / or represent edges that are also boundary edges in any technically feasible manner.

[0161] In some implementations, the raster generation application 150 inputs edge set 402 and optionally any portion of parameter data 138 into a base orientation engine 410. In response, the base orientation engine 410 generates a ranked list of orientation cluster sets 408. The ranked list of orientation cluster sets 408 is described in more detail below. As shown, the base orientation engine 410 includes, but is not limited to, an orientation clustering engine 420.

[0162] In some implementations, the base direction engine 410 generates a weighted direction set 412 based on the edge set 402. To generate the weighted direction set 412, the base direction engine 410 determines the unique direction of the edges included in the edge set 402. The base direction engine 410 then weights each direction based on the total length of the non-boundary edges in that direction and the total length of the boundary edges in that direction to generate a corresponding weighted direction (not shown). Subsequently, the base direction engine 410 generates the weighted direction set 412, which includes, but is not limited to, the weighted directions. In some other implementations, the base direction engine 410 may determine and weight directions based on any amount and / or type of criteria associated with the generated frame grid 158 in any technically feasible manner.

[0163] The base direction engine 410 then inputs the weighted direction set 412 and, optionally, any portion of the parameter data 138 into the direction clustering engine 420. The direction clustering engine 420 performs any number and / or type of unsupervised clustering operations based on the weighted direction set 412 to generate direction cluster sets 428(1) to 428(D), where D can be any positive integer. The direction cluster sets 428(1) to 428(D) are also referred to herein individually as “direction cluster set 428” and collectively as “direction cluster set 428”. Each direction cluster set 428 specifies, but is not limited to, the different distributions of the weighted directions included in the weighted direction set 412 across any number of direction clusters (not shown). It should be noted that the number of direction clusters included in any given pair of direction cluster sets 428 may be the same or different.

[0164] Subsequently, the directional clustering engine 420 can perform any number and / or type of ranking and / or filtering operations on the directional cluster sets 428 to generate a ranked list of directional cluster sets 408. The directional clustering engine 420 and / or the base directional engine 410 can determine the total number (denoted herein as D) of the directional cluster sets 428 based on any amount and / or type of data in any technically feasible manner. For example, in some embodiments, the base directional engine 410 determines the value of D based on parameter data 138 and configures the directional clustering engine 420 to generate D for the directional cluster sets 428. In some other embodiments, the directional clustering engine 420 implements a default value for D.

[0165] More specifically, in some embodiments, the directional clustering engine 420 includes, but is not limited to, K-means clustering algorithms 424(1) to 424(D) and a cluster set ranking engine 430. Each of the K-means clustering algorithms 424(1) to 424(D) is a different instance (not explicitly shown) of the K-means clustering algorithm 424 that implements K-means clustering. As those skilled in the art will recognize, K-means clustering refers to a well-known unsupervised learning algorithm that generates a predetermined number of clusters. The K-means clustering algorithms 424(1) to 424(D) are also referred to herein individually as "K-means clustering algorithm 424" and collectively as "K-means clustering algorithm 424". In some embodiments, the basic directional engine 410 configures the K-means clustering algorithms 424(1) to 424(D) to simultaneously generate directional cluster sets 428(1) to 428(D).

[0166] In some other implementations, the base direction engine 410 configures fewer than D instances of the K-means clustering algorithm 424 to generate directional cluster sets 428(1) to 428(D) sequentially, simultaneously, or in any combination thereof in any technically feasible manner. For example, in some implementations, the base direction engine 410 configures a single instance of the K-means clustering algorithm 424 to generate directional cluster sets 428(1) to 428(D) sequentially.

[0167] The directional clustering engine 420(0) can be configured to generate directional cluster sets 428(1) to 428(D) respectively in any technically feasible manner for any number of instances of the K-means clustering algorithm 424. For example, in some implementations, the directional clustering engine 420(0) inputs clustering settings 422(1) to 422(D) into the K-means clustering algorithm 424(1) to 424(D) respectively. In response, the K-means clustering algorithms 424(1) to 424(D) output directional cluster sets 428(1) to 428(D) respectively.

[0168] Clustering settings 422(1) through 422(D) are also referred to herein individually as “clustering settings 422” and collectively as “clustering settings 422”. Each clustering setting 422 includes, but is not limited to, any number and / or type of different combinations of values ​​for settings associated with the K-means clustering algorithm 424. In some implementations, each clustering setting 422 specifies different combinations of K values ​​(i.e., the number of clusters to be generated) and seed settings.

[0169] The directional clustering engine 420 can determine the clustering settings 422 in any technically feasible manner. For example, in some embodiments, the directional clustering engine 420 randomly generates the K value and seed setting for each clustering setting 422. In some other embodiments, the directional clustering engine 420 determines the K value and any permissible range of seed setting heuristics based on parameter data 138. In other embodiments, the base directional engine 410 determines the clustering settings 422 based on parameter data 138 and then inputs the clustering settings 422 into the directional clustering engine 420.

[0170] As shown in the figure, in some implementations, the directional clustering engine 420 inputs directional cluster sets 428(1) to 428(D) into the cluster set ranking engine 430. In response, the cluster set ranking engine 430 performs any number and / or type of ranking and / or filtering operations on the directional cluster sets 428(1) to 428(D) to generate a ranked list of directional cluster sets 408. The ranked list of directional cluster sets 408 includes, but is not limited to, any number of directional cluster sets 428(1) to 428(D) ranked in any technically feasible manner based on any number and / or type of criteria.

[0171] In some implementations, the cluster ranking engine 430 includes, but is not limited to, the elbow rule heuristic 432. The elbow rule heuristic 432 is based on the elbow rule. As those skilled in the art will recognize, the elbow rule refers to a known type of technique used to determine the optimal number of clusters (i.e., K values) into which a set of points can be clustered. As shown, in some implementations, the elbow rule heuristic 432 determines elbow points 434 based on directional cluster sets 428. In some implementations, for each directional cluster set 428, the elbow rule heuristic 432 determines a value based on a variance metric. The elbow rule heuristic 432 clusters the K values ​​of the directional cluster sets 428 into two groups with the values ​​of the variance metric, and then sets the elbow point 434 to be equal to the intersection of these two groups.

[0172] In some implementations, for each directional cluster set 428, the cluster set ranking engine 430 calculates the distance to the elbow point 434 based on the associated K value and a variance-based metric. The cluster set ranking engine 430 then ranks the directional cluster sets 428 based on the increased distance to the elbow point 434 to generate a ranked list of directional cluster sets 408. In some implementations, the cluster set ranking engine 430 may filter out any number of directional cluster sets 428 included in the ranked list of directional cluster sets 408 based on any technically feasible criteria. For example, in some implementations, the cluster set ranking engine 430 determines the minimum required variance for the ranked list of directional cluster sets 408 based on parameter data 138. If the ranked list of directional cluster sets 408 includes those with variances greater than the required minimum, then the cluster set ranking engine 430 removes them. For example, in some implementations, the cluster set ranking engine 420 determines the maximum permissible value for the variance-based metric based on parameter data 138. For each directional cluster 428 included in the ranked directional cluster list 408, if the correlation value of the variance-based metric is higher than the maximum allowed value, the cluster ranking engine 430 removes the directional cluster 428 from the ranked directional cluster list 408.

[0173] In some implementations, the raster generation application 150 generates a base direction set 436 based on the highest-ranked direction cluster set 428, according to a ranked list of direction cluster sets 408. As shown, the base direction set 436 includes, but is not limited to, base directions 438(1) to 438(B), where B is the total number of direction sets included in the highest-ranked direction cluster set 428, and therefore can be any positive integer. Base directions 438(1) to 438(B) are also referred to herein individually as “base directions 438” and collectively as “base directions 438”. Each base direction 438 corresponds to a different direction cluster included in the highest-ranked direction cluster set 428. In some implementations, the raster generation application 150 sets each base direction 438 to be equal to the direction associated with the centroid of the corresponding direction cluster.

[0174] Subsequently, in some implementations, the raster generation application 150 inputs any portion of the basic orientation set 436, edge set 402, and optionally gravity design target values ​​146(1) to 146(N) and / or parameter data 138 into the raster equation engine 440. In response, the raster equation engine 440 generates frame rasters 158(1) to 158(M).

[0175] although Figure 4Not depicted herein, but in some other embodiments, the raster generation application 150 generates distinct instances of a base direction set 436 for each of any number of direction clusters in the ranked list 408 of direction clusters. Instances of the base direction set 436 are also collectively referred to herein as “base direction set 436”. Each base direction set 436 may include, but is not limited to, different total numbers of base directions 438. The raster generation application 150 inputs each base direction set 436 into distinct instances of the raster equation engine 440 to generate one or more frame rasters 158 for each base direction set 436.

[0176] As shown in the figure, in some implementations, the grid equation engine 440 includes, but is not limited to, equation partitioning engine 450 and equation clustering engines 460(1) to 460(B), where B is the total number of basic directions 438 included in the basic direction set 436 and can therefore be any positive integer. Equation clustering engines 460(1) to 460(B) are different instances of equation clustering engine 460 (not explicitly shown). For illustrative purposes only, equation clustering engines 460(1) to 460(B) are also referred to herein separately as "equation clustering engine 460" and collectively as "equation clustering engine 460".

[0177] In some implementations, the raster equation engine 440 generates a weighted equation set 442 based on the edge set 402 and optionally gravity design target values ​​146(1) to 146(N). The weighted equation set 442 includes, but is not limited to, different weighted equations (not shown) for each edge included in the edge set 402. The weighted equations can be specified in any technically feasible manner. For example, in some implementations, each weighted equation is specified in the format “Ax + By + C = 0”. To generate the weighted equation set 442, the raster equation engine 440 can determine and weight the weighted equations based on any quantity and / or type of criteria associated with the generation of the frame raster 158 in any technically feasible manner.

[0178] In some implementations, the grid equation engine 440 weights each equation based on a combination of building weights and solution weights caused by building features. For example, in some implementations, the grid equation engine 440 sets the building weight of the equation corresponding to a boundary edge to a higher value than the building weight of the equation corresponding to other edges. In the same or other implementations, the grid equation engine 440 assigns higher solution weights to equations corresponding to better solutions based on a target value 146 that includes the gravity design 148 of the corresponding edge.

[0179] As shown in the figure, in some implementations, the equation partitioning engine 450 generates weighted equation subsets 458(1) to 458(B) based on the weighted equation set 442 and the basic directions 438(1) to 438(B), respectively. For illustrative purposes only, the weighted equation subsets 458(1) to 458(B) are also referred to herein as “weighted equation subset 458” and collectively as “weighted equation subset 458”. The weighted equation subsets 458(1) to 458(B) represent different subsets of the weighted equation set 442 associated with the basic directions 438(1) to 438(B). The equation partitioning engine 450 can generate the weighted equation subsets 458(1) to 458(B) in any technically feasible manner.

[0180] In some implementations, the equation partitioning engine 450 generates a weighted subset of equations 458(1) to 458(B) based on fundamental directions 438(1) to 438(B) and a tolerance (e.g., 3 degrees). For each fundamental direction 438, the equation partitioning engine 450 selects a subset of weighted equations included in the weighted equation set 442 that are substantially parallel to the fundamental direction 438. As used herein, a weighted equation is substantially parallel to the fundamental direction 438 when the angle between the line represented by the weighted equation and the fundamental direction 438 is within a tolerance of zero degrees (e.g., between -3 degrees and 3 degrees). The equation partitioning engine 450 may determine the tolerance in any technically feasible manner. In some cases, in some implementations, the equation partitioning engine 450 implements a default tolerance.

[0181] In some other embodiments, the equation partitioning engine 450 is replaced by an edge partitioning engine (not shown) and an equation engine (not shown). For each fundamental direction 438(1) to 438(B), the edge partitioning engine determines a distinct subset of edges included in the edge set 402 that are generally parallel to the fundamental direction 438. As used herein, an edge is generally parallel to the fundamental direction 438 when the direction associated with the edge is within a tolerance of the fundamental direction 438 (e.g., within 3 degrees of the fundamental direction 438). For each fundamental direction 438, the equation engine generates a weighted subset 458 of equations associated with the fundamental direction 438 based on the subset of edges associated with the fundamental direction and optionally gravity design target values ​​146(1) to 146(N).

[0182] As shown in the figure, in some implementations, the raster equation engine 440 inputs any part (including none) of the parameter data 138 and the weighted equation subsets 458(1) to 458(B) into the equation clustering engine 460(1) to 460(B), respectively. In response, the equation clustering engine 460(1) to 460(B) generates a ranked list of equation clusters 468(1) to 468(B). For illustrative purposes only, the ranked list of equation clusters 468(1) to 468(B) is also referred to herein separately as “ranked list of equation clusters 468” and collectively as “ranked list of equation clusters 468”.

[0183] In some other embodiments, the raster equation engine 440 inputs any portion (including none) of the parameter data 138 and weighted subsets of equations 458(1) to 458(B) sequentially, simultaneously, or in any combination thereof into any number of instances of the equation clustering engine 460. For example, in some embodiments, the raster equation engine 440 sequentially inputs the weighted subsets of equations 458(1) to 458(B) into a single instance of the equation clustering engine 460. In response, the single instance of the equation clustering engine 460 sequentially outputs a ranked list of equation clusters 468(1) to 468(B).

[0184] Upon receiving one of the weighted equation subsets 458, the raster equation engine 440 performs any number and / or type of unsupervised clustering operations based on the weighted equations included in the weighted equation subset 458 to generate any number of equation cluster sets (not shown). Each equation cluster set specifies, but is not limited to, a different distribution of the weighted equations across any number of equation clusters (not shown). It should be noted that any given pair of equation cluster sets may include the same or different number of equation clusters.

[0185] Subsequently, the raster equation engine 440 may perform any number and / or type of ranking and / or filtering operations on the equation cluster sets to generate a ranked list of equation cluster sets 468. Thus, in some embodiments, the ranked list of equation cluster sets 468 specifies, but is not limited to, one or more equation cluster sets. More precisely, the ranked list of equation cluster sets 468(b) specifies, but is not limited to, one or more equation cluster sets associated with the base direction 438(b), where b is an integer from 1 to B.

[0186] The equation clustering engine 460 can acquire (e.g., receive or determine) any amount and / or type of configuration data in any technically feasible manner. Some examples of configuration data are, but are not limited to, the total number of equation cluster sets, any number and / or type of settings associated with generating each equation cluster set, any number and / or type of ranking criteria, and any number and / or type of filtering criteria. For example, in some implementations, the raster equation engine 440 determines any amount and / or type of configuration data based on parameter data 138.

[0187] Although not depicted, in some embodiments, the equation clustering engine 460 performs the same type of clustering, ranking, and filtering operations on the weighted subset of equations 458 as the directional clustering engine 420 performs on the weighted set of directions 412. For example, in some embodiments, the equation clustering engine 460 includes, but is not limited to, any number of instances of the K-means clustering algorithm 424 and the elbow rule heuristic 432. The equation clustering engine 460 configures each instance of the K-means clustering algorithm 424 to perform clustering operations on the weighted equations included in the weighted subset of equations 458 based on different instances (not explicitly shown) of the clustering setting 422. In response, each instance of the K-means clustering algorithm 424 generates one of the equation clusters in the set.

[0188] In the same or other implementations, the equation clustering engine 460 then uses the elbow rule heuristic 432 to determine new instances of elbows 434. The equation clustering engine 460 then ranks the equation clusters based on the increased distance to the elbows 434 to generate a ranked list of equation clusters 468. In some implementations, the equation clustering engine 460 may perform any number and / or type of filtering operations on the ranked list of equation clusters 468.

[0189] As shown in the figure, in some implementations, the raster specification engine 490 generates frame graticles 158(1) to 158(M) based on a ranked list of equation cluster sets 468(1) to 468(B), where M can be any positive integer. Each frame graticle 158 includes, but is not limited to, different combinations of B groups of grid lines, where each combination of B groups of grid lines includes a set of grid lines for each basic direction 438(1) to 438(B). The raster specification engine 490 can generate the frame graticles 158 in any technically feasible manner.

[0190] In some implementations, to generate the frame grid 158(m), where m is an integer between 1 and M, the grid specification engine 490 selects one of the equation clusters from each of the ranked equation cluster sets list 468(1) to 468(B). The grid specification engine 490 then generates a distinct set of grid lines for each of the B selected equation cluster sets. Subsequently, the grid specification engine 490 aggregates the B sets of grid lines to generate the frame grid 158(m).

[0191] The raster specification engine 490 can generate a set of raster lines for each selected equation cluster set in any technically feasible manner. In some embodiments, for a given equation cluster set, the raster specification engine 490 generates a set of raster lines, including but not limited to different raster lines for each equation cluster included in the equation cluster set. In the same or other embodiments, the raster specification engine 490 generates the raster lines for a given cluster based on the equation associated with the centroid of the cluster. In some embodiments, after generating the raster lines, the raster specification engine 490 aligns each raster line to any nearby building features (e.g., boundary edges) and extends each raster line beyond the boundary edge associated with the nearest floor.

[0192] In some implementations, a set of grid lines for each of the B selected equation clusters specifies one or more equations that are generally parallel to the base direction 438 associated with the selected equation clusters. Thus, for each base direction 438(1) to 438(B), each frame grid 158(1) to 158(M) includes, but is not limited to, one or more grid lines parallel to the base direction 438.

[0193] The raster specification engine 490 can select M distinct combinations of B equation cluster sets for the frame raster 158(1) to 158(M) in any technically feasible manner. In some implementations, the raster specification engine 490 selects the top r equation cluster sets in each ranked list of equation cluster sets 468(1) to 468(B), where r can be any positive integer. The raster specification engine 490 then generates all possible combinations of a single selected equation cluster set from each ranked list of equation cluster sets 468(1) to 468(B). For each of the resulting B^r combinations of equation cluster sets, the raster specification engine 490 generates a distinct frame raster 158.

[0194] In some other embodiments, the grid specification engine 490 implements a genetic algorithm to iteratively determine different combinations of equation cluster sets. For example, in some embodiments, the grid specification engine 490 implements a genetic algorithm that includes, but is not limited to, B distinct design variables representing a ranked list 468 of equation cluster sets. In the same or other embodiments, the genetic algorithm determines the fit of each combination of design variables based on a building target value 186 associated with a structural design 188 generated based on the combination of design variables.

[0195] In some embodiments, after the grid specification engine 490 generates the frame grid 158, the grid generation application 150 transfers one or more of the frame grids 158 to any number of other software applications in any technically feasible manner. In the same or other embodiments, the grid generation application 150 stores the frame grids 158 in memory accessible to at least one other software application. In some embodiments, the grid generation application 150 stores the frame grids 158 in memory accessible to the structural design application 120.

[0196] Defining the framework system using genetic algorithms

[0197] Figure 5 It is based on various implementation plans. Figure 1 A more detailed illustration of the framework specification application 170 is provided. For illustrative purposes only. Figure 4 The described implementation scheme, previously combined with Figure 1 The functionality of the frame specification application 170 is described within the context of the frame grid optimization problem. More specifically, the functionality of the frame specification application 170 is described within the context of the iterative design optimization portion of the overall design flow executed by the iterative optimization application 172 to generate a structural design 188 that resists both vertical and lateral loads.

[0198] As previously mentioned in this article Figure 1 In some embodiments, to initiate a first design optimization iteration, the iterative optimization application 172 inputs wind directions 164(1) to 164(W), frame grid 158, and gravity design 148 into the frame specification application 170. In response, the frame specification application 170 generates a frame system specification 178 that specifies, but is not limited to, the location of at least one frame in each wind direction 164. Figure 5 (Not shown in the image).

[0199] To complete the first design optimization iteration, the iterative optimization application 172 configures the iteration size setting application 180 to generate a structural design 188 based at least in part on the frame system specification 178 and to calculate the building objective value 186. The structural design 188 is the design of the building's structural system, including but not limited to frames at the locations specified in the frame system specification 178, and is optimized based on constraints 132 and an objective function 134, taking into account both vertical and lateral loads. In some embodiments, the building objective value 186 is related to the degree of convergence between the structural design 188 and the design objectives associated with the building.

[0200] To initiate each of any number of subsequent design optimization iterations, the iterative optimization application 172 inputs the building target value 186 into the frame specification application 170. In response, the frame specification application 170 generates a new version of the frame system specification 178 based on the building target value 186. To complete the design optimization iteration, the iterative optimization application 172 configures the iteration size setting application 180 to regenerate the structural design 188 and recalculate the building target value 186, at least in part, based on the new version of the frame system specification 178.

[0201] It should be noted that the techniques described herein are illustrative and not restrictive, and may be modified without departing from the broader spirit and scope of the invention. For example, in some other embodiments, any instance of the frame specification application 170 may iteratively optimize the position of frames (not shown) in the frame system based on any type of building structure design, any type of grid, any number of lateral load directions, and any number and / or type of optimization criteria.

[0202] As shown in the figure, in some implementations, the frame specification application 170 includes, but is not limited to, a wind direction assignment engine 510, frame partitioning engines 530(1) to 530(W), a genetic algorithm 550, and a frame selection engine 580. The wind direction assignment engine 510 generates potential frame location sets 514(1) to 514(W) based on the frame grid 158(1), gravity design 148(1), and wind directions 164(1) to 164(W), respectively. For illustrative purposes only, the potential frame location sets 514(1) to 514(W) are also referred to herein as "potential frame location set 514" and collectively as "potential frame location set 514".

[0203] In some embodiments, each potential frame location set 514 includes, but is not limited to, different location sets, wherein each location is within a tolerance of a different grid line in the frame grid 158 and corresponds to a different potential frame relative to the gravity design 148. In some other embodiments, before executing the frame specification application 172 during the first design optimization iteration, the iterative optimization application 172 regenerates the layout of the gravity design 148 based on the frame grid 158. Therefore, each location included in the potential frame location set 514 matches a different grid line in the frame grid 158 and corresponds to a different potential frame relative to the gravity design 148.

[0204] As described herein, a “potential” frame relative to gravity design 148 refers to a set of structural members included in gravity design 148 that can be connected via moment joints to form a frame resisting both vertical and lateral loads. In some embodiments, each potential frame in gravity design 148 includes, but is not limited to, a set of one or more beams and one or more columns from gravity design 148 that can be interconnected via any number and / or type of rigid joints, any number and / or type of semi-rigid joints, or any combination thereof. The locations included in the potential frame location set 514 are also referred to herein as “potential frame locations.”

[0205] In the same or other embodiments, the potential frame location set 514(1) to 514(W) includes, but is not limited to, any number of locations corresponding to potential frames that primarily resist wind loads associated with wind directions 164(1) to 164(W) when the constituent structural members are intrinsically connected via moment joints. In some embodiments, each grid line is associated with at most one location in the potential frame location set 514. The wind direction assignment engine 510 can generate the potential frame location set 514 in any technically feasible manner.

[0206] For example, in some embodiments, the wind direction allocation engine 510 determines any number of potential frames with respect to the gravity design 148, each potential frame having a location within a tolerance amount of a different associated grid line in the frame grid 158. In the same or other embodiments, the tolerance amount is equal to zero and each potential frame is on a different grid line in the frame grid 158. The wind direction allocation engine 510 then calculates the projection of each wind direction 164 onto each potential frame. For each potential frame associated with at least one non-zero projection, the wind direction allocation engine 510 adds the associated location to the potential frame location set 514 corresponding to the wind direction 164 with the largest projection onto the potential frame.

[0207] As shown in the figure, in some embodiments, the wind distribution engine 510 calculates the building load centroid 520 based on gravity design 148. The wind distribution engine 510 can define and / or calculate the building load centroid 520 in any technically feasible manner. In some embodiments, the building load centroid 520 is the building load centroid set by the wind distribution engine 510 based on gravity design 148 to be equal to the centroid of the total dead load and live load of all floors in the building. In the same or other embodiments, the frame specification application 170 configures the frame division engines 530(1) to 530(W) to divide the potential frame location set 514(1) to 514(W) into left frame groups 542(1) to 542(W) and right frame groups 544(1) to 544(W) based on the building load centroid 520.

[0208] Each frame-partitioning engine 530(1) to 530(W) is a different instance of frame-partitioning engine 530 (not explicitly shown). For illustrative purposes only, frame-partitioning engines 530(1) to 530(W) are also referred to individually as “frame-partitioning engine 530” and collectively as “frame-partitioning engine 530” herein. Left frame groups 542(1) to 542(W) are also referred to individually as “left frame group 542” and collectively as “left frame group 542” herein. Right frame groups 544(1) to 544(W) are also referred to individually as “right frame group 544” and collectively as “right frame group 544” herein. The locations specified in left frame group 542 and right frame group 544 are also referred to herein as “potential frame locations”.

[0209] In some implementations, for each wind direction 164, the frame specification application 170 inputs the wind direction 164(w), the potential frame location set 514(w), and the building load centroid 520 into the frame partitioning engine 530(w), where w is an integer from 1 to W. In response, the frame partitioning engine 530(w) sets the left frame group 542(w) to a subset equal to the locations specified in the potential frame location set 514(w) that will be to the left of the building load centroid 520 relative to wind direction 164(w). The frame partitioning engine 530(w) sets the right frame group 544(w) to a subset equal to the locations specified in the potential frame location set 514(w) that will be to the right of the building load centroid 520 relative to wind direction 164(w). The frame partitioning engine 530(w) then outputs the left frame group 542(w) and the right frame group 544(w).

[0210] In some other embodiments, the frame specification application 170 configures any number of instances of the frame partitioning engine 530 to partition potential frame location sets 514(1) to 514(W) sequentially, simultaneously, or in any combination thereof based on the building load centroid 520. For example, in some embodiments, the frame specification application 170 configures a single instance of the frame partitioning engine 530 to partition potential frame location sets 514(1) to 514(W) sequentially based on the building load centroid 520.

[0211] In some implementations, to generate the genetic algorithm 550, the framework specification application 170 configures a metaheuristic method to iteratively and collectively optimize the left frame counts 572(1) to 572(W) and the right frame counts 574(1) to 574(W) based on the building target value 186(1,1). Therefore, the framework specification application 170 defines the left frame counts 572(1) to 572(W) and the right frame counts 574(1) to 574(W) as integer design variables for the genetic algorithm 550. The left frame counts 572(1) to 572(W) are also referred to herein separately as “left frame count 572” and collectively as “left frame count 572”. The right frame counts 574(1) to 574(W) are also referred to herein separately as “right frame count 574” and collectively as “right frame count 574”. The left frame counts 572 and right frame counts 574 are also referred to herein as “position counts”.

[0212] For an integer w from 1 to W, the left frame count 572(w) specifies the total number of positions in the left frame group 542(w) that will become frames in the frame system. As shown, in some implementations, the frame specification application 170 configures the genetic algorithm 550 to set the left frame counts 572(1) to 572(W) to integers within the left frame count ranges 562(1) to 562(W), respectively. For the left frame count ranges 562(1) to 562(W), the frame specification application 170(1-1) reactively sets the lower bound to one and the upper bound to the size of the left frame groups 542(1) to 542(W). Thus, each left frame count range 562(1) to 562(2) is an integer range.

[0213] Similarly, for an integer w from 1 to W, the right frame count 574(w) specifies the total number of positions in the right frame group 544(w) that will become frames in the frame system. As shown, in some implementations, the frame specification application 170 configures the genetic algorithm 550 to set the right frame counts 574(1) to 574(W) to integers within the right frame count range 564(1) to 564(W), respectively. For the right frame count range 564(1) to 564(W), the frame specification application 170 reactively sets the lower bound to one and the upper bound to the size of the right frame groups 544(1) to 544(W). Thus, each right frame count range 564(1) to 564(W) is an integer range.

[0214] After configuring the genetic algorithm 550, the frame specification application 170 causes the genetic algorithm 550 to determine the left frame count 572 and the right frame count 574 for the first design optimization iteration. The genetic algorithm 550 can initially determine the left frame count 572 and the right frame count 574 in any technically feasible manner. For example, in some embodiments, the genetic algorithm 550 sets each left frame count 572(1) to 572(W) to be equal to a random integer within the range of each left frame count 562(1) to 562(W), and sets each right frame count 574(1) to 574(W) to be equal to a random integer within the range of each right frame count 564(1) to 564(W). In some other embodiments, the generic algorithm 550 sets each left frame count 572(1) to 572(W) and each right frame count 574(1) to 574(W) to be equal to one.

[0215] In some implementations, after the genetic algorithm 550 determines or re-determines the left frame count 572 and the right frame count 574 in a given design optimization iteration, the frame selection engine 580 generates a frame system specification 178 for the design optimization iteration. As shown, in some implementations, the frame selection engine 580 generates the frame system specification 178 based on the left frame count 572, the left frame group 542, the right frame count 574, and the right frame group 544. The frame selection engine 580 can generate the frame system specification 178 in any technically feasible manner.

[0216] In some implementations, the frame selection engine 580 implements frame selection rules (not shown) based on the encapsulation design and structural engineering foundations to generate frame system specifications 178. According to the design and structural engineering foundations, the effectiveness of the frame against wind increases with increasing distance from the building load center of mass 520. To optimize the effectiveness of the frame system, the frame selection engine 580 implements frame selection rules that specify the positions of frames selected from the left frame group 542(w) and the right frame group 544 in descending order of distance from the building load center of mass 520.

[0217] In the same or other implementations, for each left frame group 542(w), where w is an integer from 1 to W, the frame selection engine 580 selects the left frame count 572(w) at the specified location in the left frame group 542(w) based on frame selection rules. Therefore, the frame selection engine 580 selects the location in the left frame group 542(w) that is farthest from the building load centroid 520. For example, if the left frame count 572(1) is two, then the frame selection engine 580 selects the two locations in the left frame group 542(w) that are farthest from the building load centroid 520.

[0218] Similarly, in some implementations, for each right frame group 544(w), where w is an integer from 1 to W, the frame selection engine 580 selects the right frame count 574(w) at a specified location within the right frame group 544(w) based on frame selection rules. Accordingly, the frame selection engine 580 selects the location within the right frame group 544(w) that is furthest from the building load centroid 520. For example, if the right frame count 574(1) is three, then the frame selection engine 580 selects the three locations furthest from the right frame group 544(w) from the building load centroid 520.

[0219] Subsequently, the frame selection engine 580 generates a frame system specification 178 for the frame system, which includes, but is not limited to, different frames at each selected location. The frame system specification 178 can specify the frame system in any technically feasible manner. For example, in some implementations, the frame system specification 178 is a list of selected locations.

[0220] In some embodiments, after the framework selection engine 580 generates the framework system specification 178, the framework specification application 170 transfers the framework system specification 178 to any number of other software applications in any technically feasible manner. In the same or other embodiments, the framework specification application 170 stores the framework system specification 178 in memory accessible to at least one other software application. In some embodiments, the framework specification application 170 stores the framework system specification 178 in memory accessible to the iterative optimization application 172, and the iterative optimization application 172 inputs the framework system specification 178 into the iteration size setting application 180.

[0221] In some implementations, after the framework specification application 170 generates the framework system specification 178 for the current design optimization iteration, the framework specification application 170 may regenerate the framework system specification 178 for a new design optimization iteration based on any number and / or type of optimization criteria. The framework specification application 170 may determine when to regenerate the framework system specification 178 and / or acquire any amount and / or type of data related to the optimization criteria in any technically feasible manner.

[0222] As depicted by the dashed arrow, in some implementations, the framework specification application 170 regenerates the framework system specification 178 for a new design optimization iteration after receiving the building target value 186 associated with the current design optimization iteration as input. In response to receiving the building target value 186, the framework specification application 170 inputs the building target value 186 into the genetic algorithm 550.

[0223] In the same or other implementations, the genetic algorithm 550 performs any number and / or type of search-based optimization operations based on the building target value 186 to redetermine the left frame count 572 and the right frame count 574. The frame selection engine 580 then regenerates the frame system specification 178 based on the left frame count 572, the left frame group 542, the right frame count 574, and the right frame group 544.

[0224] The framework specification application 170 can determine when to stop operating in any technically feasible manner. For example, in some embodiments, the framework specification application 170 stops operating in response to a termination command from the iterative optimization application 172 or the structural design application 120. In the same or other embodiments, the framework specification application 170 stops operating when the amount of time that has elapsed since the last time the framework specification application 170 received input exceeds a maximum waiting time.

[0225] Optimize the size setting of structural members for vertical and lateral loads.

[0226] Figure 6 It is based on various implementation plans. Figure 1 A more detailed illustration of the iteration size setting application 180 is provided. This is for illustrative purposes only. Figure 6 The described implementation scheme addresses the issues previously discussed herein. Figure 1 The functionality of the iterative sizing application 180 is described within the context of the vertical and lateral load design optimization. More specifically, the iterative sizing application 180 adds or modifies the connections and sizing settings between columns and beams in the gravity design 148 based on the frame system specification 178 and the objective function 134 to generate a structural design 188 that resists dead loads, live loads, and building wind loads included in the building wind load data 162.

[0227] It should be noted that the techniques described herein are illustrative and not restrictive, and may be modified without departing from the broader spirit and scope of the invention. Generally, any number of instances of the iterative sizing application 180 may be performed in any technically feasible manner. The iterative sizing application 180 can modify the connections and / or sizing settings between any type of structural members in any type of design of a building's structural system to generate a structural design 188 resistant to any number and / or type of loads. The iterative sizing application 180 can modify the connections and / or sizing settings in the design of the structural system based on any amount (including none) of data, any number and / or type of optimization criteria, and any number and / or type of constraints 132.

[0228] As shown in the figure, in some implementations, the iterative sizing application 180 generates structural designs 188 and building target values ​​186 based on gravity design 148, frame system specifications 178, design instructions 130, and building wind load data 162. Previously combined with... Figure 1 Gravity design 148, design instructions 130, and building wind load data 162 are described. This document previously combined... Figure 5 The framework system specification 178 is described in detail.

[0229] In the same or other embodiments, the iteration size setting application 180 includes, but is not limited to, a design initialization engine 620, a structural system iteration controller 630, a framework system iteration controller 650, and framework iteration engines 670(1) to 670(R). Each framework iteration engine 670(1) to 670(R) is a different instance of framework iteration engine 670 (not explicitly shown). For purposes of explanation only, framework iteration engines 670(1) to 670(R) are also individually referred to herein as “framework iteration engine 670” and collectively as “framework iteration engine 670”. As described in more detail below, in some embodiments, R is a positive integer determined by the design initialization engine 620 based on framework system specification 178. In some other embodiments, the iteration size setting application 180 may include, but is not limited to, any number (including one) of instances of framework iteration engine 670.

[0230] As shown in the figure, in some implementations, the design initialization engine 620 initializes the structural design dataset 610 based on gravity design 148, frame system specification 178, and design instructions 130. For illustrative purposes only, at any given point in time, the structural design dataset 610 is also referred to herein as the “current structural design” of the building associated with gravity design 148.

[0231] The structural design dataset 610 may include, but is not limited to, any quantity and / or type of data related to generating the structural design 188 and / or calculating the target building value 186. In some embodiments, the structural design dataset 610 includes, but is not limited to, building layout 612, size setting data 614, frame specifications 616(1) to 616(R), connection data 618, live load data 622, dead load data 624, lateral load data 626, and design instructions 130, wherein R may be any positive integer.

[0232] Building layout 612 specifies, but is not limited to, the location, type, and material of structural members included in the current structural design. In some embodiments, structural members include, but are not limited to, any number of slabs, any number of beams, and any number of columns. As depicted in italics, in some embodiments, building layout 612 is fixed and therefore not modified by the iterative sizing application 180. Sizing data 614 specifies, but is not limited to, sizing data for any quantity and / or type of structural members included in the current structural design.

[0233] Framework specifications 616(1) through 616(R) are also referred to herein individually as “framework specification 622” and collectively as “framework specification 622”. In some embodiments, each framework specification 616 specifies a different framework (not shown), and these frameworks are collectively referred to herein as a “framework system” (not shown). In the same or other embodiments, the framework system corresponds to framework system specification 178(1,1). Therefore, and as described in more detail below, in some embodiments, R is a positive integer determined by the design initialization engine 620 based on framework system specification 178(1,1).

[0234] Each frame specification 616 specifies, but is not limited to, different groups of structural members of the current design interconnected via moment joints to form the corresponding frame. For example, in some embodiments, each frame specification 616 specifies, but is not limited to, any number of beams and any number of columns interconnected via rigid joints.

[0235] Connection data 618 specifies any amount and / or type of data associated with the connections between structural members in the current structural design. In some embodiments, connection data 618 specifies, but is not limited to, any number and / or type of joints included in the current structural design. In the same or other embodiments, connection data 618 specifies, but is not limited to, rigid joints for each interconnection between structural members specified in each frame specification 616.

[0236] Live load data 622 includes, but is not limited to, any number and / or type of live loads associated with the current structural design. Live load data 622 is fixed and therefore not modified by the iteration size setting application 180. Dead load data 624 includes, but is not limited to, any number and / or type of dead loads associated with the current structural design. Lateral load data 626 includes, but is not limited to, any number and / or type of lateral loads associated with the current structural design. In some embodiments, the live loads, dead loads, and lateral loads included in live load data 622, dead load data 624, and lateral load data 626, respectively, can be specified at any granularity level relative to the current structural design. For example, in some embodiments, live loads and dead loads are specified as distributed loads relative to a horizontal area (e.g., a room).

[0237] In the same or other embodiments, lateral load data 626 includes, but is not limited to, any number and / or type of member lateral loads (not shown). Each member lateral load is associated with one of the structural members of the current structural design and specifies, but is not limited to, any type of lateral load associated with the structural member. In some embodiments, at any given time, member lateral loads may reflect the distribution of any number and / or type of building lateral loads (not shown) to each structural member. Each building lateral load is a lateral load associated with the current structural design and / or the associated building. In some embodiments, building lateral loads include, but are not limited to, any number of building wind loads included in building wind load data 162.

[0238] The design initialization engine 620 can initialize the structural design dataset 610 in any technically feasible manner. In some embodiments, the design initialization engine 620 copies design instructions 130 to the structural design dataset 610. As previously described herein, design instructions 130 include, but are not limited to, constraints 132, objective functions 134, design variable data 136, and parameter data 138. In the same or other embodiments, the design initialization engine 620 copies data of any quantity and / or type from gravity design 148 to initialize the building layout 612 and sizing data 614.

[0239] Design initialization engine 620 generates frame specification 616 based on gravity design 148 and frame system specification 178(1,1). Design initialization engine 620 can generate frame specification 616 in any technically feasible manner. For example, in some embodiments, frame system specification 178 specifies the location of each group of structural members in gravity design 148(1) to be interconnected via moment joints. For each location specified in frame system specification 178, design initialization engine 620 identifies the corresponding group of structural members in the current structural design and generates frame specification 616 specifying, but not limited to, the identified group of structural members. Therefore, the total number of frame specifications 616 is equal to the number of locations specified in frame system specification 178.

[0240] In the same or other embodiments, the design initialization engine 620 initializes the connection data 618 to specify, but is not limited to, any number and / or type of moment joints associated with the frame corresponding to frame specification 616. In some embodiments, for each frame specification 616, the design initialization engine 620 specifies via the connection data 618 that each connection between structural members specified in frame specification 616 is a rigid joint. In the same or other embodiments, the design initialization engine 620 specifies via the connection data 618 that each connection between structural members in the current structural design not specified in frame specification 616 is a pin joint or a hinged joint.

[0241] In some embodiments, the design initialization engine 620 copies data from the gravity design 148 to initialize the live load data 622 and dead load data 624. In other embodiments, the design initialization engine 620 calculates the live load data 622 and dead load data 624 based on the building layout 612, size setting data 614, and optionally design instructions 130. In some embodiments, the design initialization engine 620 initializes the lateral load data 626 to a specified initial value of zero for each of any number and / or type of member lateral load.

[0242] As indicated by the double arrows, in some embodiments, the structural system iteration controller 630, the frame system iteration controller 650, and the frame iteration engines 670(1) to 670(R) can read, write, and / or modify the structural design dataset 610. In some other embodiments, the iteration size setting application 180 can route data of any amount and / or type among the structural design dataset 610, the structural system iteration controller 630, the frame system iteration controller 650, and the frame iteration engines 670(1) to 670(R) in any technically feasible manner.

[0243] In some implementations, the iterative sizing application 180 defines and solves a nested optimization problem to generate a structural design 188(1,1). In some implementations, solving the nested optimization problem corresponds to optimizing the sizing data 614 included in the current structural design based on an objective function 134 and constraints 132, while taking into account gravity and any number and / or type of lateral building loads. In some implementations, one or more constraints 132 are safety design factors that ensure the structural design 188 satisfactorily resists both vertical and lateral loads.

[0244] In some implementations, the structural system iteration controller 630 performs any number of iterations included in the top loop to solve the top layer of the nested optimization problem and thus solve the nested optimization problem. As shown, in some implementations, the structural system iteration controller 630 includes, but is not limited to, the structural system iteration controller 640. In the same or other implementations, the structural system iteration controller 640 can read, write, and / or modify the structural design dataset 610. In some other implementations, the structural system iteration controller 630 can route any amount and / or type of data between the structural design dataset 610 and the structural system iteration controller 640 in any technically feasible manner.

[0245] In some implementations, to initiate each “top loop iteration,” the structural system iteration controller 630 configures the structural system iteration controller 640 to optimize the sizing set data 614 based on the objective function 134 and constraints 132 while keeping the lateral load data 626 fixed. The structural system iteration controller 640 can optimize the sizing set data 614 for any number and / or type of structural members in the current design in any technically feasible manner.

[0246] In some other embodiments, the structural system iterative controller 640 iteratively optimizes the beams in the current structural design and then iteratively optimizes the columns in the current structural design, thereby updating the dead load data 624 after each iteration while keeping the lateral load data 626 fixed. The structural system iterative controller 640 can implement any number and / or type of optimization algorithms and / or any number and / or type of basic rules, each encapsulating any number and / or type of design and / or structural engineering fundamentals. For example, in some embodiments, the structural system iterative controller 640 implements a full-stress design method to optimize the beam and / or column size setting data 614 in the current structural design.

[0247] In some other embodiments, the structural system iterative controller 640 executes a bisection-based beam optimization algorithm that iteratively optimizes the beam size setting data 614 based on the objective function 134 and constraints 132, thereby updating the dead load data 624 after each iteration while keeping the lateral load data 626 fixed. Subsequently, in some embodiments, the structural system iterative controller 640 executes a bisection-based optimization algorithm to iteratively optimize the column size setting data 614 based on the objective function 134 and constraints 132, thereby updating the dead load data 624 after each iteration while keeping the lateral load data 626 fixed.

[0248] In the same or other embodiments, after the structural system iteration controller 640 optimizes the sizing data 614 while keeping the lateral load data 626 fixed, the structural system iteration controller 630 configures the frame system iteration controller 650 to solve the nested optimization problem as an intermediate layer relative to the top loop iteration. The intermediate layer solving the nested optimization problem corresponds to optimizing the frame sizing data 614 specified via frame specification 616 based on any number and / or type of building lateral loads. The frame sizing data 614 is the sizing data 614 of the structural elements specified via frame specification 616. For illustrative purposes only, each frame sizing data 614 is also referred to herein as a “sizing dataset”.

[0249] In some implementations, the frame system iteration controller 650 includes, but is not limited to, a lateral load distribution engine 660. In some implementations, the lateral load distribution engine 660 can read, write, and / or modify the structural design dataset 610. In some other implementations, the frame system iteration controller 650 can route data of any quantity and / or type between the structural design dataset 610 and the lateral load distribution engine 660 in any technically feasible manner.

[0250] As shown in the figure, in some embodiments, the frame system iteration controller 650 executes any number of iterations included in the intermediate loop to solve the intermediate layer of the nested optimization problem relative to the top loop iteration. In some embodiments, to begin each “intermediate loop iteration”, the frame system iteration controller 650 configures the lateral load distribution engine 660 to distribute any number and / or type of building lateral loads on the frame corresponding to frame specification 616.

[0251] For example, as depicted in italics, in some embodiments, the frame system iteration controller 650 configures the lateral load distribution engine 660 to distribute any number of building wind loads (not shown) included in the building wind load data 162 on the frame corresponding to frame specification 616. In some embodiments, the building wind load data 162 includes, but is not limited to, different building wind loads in each of any number of directions (e.g., wind directions 164(1) to 164(W)).

[0252] The lateral load distribution engine 660 can distribute the building lateral loads specified by the frame system iteration controller 650 onto the frames corresponding to frame code 616 in any technically feasible manner. In some embodiments, the lateral load distribution engine 660 applies any number and / or type of basic rules, each encapsulating any number and / or type of structural engineering foundations, to frame code 616 to distribute the building lateral loads onto the corresponding frames. In the same or other embodiments, the lateral load distribution engine 660 distributes the building lateral loads onto the frames based on the frame stiffness. In the same or other embodiments, for each frame, the lateral load distribution engine 660 generates one or more frame lateral loads (not shown) associated with the frame and corresponding to the portion of the building lateral load distributed to the frame by the lateral load distribution engine 660. Thus, for each frame code 616, the frame lateral load specifies the portion of the building lateral load distributed to the corresponding frame by the lateral load distribution engine 660. The frame lateral load is also referred to herein as a "frame-based lateral load".

[0253] In some implementations, after the lateral load distribution engine 660 generates the lateral loads of the frame, the frame system iteration controller 650 configures any number of instances of the frame iteration engine 670 to independently solve the nested optimization problem for each frame specification 616(1) to 616(R) relative to the intermediate loop iterations. The underlying layer that solves the nested optimization problem for each frame specification 616 corresponds to optimizing the size setting data 614 of the corresponding frame while keeping the associated lateral loads of the frame fixed.

[0254] As shown in the figure, in some implementations, the framework system iteration controller 650 configures the framework iteration engines 670(1) to 670(R) to independently solve the optimization problem at the bottom layer for each framework specification 616(1) to 616(R). In some other implementations, the framework system iteration controller 650 configures fewer than R instances of the framework iteration engine 670 to independently solve the optimization problem at the bottom layer for each framework specification 616(1) to 616(R). For example, in some implementations, the framework system iteration controller 650 configures a single instance of the framework iteration engine 670 to sequentially solve the optimization problem at the bottom layer for each framework specification 616(1) to 616(R).

[0255] In some implementations, each instance of the framework iteration engine 670 can read, write, and / or modify the structural design dataset 610. In other implementations, the framework system iteration controller 650 can route data of any amount and / or type between the structural design dataset 610 and each instance of the framework iteration engine 670 in any technically feasible manner.

[0256] To address the underlying optimization problem for frame specification 616, frame iteration engine 670 can optimize the size setting data 614 of the structural elements specified in frame specification 616 in any technically feasible manner, while keeping the associated lateral loads of the frame fixed. As shown for frame iteration engine 670 (1), frame iteration engine 670 includes, but is not limited to, frame iteration controller 672, frame analyzer 680, and lateral load resizing engine 690.

[0257] In some implementations, the frame iteration controller 672 initiates any number of iterations included in the bottom loop to optimize the size setting data 614 of the structural elements specified in frame specification 616, while keeping the lateral loads of the frame associated with frame specification 616 fixed. In some implementations, to initiate each bottom loop iteration, the frame iteration controller 672 generates a bending moment diagram 662 and a shear force diagram 664 of the frame corresponding to frame specification 616, at least in part, based on the lateral loads of the frame. The frame analyzer 680 can generate the bending moment diagram 662 and the shear force diagram 664 in any technically feasible manner.

[0258] In some implementations, the frame analyzer 680 performs any number and / or type of frame analysis operations based on any number and / or type of fundamental rules to generate bending moment diagrams 662 and shear force diagrams 664. For example, in some implementations, the frame analyzer 680 applies any number and / or type of fundamental rules to the frame code 616 based on the frame's lateral loads to calculate local bending moment diagrams (not shown) and local shear force diagrams (not shown). More specifically, in some implementations, the frame analyzer 680 applies the portal method, equivalent column method, or moment distribution method to the size setting data 614 of the structural elements specified in the frame code 616 based on the frame's lateral loads to generate local bending moment diagrams and local shear force diagrams.

[0259] Subsequently, in some embodiments, the frame analyzer 680 determines any number and / or type of vertical loads associated with the frame corresponding to frame code 616 based on live load data 622 and dead load data 624. The frame analyzer 680 then uses an overlay method to generate a bending moment diagram 662 of the frame corresponding to frame code 616 based on the vertical loads associated with the frame and local bending moment diagrams. In the same or other embodiments, the frame analyzer 680 uses basic rules associated with the overlay method to generate a shear force diagram 664 of the frame corresponding to frame code 616 based on the vertical loads associated with the frame and local shear force diagrams.

[0260] In some implementations, the lateral load sizing engine 690 optimizes the sizing data 614 of the structural elements specified in the frame specification 616 based on the moment diagram 662, the shear force diagram 664, the objective function 134, and the constraints 132. The lateral load sizing engine 690 can optimize the sizing data 614 of the structural elements specified in the frame specification 616 in any technically feasible manner.

[0261] For example, in some embodiments, the lateral load sizing engine 690 executes a bisection-based frame optimization algorithm that collectively optimizes the beam and column sizing settings 614 specified in frame specification 616. During each of any number of iterations, the bisection-based frame optimization algorithm updates the beam and column sizing settings 614 based on moment diagram 662, shear force diagram 664, objective function 134, and constraints 132. In the same or other embodiments, the lateral load sizing engine 690 can optimize the sizing settings 614 of structural elements specified in frame specification 616 in any technically feasible manner while keeping the associated lateral frame loads fixed.

[0262] In some implementations, an associated bottom loop iteration is completed after the lateral load sizing engine 690 optimizes the beam and column sizing settings 614 specified in frame specification 616. In some implementations, the lateral load sizing engine 690 or the frame iteration controller 672 updates the dead load data 624 and member lateral loads to reflect any changes to the beam and column sizing settings 614 specified in frame specification 616. The frame iteration controller 672 can determine whether to begin another bottom loop iteration in any technically feasible manner.

[0263] In some implementations, if the maximum number of bottom loop iterations (not shown) has been reached for frame specification 616, then the frame iteration controller 672 does not initiate another bottom loop iteration. In the same or other implementations, the frame iteration controller 672 determines whether to initiate another bottom loop iteration based at least in part on the magnitude of any changes to the size setting data 614 of the structural members specified in frame specification 616 between bottom loop iterations.

[0264] In some implementations, if the frame iteration controller 672 determines that the relevant sizing options have been explored, then the frame iteration controller 672 does not begin another bottom loop iteration. The frame iteration controller 672 can determine whether the relevant sizing options have been explored in any technically feasible manner. For example, in some implementations, the frame iteration controller 672 determines that the relevant sizing operation has been explored when each structural element specified in the frame specification 616 is at the maximum permissible size according to the design variable data 136.

[0265] As depicted by the dashed arrow, if the frame iteration controller 672 does not initiate another bottom loop iteration, then the frame iteration controller 672 instructs the frame system iteration controller 650 to complete the bottom loop for frame specification 616 in any technically feasible manner. In some embodiments, when the bottom loop for frame specification 616 is completed, the frame iteration engine 670 has already solved the underlying nested optimization problem of the frames corresponding to frame specification 616 relative to the intermediate loop iterations.

[0266] After the instance of the frame iteration engine 670 has completed the bottom loop for frame specifications 616(1) to 616(R), the frame system iteration controller 650 optionally performs any number of optimization and / or refinement operations based on frame specification 616. For example, as those skilled in the art will recognize, if the centroid of the building wind load is not aligned with the shear centroid of the current structural design, the resulting eccentricity will cause unbalanced torsional forces when the building wind load is applied to the building. Therefore, in some embodiments, the frame system iteration controller 650 implements one or more techniques to reduce the eccentricity of the building wind load included in the building wind load data 162.

[0267] For example, in some implementations, the frame system iterative controller 650 implements different instances of a proportional-integral-derivative (“PID”) controller (not shown) for each floor in the building. The PID controller correlates the magnitude of the unbalanced torsional force with corrections for safety factors in beams and columns specified in frame code 616. More specifically, each instance of the PID controller corrects for design safety factors (not shown) included in constraint 132 based on any unbalanced torsional force in the associated floor. Correcting the stiffness safety factor causes the lateral load adjustment sizing engine 690 to artificially strengthen some frames corresponding to frame code 616, reducing the distance between the centroid of the building's wind load and the shear centroid of the current structural design. In the same or other implementations, the frame system iterative controller 650 implements different instances of the PID controller for each level of each frame. For a given building wind load, the PID controller over-designs the frames located on the weaker side of the building relative to the building wind load (e.g., in left frame group 542 or right frame group 544).

[0268] After the frame system iteration controller 650 optionally performs any number of optimization and / or refinement operations on the frame specification 616, an intermediate loop iteration is completed. The frame system iteration controller 650 then determines whether to begin another intermediate loop iteration. The frame system iteration controller 650 may determine whether to begin another intermediate loop iteration in any technically feasible manner. For example, in some embodiments, if the maximum number of intermediate loop iterations (not shown) has been reached, then the frame system iteration controller 650 does not begin another top loop iteration. In the same or other embodiments, the frame system iteration controller 650 determines whether to begin another intermediate loop iteration based at least in part on the magnitude of any changes to the size setting data 614 of the structural members specified in the frame specification 616 and / or the magnitude of any changes to the lateral loads of the frame between intermediate loop iterations. In some embodiments, if the frame system iteration controller 650 determines that the relevant size setting options have been explored, then the frame system iteration controller 650 does not begin another bottom loop iteration.

[0269] As depicted by the dashed arrow, if the frame system iteration controller 650 does not initiate another intermediate loop iteration, then the frame system iteration controller 650 instructs the structure system iteration controller 630 to complete the intermediate loop. In some embodiments, when the intermediate loop is completed, the frame system iteration controller 650 has already solved the intermediate layer of the nested optimization problem of the frame system relative to the top loop iteration.

[0270] The structural system iteration controller 630 then determines whether to begin another top loop iteration. The structural system iteration controller 630 may determine whether to begin another top loop iteration in any technically feasible manner. For example, in some embodiments, if the maximum number of top loop iterations (not shown) has been reached, then the structural system iteration controller 630 does not begin another top loop iteration. In the same or other embodiments, the structural system iteration controller 630 determines whether to begin another top loop iteration based at least in part on the magnitude of any change to the size setting data 614 between top loop iterations. In some embodiments, if the structural system iteration controller 630 determines that the relevant size setting options have been explored, then the frame system iteration controller 650 does not begin another bottom loop iteration.

[0271] If the structural system iterative controller 630 does not initiate another top-loop iteration, then the top loop is completed. In some embodiments, when the top loop is completed, the structural system iterative controller 630 has solved the nested optimization problem. As shown, the structural system iterative controller 630 then generates a structural design 188 based on the structural design dataset 610. In some embodiments, the structural system iterative controller 630 calculates the building objective value 186 of the structural design 188 based on the objective function 134. In the same other embodiments, the structural system iterative controller 630 may calculate any number and / or type of other metrics associated with any number and / or type of design objectives.

[0272] In some embodiments, the iterative sizing application 180 transfers the structural design 188 and / or building target values ​​186 to any number of other software applications in any technically feasible manner. In the same or other embodiments, the iterative sizing application 180 stores the structural design 188 and / or building target values ​​186 in memory accessible to at least one other software application. In some embodiments, the iterative sizing application 180 stores the building target values ​​186 in memory accessible to the iterative optimization application 172, and the iterative optimization application 172 inputs the building target values ​​186 into the frame specification application 170(1,1).

[0273] Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. For example, in some embodiments, gravity design 148 specifies a reinforced concrete frame structure system. As those skilled in the art will recognize, beams and columns in a reinforced concrete frame structure system are typically connected via rigid joints, and therefore frame system specification 178 is redundant. In some embodiments, if frame system specification 178 is not entered into the iteration size setting application 180, then the design initialization engine 620 generates frame specifications 616 for the frame at all appropriate locations specifying gravity design 148. In the same or other embodiments, if frame system specification 178 is not entered into the iteration size setting application 180 and gravity design 148 specifies vertical loads, then the iteration size setting application 180 does not execute the structural system iteration controller 630 before performing the first structural system design iteration.

[0274] It should be understood that, Figure 6 The example of the iteration size setting application 180 depicted and described in conjunction with this figure is illustrative, and variations and modifications to the iteration size setting application 180 are possible. For example, the functionality provided by the iteration size setting application 180 as described herein can be integrated into or distributed across any number of components of the iteration size setting application 180. Furthermore, the connection topology between the various components of the iteration size setting application 180 can be modified as needed.

[0275] For example, in some embodiments, the iterative sizing application 180 omits the design initialization engine 620 and / or structural design dataset 610, and the iterative sizing application 180 can determine any amount and / or type of data in any technically feasible manner, and / or route any amount and / or type of data to any number of components, between any number of components, and from any number of components. In some embodiments, the iterative sizing application 180 receives gravity design 148, frame system specification 178, design instructions 130, and any number and / or type of building lateral loads in any technically feasible manner. In response, the iterative sizing application 180 generates an initial structural design (not shown) based on gravity design 148 and frame system specification 178. The iterative sizing application 180 then configures the structural system iteration controller 630, frame system iteration controller 650, and frame iteration engine 670 to collaboratively optimize the initial structural design based on design instructions 130 and building lateral loads.

[0276] Figures 7A to 7BA flowchart illustrating the method steps for generating at least one design of a building's structural system according to various implementation schemes is provided. (Although references are provided...) Figures 1 to 3 The system describes the method steps, but those skilled in the art will understand that any system configured to implement the method steps in any order falls within the scope of this invention.

[0277] As shown in the figure, method 700 begins with step 702, where the design concept engine 220 generates floor structure templates 222 for each floor of the building's structural system based on the building floor plan 124. The gravity design application 140 then selects the first floor. At step 704, the partitioning engine 224 divides the floor structure template 222 of the selected floor into any number of segments 230, and then selects the first of the segments 230 for the selected floor.

[0278] At step 706, the layout variation engine 250 generates multiple local designs 258 for the selected segment 230. At step 708, the gravity design optimizer 260 optimizes the local designs 258 of the selected segment 230 based on constraints 132 and an objective function 134 to generate an optimized local design 268 for the selected segment 230. At step 710, the segment design ranking engine 270 ranks the optimized local designs 268 of the selected segment 230 based on the objective function 134 to generate a ranked list 278 of segment designs for the selected segment 230.

[0279] At step 712, the partitioning engine 224 determines whether the selected segment 230 is the last of the segments 230 associated with the selected floor. If at step 712, the partitioning engine 224 determines that the selected segment 230 is not the last of the segments 230 associated with the selected floor, then method 700 proceeds to step 714. At step 714, the partitioning engine 224 selects the next segment 230 associated with the selected floor, and method 700 returns to step 706, where the layout variation engine 250 generates multiple partial designs 258 for the selected segment 230.

[0280] However, if at step 712, the partitioning engine 224 determines that the selected segment 230 is the last of the segments 230 associated with the selected floor, then method 700 proceeds directly to step 716. At step 716, the incremental merging engine 280 performs incremental segment-by-segment merging and optimization operations on the ranked segment design list 278 associated with the selected floor to generate a ranked floor design list 288 for the selected floor.

[0281] At step 718, the gravity design application 140 determines whether the selected floor is the last floor. If at step 718 the gravity design application 140 determines that the selected floor is not the last floor, then method 700 proceeds to step 720. At step 720, the gravity design application 140 selects the next floor, and method 700 returns to step 704, where the partitioning engine 224 partitions the floor structure template 222 of the selected floor.

[0282] However, if at step 718 the gravity design application 140 determines that the selected floor is the final floor, then method 700 proceeds directly to step 722. At step 722, the multi-floor optimizer 290 performs one or more search operations on the ranked floor design list 288 based on objective function 134 to generate a gravity design 148. At step 724, the multi-floor optimizer 290 calculates a gravity design target value 146 based on the gravity design 148 and objective function 134. At step 726, the gravity design application 140 stores and / or transfers any number of gravity designs 148 and / or gravity design target values ​​146 to any number of software applications for further design activities. Method 700 then terminates.

[0283] For illustrative purposes only, the steps of method 700 are depicted and described as occurring sequentially. However, as those skilled in the art will recognize, steps 704 to 720 may be performed sequentially, simultaneously, or in any combination thereof for each floor. Similarly, steps 706 to 714 may be performed sequentially, simultaneously, or in any combination thereof for each segment 230.

[0284] Figures 8A to 8B Flowcharts illustrating the method steps for generating a frame grid for a building's structural system, based on various implementation schemes, are provided. (Although references are not included.) Figures 1 to 4 The system describes the method steps, but those skilled in the art will understand that any system configured to implement the method steps in any order falls within the scope of this invention.

[0285] As shown in the figure, method 800 begins with step 802, where a grid generation application 150 acquires a gravity design 148 and optionally a gravity design target value 146 associated with the gravity design 148. At step 804, the grid generation application 150 generates an edge set 402 based on the gravity design 148. Each edge included in edge set 402 corresponds to a different beam connected to at least one column.

[0286] At step 806, the base direction engine 410 generates a weighted direction set 412 based on the directions of the edges included in the edge set 402. At step 808, the direction clustering engine 420 performs any number and / or type of clustering operations on the weighted directions included in the weighted direction set 412 to generate a direction cluster set 428. At step 810, the direction clustering engine 420 performs any number and / or type of ranking and / or filtering operations on the direction cluster set 428 to generate a ranked list of direction cluster sets 408.

[0287] At step 812, for each of any number of directional clusters 428 that has the highest ranking according to the ranked list of directional clusters 408, the raster generation application 150 generates a base direction set 436 based on the directional clusters included in the directional clusters 428. At step 814, the raster generation application 150 selects the first one in the base direction set 436.

[0288] At step 816, the raster equation engine 440 generates a weighted equation set 442 based on the equations representing the edges included in the edge set 402. At step 818, the equation partitioning engine 450 determines a weighted equation subset 458 from the weighted equation set 442 for each basic direction 438 specified in the selected basic direction set 436. At step 820, the raster equation engine 440 selects the first of the weighted equation subsets 458 associated with the selected basic direction set 436.

[0289] At step 822, the raster equation engine 440 performs any number and / or type of clustering operations on the weighted equations included in the selected subset of the weighted equation subset 458 to generate one or more equation cluster sets. At step 824, the raster equation engine 440 performs any number and / or type of ranking and / or filtering operations on the equation cluster sets to generate a ranked list 468 of equation cluster sets with base directions 438 associated with the selected subset of the weighted equation subset 458.

[0290] At step 826, the raster equation engine 440 determines whether the selected subset of weighted equation subset 458 is the last of the weighted equation subset 458 associated with the selected basic direction set 436. If at step 826, the raster equation engine 440 determines that the selected subset of weighted equation subset 458 is not the last of the weighted equation subset 458 associated with the selected basic direction set 436, then method 800 proceeds to step 828.

[0291] At step 828, the raster equation engine 440 selects the next weighted equation subset 458 associated with the selected base direction set 436, and method 800 returns to step 822, where the raster equation engine 440 generates one or more new equation cluster sets. Method 800 continues to loop through steps 822 to 828 until, at step 826, the raster equation engine 440 determines that the selected subset of weighted equation subset 458 is the last of the weighted equation subset 458 associated with the selected base direction set 436.

[0292] If, at step 826, the raster equation engine 440 determines that the selected subset of weighted equations 458 is the last of the weighted equation subsets 458 associated with the selected base direction set 436, then the direction of method 800 proceeds to step 830. At step 830, the raster specification engine 490 generates any number of frame rasters 158 based on a list 468 of ranked equation clusters of the selected subset of weighted equations 458.

[0293] At step 832, the raster generation application 150 determines whether the selected basic direction set 436 is the last of the basic direction sets 436. If at step 832, the raster generation application 150 determines that the selected basic direction set 436 is not the last of the basic direction sets 436, then method 800 proceeds to step 834. At step 834, the raster generation application 150 selects the next basic direction set 436, and method 800 returns to step 818, where the equation partitioning engine 450 determines a weighted equation subset 458 based on the selected basic direction set 436. Method 800 continues to loop through steps 818 to 834 until at step 822, the raster generation application 150 determines that the selected basic direction set 436 is the last of the basic direction sets 436.

[0294] If, at step 822, the raster generation application 150 determines that the selected basic direction set 436 is the last in the basic direction set 436, then the direction of method 800 proceeds to step 836. At step 836, the raster generation application 150 stores and / or transfers any number of frame grates 158 to any number of software applications for further design activities. Method 800 then terminates.

[0295] For illustrative purposes only, the steps of method 800 are depicted and described as occurring sequentially. However, as those skilled in the art will recognize, steps 814 to 834 may be performed sequentially, simultaneously, or in any combination thereof for each basic set of directions 436. Similarly, steps 820 to 828 may be performed sequentially, simultaneously, or in any combination thereof for each subset of weighted equations 458.

[0296] Figure 9 This is a flowchart illustrating the methodological steps for generating a design of a frame system associated with a building, based on various implementation schemes. (Although references are available...) Figures 1 to 5 The system describes the method steps, but those skilled in the art will understand that any system configured to implement the method steps in any order falls within the scope of this invention.

[0297] As shown in the figure, method 900 begins with step 902, where the wind direction distribution engine 510 determines the potential frame location set 514 for each wind direction 164 based on the building's gravity design 148 and frame grid 158. At step 904, the wind direction distribution engine 510 calculates the building load centroid 520 based on the gravity design 148.

[0298] At step 906, for each wind direction 164(w), where w is an integer from 1 to W, the frame partitioning engine 530 divides the potential frame location set 514(w) into a left frame group 542(w) and a right frame group 544(w) based on the building load centroid 520. At step 908, the frame specification application 170 implements a genetic algorithm 550 with two design variables for each wind direction 164(w): the left frame count 572(w) and the right frame count 574(w).

[0299] At step 910, the frame specification application 170 causes the genetic algorithm 550 to determine the left frame count 572 and the right frame count 574. At step 912, for each wind direction 164(w), the frame selection engine 580 selects the left frame count 572(w) from the left frame group 542(w) at the position farthest from the building load centroid 520. At step 914, for each wind direction 164(w), the frame selection engine 580 selects the right frame count 574(w) from the right frame group 544(w) at the position farthest from the building load centroid 520.

[0300] At step 916, the frame selection engine 580 generates a frame system specification 178, which indicates the frame system including, but not limited to, frames at selected locations. At step 918, the frame specification application 170 stores and / or provides the frame system specification 178 to any number of software applications for further design activities.

[0301] At step 920, the framework specification application 170 determines whether it has acquired the building target value 186 associated with the framework system specification 178. If at step 920, the framework specification application 170 determines that it has not acquired the building target value 186, then method 900 terminates.

[0302] However, if at step 920 the frame specification application 170 determines that it has acquired a building target value 186, then method 900 proceeds to step 922. At step 922, the frame specification application 170 causes the genetic algorithm 550 to re-determine the left frame count 572 and the right frame count 574 based on the building target value 186. Method 900 then returns to step 912, where the frame selection engine 580 selects positions from the left frame group 542 and the right frame group 544 based on the left frame count 572 and the right frame count 574.

[0303] Method 900 continues to loop through steps 912 to 922 until, at step 920, the framework specification application 170 determines that it has not acquired the building target value 186. Method 900 then terminates.

[0304] Figures 10A to 10B A flowchart illustrating the steps involved in designing structural systems for buildings to resist lateral loads, based on various implementation schemes, is provided. (Although references are not included.) Figures 1 to 6 The system describes the method steps, but those skilled in the art will understand that any system configured to implement the method steps in any order falls within the scope of this invention.

[0305] As shown in the figure, method 1000 begins with step 1002, where the design initialization engine 620 generates a structural design dataset 610 specifying, but not limited to, a frame system 606 based on gravity design 148 and frame system specification 178. The structural system iteration controller 630 then initializes the lateral loads on the members to zero. At step 1004, the structural system iteration controller 640, while keeping the lateral loads on the members fixed, sequentially optimizes the size settings of the beams and columns specified in the structural design dataset 610 based on constraints 132 and an objective function 134.

[0306] At step 1006, the lateral load distribution engine 660 distributes one or more building lateral loads (e.g., building wind loads included in building wind load data 162) onto frames corresponding to frame specification 616 to determine any number of frame lateral loads for each frame. The frame system iteration controller 650 then selects frames corresponding to frame specification 616(1).

[0307] At step 1008, the frame analyzer 680 generates a bending moment diagram 662 and a shear force diagram 664 for the selected frame based on the associated lateral and vertical loads. At step 1010, the lateral load sizing engine 690 jointly optimizes the beam and column sizing settings in the selected frame based on the bending moment diagram 662, the shear force diagram 664, constraint 132, and objective function 134.

[0308] At step 1012, the frame iteration controller 672 determines whether it has completed optimizing the selected frame. If at step 1012, the frame iteration controller 672 determines that it has not yet completed optimizing the selected frame, then method 1000 returns to step 1008, where the frame analyzer 680 regenerates the bending moment diagram 662 and shear force diagram 664 of the selected frame.

[0309] However, if at step 1012, the frame iteration controller 672 determines that it has completed optimizing the selected frame, then method 1000 proceeds to step 1014. At step 1014, the frame system iteration controller 650 determines whether the selected frame corresponds to the last one in frame specification 616. If at step 1014, the frame system iteration controller 650 determines that the selected frame does not correspond to the last one in frame specification 616, then method 1000 proceeds to step 1016.

[0310] At step 1016, the frame iteration controller 672 selects the frame corresponding to the next frame specification 616. Method 1000 then returns to step 1008, where the frame analyzer 680 regenerates the bending moment diagram 662 and shear force diagram 664 for the selected frame. Method 1000 continues to loop through steps 1008 to 1016 until, at step 1014, the frame iteration controller 672 determines that the selected frame corresponds to the last one in frame specification 616.

[0311] If, at step 1014, the frame iteration controller 672 determines that the selected frame corresponds to the last one in the frame specification 616, then method 1000 proceeds directly to step 1018. At step 1018, the frame system iteration controller 650 determines whether it has completed optimizing the frame system.

[0312] If, at step 1018, the frame system iteration controller 650 determines that it has not yet completed optimizing the frame system, then method 1000 returns to step 1006, where the lateral load distribution engine 660 redistributes the building's lateral loads onto the frame corresponding to frame specification 616. Method 1000 continues to loop through steps 1006 to 1018 until, at step 1018, the frame system iteration controller 650 determines that it has completed optimizing the frame system.

[0313] If, at step 1018, the frame system iteration controller 650 determines that it has completed optimizing the frame system, then method 1000 proceeds to step 1020. At step 1020, the structural system iteration controller 630 determines whether it has completed optimizing the structural design dataset 610.

[0314] If, at step 1020, the structural system iteration controller 630 determines that it has not yet completed optimizing the structural design dataset 610, then method 1000 returns to step 1004, where the structural system iteration controller 640 sequentially optimizes the size settings of beams and columns in the structural design dataset 610 while keeping the lateral loads on the members fixed. Method 1000 continues to loop through steps 1004 to 1020 until, at step 1020, the structural system iteration controller 630 determines that it has completed optimizing the structural design dataset 610.

[0315] If, at step 1020, the structural system iteration controller 630 determines that it has completed optimizing the structural design dataset 610, then method 1000 proceeds to step 1022. At step 1022, the structural system iteration controller 630 generates a structural design 188 based on the structural design dataset 610 and optionally calculates the building target value 186 for the structural design 188. At step 1024, the iteration size setting application 180 stores and / or transfers the structural design 188 and / or the building target value 186 to any number of other software applications in any technically feasible manner. Method 1000 then terminates.

[0316] For purposes of explanation only, the method steps of method 1000 are depicted and described as occurring sequentially. However, as those skilled in the art will recognize, for each framework corresponding to framework specification 616, steps 1008 to 1016 may be performed sequentially, simultaneously, or in any combination thereof.

[0317] In summary, the disclosed techniques can be used to efficiently generate structural system designs for buildings based on building floor plans, constraints of any number and type, objective functions encapsulating design objectives of any number and / or type, and one or more building wind loads. In some implementations, the structural design application decomposes the overall design optimization problem into multiple, less complex composition optimization problems associated with different aspects of the structural system. The structural design application executes an overall design process that dynamically self-adjusts based on the results generated while solving the composition optimization problems to generate a ranked list of structural designs for the structural system. The ranked list of structural designs specifies any number of structural designs for the building structural system and corresponding values ​​of the objective function, or "building target values." Each design is optimized based on constraints, the objective function, gravity, and building wind loads. The structural designs are ranked in the ranked list of structural designs in descending order of convergence with the design objectives according to the building target values.

[0318] To begin the overall design process, the structural design application configures the gravity design application to generate a specified number of gravity designs based on building plans, constraints, and objective functions. Each gravity design specifies, but is not limited to, the location, type, material, and size settings for any number of slabs, beams, and columns. It should be noted that each gravity design is optimized based on constraints and objective functions while taking gravity into account, but not the building's wind loads.

[0319] The gravity design application implements a branch-and-merge design flow to generate a gravity design. During the branching phase, the gravity design application divides each floor of the structural system into multiple segments, and then implements a rule-based expert system to generate various segment layouts for each segment. Each segment layout specifies, but is not limited to, the location, type, and material of any number of slabs, beams, and columns.

[0320] The gravity design application configures its gravity design optimizer to independently optimize the sizing settings for each segment layout to generate optimized segment designs. To optimize the sizing settings for a given segment layout, the gravity design application sequentially optimizes the sizing settings for the slabs, beams, and columns based on constraints and an objective function, taking gravity (as both live and dead loads) into account but not the building's wind loads. The gravity design application also calculates a target value for each segment design based on the objective function. For each segment, the gravity design application ranks the associated segment designs based on the target values ​​to generate a ranked list of segment designs. The ranked list of segment designs for a given segment includes, but is not limited to, the N highest-ranked segment designs and their associated target values, where N is a parameter value that can be any positive integer.

[0321] During the merging phase, the gravity design application generates multiple floor designs for each floor based on an associated, ranked list of segment designs. For a given floor, the gravity design application performs a segment-by-segment incremental merging based on the associated, ranked list of segment designs. After each incremental merging, the gravity design application configures the gravity design optimizer to optimize the resulting merged design and computes the associated target value. After performing the final segment-by-segment incremental merging, the gravity design application generates a ranked list of floor designs for the floor, which includes, but is not limited to, N designs for the associated floor and the associated target value. The N designs for the associated floor are the N highest-ranked optimized merged designs representing a subset of the optimized merged layout for the entire floor. The gravity design application then executes a genetic algorithm that searches the ranked list of floor designs for different floors to generate N distinct gravity designs for the structural system.

[0322] Subsequently, the structural design application configures the grid generation application to generate any number of frame grids based on N gravity designs. Each frame grid includes, but is not limited to, any number of grid lines, along which the frames resisting lateral loads are aligned. For each gravity design, the grid generation application selects beams connected to at least one column and generates an edge set, which includes, but is not limited to, different edges for each selected beam. The grid generation application then generates a weighted set of directions based on the orientations of the edges included in the edge set. The grid generation application performs K-means clustering multiple times on the weighted set of directions based on different combinations of seed settings and the number of clusters to generate different direction cluster values. Subsequently, the grid generation application applies the elbow rule heuristic to the direction cluster set to determine elbows and ranks the direction cluster sets based on distances to the elbows to generate a ranked list of direction cluster sets. For each cluster included in the highest-ranked direction cluster set, the grid generation application generates a base direction equal to the direction associated with the centroid of the cluster.

[0323] The raster generation application generates a weighted set of equations based on the equations of the edges included in the edge set and the target values ​​of the associated gravity design. For each fundamental direction, the raster generation application determines a corresponding subset of weighted equations, including but not limited to those generally parallel to the fundamental direction. For each subset of weighted equations, the raster generation application uses a K-means clustering algorithm and an elbow rule heuristic to generate a ranked list of equation clusters. The raster generation application then generates any number of frame rasters based on the ranked list of equation clusters. For each fundamental direction, each frame raster includes, but is not limited to, one or more raster lines generally parallel to the fundamental direction.

[0324] For each unique combination of a gravity design and a frame grid, the structural design application iteratively optimizes different instances of the application to generate different structural designs and associated building objective values ​​for the structural system. Each structural design of the structural system is optimized based on constraints and objective functions, taking into account gravity and building wind loads.

[0325] Each instance of the iterative optimization application includes, but is not limited to, different instances of the framework specification application and different instances of the iteration size setting application. In operation, the iterative optimization application performs any number of design optimization iterations via the framework specification application and the iteration size setting application.

[0326] To perform the first design optimization iteration, the iterative optimization application inputs the gravity design, frame grid, and any number of wind directions into the frame specification application. In response, the frame specification application generates a frame system specification that specifies, but is not limited to, the location of at least one frame providing lateral drag for each wind direction. Subsequently, the iterative optimization application inputs the gravity design, frame system specification, building wind loads, constraints, and objective function into the iteration size setting application. In response, the iterative optimization application generates a first version of the structural design and calculates the associated building objective values.

[0327] To perform each of any number of subsequent design optimization iterations, the iterative optimization application inputs the building target values ​​calculated during the previous design optimization iteration into the frame specification application. In response, the frame specification application regenerates the frame system specification. Subsequently, the iterative optimization application inputs the gravity design, the regenerated frame system specification, building wind loads, constraints, and objective functions into the iteration size setting application. In response, the iterative optimization application generates a new version of the structural design and calculates the associated building target values.

[0328] During the first design optimization iteration, for each wind direction, the frame code application generates different sets of potential frame locations based on the frame grid and gravity design. Each set of potential frame locations includes, but is not limited to, the locations of different subsets of potential frames relative to the gravity design, where subsets are mutually exclusive. Based on the gravity design, the frame code application sets the building load centroid to be equal to the total dead load on all floors of the building. For each wind direction, the frame code application then divides the associated set of potential frame locations into a left frame group and a right frame group based on the building load centroid.

[0329] The framework specification application configures a genetic algorithm to iteratively and jointly optimize the left and right frame counts of the left and right frame groups, respectively, based on building target values ​​associated with previous iterations (and computed by the application according to the iteration size setting). Each left frame count is a design variable for the genetic algorithm, ranging from 1 to the total number of positions in the associated left frame group. Similarly, each right frame count is a design variable for the genetic algorithm, ranging from 1 to the total number of positions in the associated right frame group.

[0330] During the first design iteration, the frame specification application uses a genetic algorithm to randomly determine the left and right frame counts. For each left frame group, the frame specification application selects the associated left frame counts from locations within the left frame group in descending order of distance from the building's load centroid. Similarly, for each right frame group, the frame specification application selects the associated right frame counts from locations within the right frame group in descending order of distance from the building's load centroid. The frame specification application then generates a frame system specification, which includes, but is not limited to, the selected locations.

[0331] During each subsequent design optimization iteration, the frame specification application receives the building target values ​​calculated by the iteration size setting application during the previous design optimization iteration. The frame specification application feeds these building target values ​​into a genetic algorithm. In response, the genetic algorithm redetermines the left and right frame counts. Based on the left and right frame counts, the frame specification application regenerates the frame system specification.

[0332] During each design optimization iteration, the iteration sizing application generates a structural design based on gravity design, the frame system specifications associated with the design optimization iteration, constraints, objective function, and building wind loads. The structural design specifies a structural system that resists live loads, dead loads, and building wind loads according to any number of constraints. The iteration sizing application also calculates the building objective values ​​for the structural design based on the objective function.

[0333] In operation, the Iterative Size Setting application modifies the gravity design based on the frame system specifications to generate a current structural design, including but not limited to the frame system. Each of any number of frame specifications derived from the frame system specifications specifies, but is not limited to, a group of one or more beams and one or more columns interconnected via rigid joints included in the current structural design. The Iterative Size Setting application also initializes the lateral loads on the slabs, beams, and columns of the current structural design to zero.

[0334] Subsequently, the iterative sizing application defines and solves nested optimization problems to optimize the sizing of beams and columns included in the current structural design based on the objective function, constraints, gravity, and building wind loads. The iterative sizing application includes, but is not limited to, a structural system iterative controller, a frame system iterative controller, and a frame iterative engine.

[0335] The structural system iterative controller executes any number of top-loop iterations to solve the top layer of the nested optimization problem and thus resolve the nested optimization problem. To begin the top-loop iterations, the structural system iterative controller executes a gradient-based beam optimization algorithm, which iteratively optimizes the beam size settings based on the objective function and constraints, updating the dead loads after each iteration while keeping the member wind loads constant. Subsequently, the structural system iterative controller executes a gradient-based column optimization algorithm, which iteratively optimizes the column size settings based on the objective function and constraints, updating the dead loads after each iteration while keeping the member wind loads constant.

[0336] The frame system iterative controller is then configured to execute any number of intermediate loop iterations to solve the nested optimization problem at the intermediate layer relative to the top loop iteration. The intermediate layer solving the nested optimization problem corresponds to optimizing the column and beam size settings in the frame system based on the building's wind load.

[0337] To initiate each intermediate loop iteration, the frame system iteration controller distributes the building's wind loads across the frames included in the current structural design to generate one or more frame lateral loads for each frame. For each frame, the frame system iteration controller configures different instances of the frame iteration engine to solve the nested optimization problem at the underlying level, independently of the intermediate loop iterations. The underlying level solving the nested optimization problem for a given frame corresponds to optimizing the beam and column sizing settings specified via the corresponding frame code, while keeping the associated frame lateral loads fixed.

[0338] The frame iteration engine performs any number of bottom loop iterations to solve the nested optimization of a given frame relative to the middle loop iterations. To begin each bottom loop iteration, the frame iteration engine generates bending moment and shear force diagrams for the frame based on the frame's associated lateral and vertical loads. The frame iteration engine then iteratively and collectively optimizes the beam and column sizing settings in the frame based on the bending moment, shear force, objective function, and constraints. The bottom loop iteration completes after the frame iteration engine has optimized the beam and column sizing settings.

[0339] The framework iteration engine can determine whether to execute another bottom loop iteration in any technically feasible way. If the framework iteration engine does not execute another bottom loop iteration, then the framework iteration engine indicates to the framework system iteration controller that it has solved the underlying layer of the nested optimization problem of the framework relative to the intermediate loop iterations.

[0340] After the frame system iterative controller determines that the bottom layer of the nested optimization problem for each frame in the frame system has been completed relative to the intermediate loop iteration, the frame system iterative controller determines whether to execute another intermediate loop iteration. If the frame system iterative controller does not execute another intermediate loop iteration, then the frame system iterative controller indicates to the structural system iterative controller that the frame system iterative controller has solved the intermediate layer of the nested optimization problem relative to the top loop iteration.

[0341] The structural system iteration controller can determine whether to execute another top-loop iteration in any technically feasible manner. If the structural system iteration controller does not execute another top-loop iteration, then the structural system iteration controller sets the structural design of the design optimization iteration to be equal to the current structural design. The system iteration controller also calculates the building target value of the structural design. The iteration size setting application then provides the structural design and building target value to the iterative optimization application, and completes the design optimization iteration.

[0342] In response, the iterative optimization application determines whether to execute another design optimization iteration. The iterative optimization application can determine when to execute another design optimization iteration in any technically feasible manner (e.g., when the building target value is reached). If the iterative optimization application does not execute another design optimization iteration, it provides the latest version of the structural design and the associated building target value to the structural design application.

[0343] After all instances of the iterative optimization application have provided structural designs and associated building target values ​​to the structural design application, the structural design application generates a ranked list of structural designs. The structural design application then stores and / or transfers any portion of the ranked structural designs to any number and / or type of software applications in any technically feasible manner.

[0344] At least one technical advantage of the disclosed technology over existing technologies lies in its ability to automatically explore the design space of a building's structural system to generate a structural design that converges more towards the design objectives while satisfying design constraints. In this regard, by decomposing the overall design optimization problem into any number of layout and gravity design optimization problems, frame grid optimization problems, frame system definition optimization problems, and vertical and lateral load design optimization problems using the disclosed technology, structural design applications can efficiently and systematically explore the design space of the structural system to identify areas optimized for the design objectives. Furthermore, compared to conventional CAD applications, using trained machine learning models and / or design and structural engine foundations to evaluate design decisions and dynamically discard poor local designs allows structural design applications to explore the design space in a more targeted and therefore more efficient manner. This increases the possibility of appropriately optimizing the structural design for the design objectives. These technical advantages provide one or more technical improvements over existing methods.

[0345] 1. In some embodiments, a computer-implemented method for generating one or more frame grids of a structural system of a building includes: determining an edge set based on a computer-aided design of the structural system; performing one or more clustering operations based on the edge set to determine a first plurality of basic directions; determining a first subset of edges based on the edge set and the first basic directions included in the first plurality of basic directions; performing one or more clustering operations based on the first subset of edges to determine a first plurality of grid lines associated with the first basic directions; and generating a first frame grid of the structural system based on the first plurality of grid lines and a second plurality of grid lines associated with a second basic direction included in the first plurality of basic directions.

[0346] 2. The computer-implemented method as described in Clause 1, wherein determining the edge set comprises generating edges of each beam connected to at least one column specified in the computer-aided design.

[0347] 3. A computer-implemented method as described in Clause 1 or 2, wherein performing the one or more clustering operations based on the edge set comprises: determining a plurality of weighted directions based on the edge set; performing a clustering algorithm on the plurality of weighted directions for each clustering setting included in the plurality of clustering settings to generate a plurality of directional cluster sets; performing an elbow rule heuristic on the plurality of directional cluster sets to determine elbow points; and calculating a first plurality of basic directions based on the plurality of directional cluster sets and the elbow points.

[0348] 4. A computer-implemented method as described in any one of Clauses 1 to 3, wherein calculating the first plurality of basic directions comprises: performing one or more ranking operations on the plurality of direction clusters based on a plurality of distances to the elbow to determine a highest-ranked direction cluster; and determining the first plurality of basic directions based on the highest-ranked direction cluster.

[0349] 5. A computer-implemented method as described in any one of Clauses 1 to 4, wherein performing the one or more clustering operations based on the first edge subset comprises: determining a first weighted equation subset based on the first edge subset; performing a K-means clustering algorithm on the first weighted equation subset to generate a plurality of equation clusters; and generating the first plurality of grid lines based on the plurality of equation clusters.

[0350] 6. A computer-implemented method as described in any one of Clauses 1 to 5, wherein determining the first weighted equation subset comprises: determining a first equation based on a first edge included in the first edge subset; and generating the first weighted equation based on the first equation and at least one of a first value of an objective function quantifying one or more design objectives of the structural system or a length associated with the first edge.

[0351] 7. A computer-implemented method as described in any one of clauses 1 to 6, wherein a first grid line included in the first plurality of grid lines is associated with the computer-aided design of the structural system, and a second grid line included in the first plurality of grid lines is associated with another computer-aided design of the structural system.

[0352] 8. A computer-implemented method as described in any one of clauses 1 to 7, wherein the building comprises a plurality of floors, and the first frame grid is associated with at least one of the plurality of floors.

[0353] 9. A computer-implemented method as described in any one of Clauses 1 to 8, wherein determining the first subset of edges comprises selecting each edge in the edge set that has a direction within a tolerance amount of the first basic direction.

[0354] 10. The computer-implemented method of any one of clauses 1 to 9, the computer-implemented method further comprising generating a second frame grid of the structural system based on the first plurality of grid lines and a third plurality of grid lines associated with the second basic direction.

[0355] 11. In some embodiments, one or more non-transitory computer-readable media include instructions that, when executed by one or more processors, cause the one or more processors to generate one or more frame grids of a structural system of a building by performing the following steps: determining an edge set based on a computer-aided design of the structural system; performing one or more clustering operations based on the edge set to determine a first plurality of basic directions; determining a first subset of edges based on the edge set and the first basic directions included in the first plurality of basic directions; performing one or more clustering operations based on the first subset of edges to determine a first plurality of grid lines associated with the first basic directions; and generating a first frame grid of the structural system based on the first plurality of grid lines and a second plurality of grid lines associated with a second basic direction included in the first plurality of basic directions.

[0356] 12. One or more non-transitory computer-readable media as described in Clause 11, wherein determining the edge set comprises: determining at least two sets of edges based on multiple computer-aided designs of the structural system; and determining the edge set from the union of the at least two sets of edges.

[0357] 13. One or more non-transitory computer-readable media as described in Clause 11 or 12, wherein performing the one or more clustering operations based on the edge set comprises: determining a plurality of weighted directions based on the edge set; performing a K-means clustering algorithm on the plurality of weighted directions to generate a plurality of directional clusters; and determining a first plurality of basic directions based on the plurality of directional clusters.

[0358] 14. One or more non-transitory computer-readable media as described in any one of clauses 11 to 13, wherein performing the one or more clustering operations based on the first edge subset comprises: determining a plurality of weighted equations based on the first edge subset; performing a clustering algorithm on the plurality of weighted equations for each clustering setting included in a plurality of clustering settings to generate a plurality of equation cluster sets; performing an elbow rule heuristic based on the plurality of equation cluster sets to determine elbow points; and calculating the first plurality of grid lines based on the elbow points and the plurality of equation cluster sets.

[0359] 15. One or more non-transitory computer-readable media as described in any one of clauses 11 to 14, wherein calculating the first plurality of grid lines comprises: performing one or more ranking operations on the plurality of equation cluster sets based on a plurality of distances to the elbows to determine the highest-ranked equation cluster set; and determining the first plurality of grid lines based on the highest-ranked equation cluster set.

[0360] 16. One or more non-transitory computer-readable media as described in any one of clauses 11 to 15, wherein a first grid line included in the first plurality of grid lines is associated with the computer-aided design of the structural system, and a second grid line included in the first plurality of grid lines is associated with another computer-aided design of the structural system.

[0361] 17. One or more non-transitory computer-readable media as described in any one of clauses 11 to 16, wherein the building comprises a plurality of floors, and the first frame grid is associated with each of the plurality of floors.

[0362] 18. One or more non-transitory computer-readable media as described in any one of clauses 11 to 17, wherein determining the first subset of edges includes selecting each edge in the subset of edges that has a direction within a tolerance amount of the first basic direction.

[0363] 19. One or more non-transitory computer-readable media as described in any one of Clauses 11 to 18, the non-transitory computer-readable media further comprising generating a second frame grid of the structural system based on the first plurality of grid lines and a third plurality of grid lines associated with the second basic direction.

[0364] 20. In some embodiments, a system includes: one or more memories storing instructions; and one or more processors coupled to the one or more memories, the one or more processors performing the following steps when executing the instructions: determining an edge set based on computer-aided design of a structural system of a building; performing one or more clustering operations based on the edge set to determine a first plurality of basic orientations; determining a first subset of edges based on the edge set and the first basic orientations included in the first plurality of basic orientations; performing one or more clustering operations based on the first subset of edges to determine a first plurality of grid lines associated with the first basic orientations; and generating a first frame grid of the structural system based on the first plurality of grid lines and a second plurality of grid lines associated with a second basic orientation included in the first plurality of basic orientations.

[0365] Any and all combinations of any element of the claim set forth in any claim and / or any element described in this application, in any manner, fall within the scope of the implementation and protection contemplated.

[0366] Various embodiments have been described for illustrative purposes; however, these descriptions are not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. Aspects of the embodiments of the invention may be embodied as systems, methods, or computer program products. Therefore, aspects of this disclosure may take the form of an all-hardware implementation, an all-software implementation (including firmware, resident software, microcode, etc.), or an implementation combining software and hardware aspects, which may be generally referred to herein as “modules,” “systems,” or “computers.” Furthermore, any hardware and / or software technology, process, function, component, engine, module, or system described in this disclosure may be implemented as a circuit or a set of circuits. Additionally, aspects of this disclosure may take the form of a computer program product embodied in one or more computer-readable media having a computer-readable program codec embodied thereon.

[0367] Any combination of one or more computer-readable media may be used. Each computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium. A computer-readable storage medium may be, for example, but not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or apparatuses, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of computer-readable storage media will include the following: electrical connections having one or more wires, portable computer disks, hard disks, random access memory, read-only memory, erasable programmable read-only memory, flash memory, optical fiber, portable optical disc read-only memory, optical storage devices, magnetic storage devices, or any suitable combination of the foregoing. In the context of this document, a computer-readable storage medium may be any tangible medium that can contain or store programs for use by or in conjunction with an instruction execution system, device, or apparatus.

[0368] The foregoing description of aspects of this disclosure includes flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this disclosure. It will be understood that each block in the flowchart illustrations and / or block diagrams, as well as combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus to produce a machine. When executed via a processor of a computer or other programmable data processing apparatus, the instructions cause the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams to be implemented. Such processors can be, but are not limited to, general-purpose processors, special-purpose processors, application-specific processors, or field-programmable gate arrays.

[0369] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code comprising one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may not occur in the order shown in the drawings. For example, two blocks shown consecutively may actually be executed substantially simultaneously, or the blocks may sometimes be executed in reverse order, depending on the functions involved. It will also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented by a system based on dedicated hardware or a combination of dedicated hardware and computer instructions that performs the specified function or action.

[0370] Although the foregoing relates to embodiments of this disclosure, other and additional embodiments of this disclosure may be contemplated without departing from the essential scope of this disclosure, the scope of which is defined by the appended claims.

Claims

1. A computer-implemented method for generating one or more frame grids of a structural system for a building, the method comprising: The edge set is determined based on the computer-aided design of the aforementioned structural system; One or more clustering operations are performed based on the edge set to determine a first plurality of basic directions; The first edge subset is determined based on the edge set and the first basic direction included in the first plurality of basic directions; Perform one or more clustering operations based on the first edge subset to determine a first plurality of grid lines associated with the first basic direction; as well as The first frame grid of the structural system is generated based on the first plurality of grid lines and the second plurality of grid lines associated with the second basic direction included in the first plurality of basic directions. The building comprises multiple floors, and the first frame grid is associated with at least one of the multiple floors.

2. The computer-implemented method of claim 1, wherein determining the edge set comprises generating edges of each beam connected to at least one column specified in the computer-aided design.

3. The computer-implemented method of claim 1, wherein performing the one or more clustering operations based on the edge set comprises: Multiple weighted directions are determined based on the edge set; For each clustering setting included in the multiple clustering settings, a clustering algorithm is performed on the multiple weighted directions to generate multiple directional cluster sets; The elbow rule heuristic is applied to the multiple directional cluster sets to determine the elbow points; as well as The first plurality of basic directions are calculated based on the plurality of directional clusters and the elbow points.

4. The computer-implemented method of claim 3, wherein calculating the first plurality of basic directions comprises: One or more ranking operations are performed on the multiple directional cluster sets based on multiple distances to the elbow point to determine the highest-ranked directional cluster set. as well as The first plurality of basic directions are determined based on the highest-ranked direction cluster set.

5. The computer-implemented method of claim 1, wherein performing the one or more clustering operations based on the first edge subset comprises: The first weighted equation subset is determined based on the first edge subset; Perform K-means clustering on the first weighted subset of equations to generate multiple equation clusters; as well as The first plurality of grid lines are generated by clustering based on the plurality of equations.

6. The computer-implemented method of claim 5, wherein determining the first subset of weighted equations comprises: The first equation is determined based on the first edge included in the first edge subset; as well as The first weighted equation is generated based on the first equation and at least one of the first value of the objective function that quantifies one or more design objectives of the structural system or the length associated with the first edge.

7. The computer-implemented method of claim 1, wherein a first grid line included in the first plurality of grid lines is associated with the computer-aided design of the structural system, and a second grid line included in the first plurality of grid lines is associated with another computer-aided design of the structural system.

8. The computer-implemented method of claim 1, wherein determining the first subset of edges comprises selecting each edge in the edge set that has a direction within a tolerance of the first basic direction.

9. The computer-implemented method of claim 1, further comprising generating a second frame grid of the structural system based on the first plurality of grid lines and a third plurality of grid lines associated with the second basic direction.

10. One or more non-transitory computer-readable media, the non-transitory computer-readable media comprising instructions that, when executed by one or more processors, cause the one or more processors to generate one or more frame grids of a building's structural system by performing the following steps: The edge set is determined based on the computer-aided design of the aforementioned structural system; One or more clustering operations are performed based on the edge set to determine a first plurality of basic directions; The first edge subset is determined based on the edge set and the first basic direction included in the first plurality of basic directions; Perform one or more clustering operations based on the first edge subset to determine a first plurality of grid lines associated with the first basic direction; as well as The first frame grid of the structural system is generated based on the first plurality of grid lines and the second plurality of grid lines associated with the second basic direction included in the first plurality of basic directions. The building comprises multiple floors, and the first frame grid is associated with each of the multiple floors.

11. One or more non-transitory computer-readable media as claimed in claim 10, wherein determining the edge set comprises: At least two sets of edges are determined based on multiple computer-aided designs of the structural system; as well as The edge set is determined from the union of the at least two sets of edges.

12. One or more non-transitory computer-readable media as claimed in claim 10, wherein performing the one or more clustering operations based on the edge set comprises: Multiple weighted directions are determined based on the edge set; Perform K-means clustering algorithm on the multiple weighted directions to generate multiple directional clusters; as well as The first plurality of basic directions are determined based on the clustering of the plurality of directions.

13. One or more non-transitory computer-readable media as claimed in claim 10, wherein performing the one or more clustering operations based on the first edge subset comprises: Multiple weighted equations are determined based on the first subset of edges; A clustering algorithm is performed on the multiple weighted equations for each of the multiple clustering settings to generate multiple equation cluster sets; Based on the cluster set of the multiple equations, the elbow rule heuristic is performed to determine the elbow point; as well as The first plurality of grid lines are calculated based on the elbow points and the plurality of equation clusters.

14. One or more non-transitory computer-readable media as claimed in claim 13, wherein calculating the first plurality of grid lines comprises: One or more ranking operations are performed on the multiple equation cluster sets based on multiple distances to the elbow point to determine the highest-ranked equation cluster set; as well as The first plurality of grid lines are determined based on the highest-ranked equation cluster set.

15. One or more non-transitory computer-readable media as claimed in claim 10, wherein a first grid line included in the first plurality of grid lines is associated with the computer-aided design of the structural system, and a second grid line included in the first plurality of grid lines is associated with another computer-aided design of the structural system.

16. One or more non-transitory computer-readable media as claimed in claim 10, wherein determining the first subset of edges includes selecting each edge in the subset that has a direction within a tolerance amount of the first basic direction.

17. The one or more non-transitory computer-readable media of claim 10, wherein the non-transitory computer-readable media further comprises generating a second frame grid of the structural system based on the first plurality of grid lines and a third plurality of grid lines associated with the second basic direction.

18. A system comprising: One or more memories, wherein the one or more memories store instructions; as well as One or more processors, coupled to one or more memories, wherein the one or more processors perform the following steps when executing the instructions: Determining edge sets based on computer-aided design of structural systems of buildings; One or more clustering operations are performed based on the edge set to determine a first plurality of basic directions; The first edge subset is determined based on the edge set and the first basic direction included in the first plurality of basic directions; Perform one or more clustering operations based on the first edge subset to determine a first plurality of grid lines associated with the first basic direction; as well as The first frame grid of the structural system is generated based on the first plurality of grid lines and the second plurality of grid lines associated with the second basic direction included in the first plurality of basic directions. The building comprises multiple floors, and the first frame grid is associated with at least one of the multiple floors.

Images