Technique for automatically designing structural systems of residential buildings

Abstract

In various embodiments, a room-based design application automatically generates a design of a floor structure of a building. In operation, the room-based design application generates blocks representing portions of the floor structure based on room plans included in a computer-aided design of the building, the portions being bounded by walls. The room-based design application modifies the blocks based on a span length to generate partitions. Each partition represents a different portion of the floor structure that is spannable in at least one direction by a structural element having the span length. Based on the partitions, the room-based design application determines a wall classification of the walls. The room-based design application generates at least a portion of the design of the floor structure based on the wall classification and the partitions.

Description

[0001] Cross-reference to related applications

[0002] This application is a continuation-in-part of a co-pending U.S. patent application filed December 18, 2020, with serial number 17 / 127,479, entitled "Techniques for Automatically Designing Structural Systems for Buildings". This application also claims priority to U.S. provisional patent application filed April 5, 2021, with serial number 63 / 171,018, entitled "Machine Learning Techniques For Designing Residential Structures". The subject matter of these related applications is hereby incorporated by reference. Background Technology Technical Field

[0004] The various implementation schemes generally involve structural engineering and computer-aided design, and more specifically, technology for automatically designing structural systems for residential buildings.

[0005] Related technical descriptions

[0006] In a typical building design process, the architect generates building plans that specify the building's outline, one or more outlines for each floor, and any number of building elements to be included in the building. Some examples of building elements include, but are not limited to, walls, elevators, and staircases. Once the building plans are complete, the structural engineer then designs the building's structural system based on the building 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 collectively enable the building to resist various loads according to the design constraints. For example, the structural system of a given building may include floor slabs, beams, and columns that enable the building to resist vertical loads from gravity and lateral loads from hurricane-force winds, provided that the allowable stress is not exceeded. 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 account for these changes.

[0007] In one approach to designing a building's structural system, structural engineers independently generate different designs of the structural system using conventional computer-aided design ("CAD") applications, 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, fundamental principles of structural engineering, building codes and engineering practice specifications, local government laws, and the structural engineer's professional experience. The baseline design specifies the layout of the building's structural members, as well as the dimensions used for those members, and other aspects. Using CAD applications, structural engineers then progressively 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.

[0008] One drawback of the above 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 improving the baseline design is often very time-consuming because evaluating design decisions involves performing computationally complex finite element analyses on many improved designs. Therefore, in a typical design process, only a small number of baseline designs for a given structural system can be generated and improved. Furthermore, structural engineers may sacrifice any number of design objectives to make conservative design decisions in order to shorten the time required to generate the final design. For example, a structural engineer may overestimate the required dimensions of some structural members to increase the likelihood that these members will be included in the final design without further modifications. In this case, the structural engineer will intentionally neglect to explore and evaluate a structural system design that more closely approximates the design objective of minimizing weight.

[0009] The aforementioned problems are exacerbated as the complexity and size of buildings increase. For example, for a typical multi-story building, the total number of different combinations of values ​​for relevant design variables may exceed half a million, each resulting in a different design for the building's structural system. Using conventional CAD applications cannot ensure that structural engineers have considered all these different combinations and resulting designs when generating the final design of the building's structural system. In fact, as mentioned above, in such cases, structural engineers are most likely to consider only a small fraction of the total possible designs, significantly reducing the likelihood of properly optimizing the final design.

[0010] 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

[0011] One embodiment of the present invention describes a computer-implemented method for automatically generating a design for the floor structure of a building. The method includes: generating blocks representing portions of the floor structure, defined by walls, based on room floor plans included in a computer-aided design of the building; modifying the blocks based on span lengths to generate partitions, wherein each partition represents a different portion of the floor structure, the different portions being traversable in at least one direction by a structural element having the span length; determining wall classifications based on the partitions; and generating at least a portion of the design for the floor structure based on the wall classifications and the partitions.

[0012] At least one technical advantage of the disclosed technology over the prior art is that it can be incorporated into CAD applications, enabling them to automatically explore the design space to identify areas of the building's structural system optimized for any number of design objectives. In this respect, using 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 likelihood of identifying and generating optimized designs of the structural system that approximate the building's design objectives. These technical advantages provide one or more technical improvements over existing methods. Attached Figure Description

[0013] 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 illustrate typical embodiments of the inventive concept and should therefore not be considered as limiting the scope, and that other equally effective embodiments exist.

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

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

[0016] Figure 3 It is based on various implementation plans. Figure 2 A more detailed illustration of the gravity design optimizer;

[0017] Figure 4 It is based on various implementation plans. Figure 1 A more detailed illustration of the mesh generation application;

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

[0019] Figure 6 It is based on various implementation plans. Figure 1 A more detailed illustration of the iterative sizing application;

[0020] Figures 7A to 7B A flowchart illustrating the steps involved in designing a structural system for a building, based on various implementation schemes;

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

[0022] 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;

[0023] Figures 10A to 10B A flowchart illustrating the steps of designing structural systems for buildings that resist lateral loads, based on various implementation schemes;

[0024] Figure 11 It is based on various implementation plans. Figure 1 A more detailed illustration of a grid-based design application;

[0025] Figure 12 It is based on various implementation plans. Figure 11 A more detailed illustration of the mesh transformation engine;

[0026] Figure 13 It is based on various implementation plans. Figure 11 A more detailed illustration of one of the area design engines;

[0027] Figure 14 It is a flowchart of the method steps for designing a structural system for generating floors of arbitrary shapes within a building, based on various implementation schemes;

[0028] Figure 15 It is based on various implementation plans. Figure 1 More detailed illustrations of the room-based design application;

[0029] Figure 16A It is based on various implementation plans. Figure 15 An exemplary diagram of the two in the subdivided floor areas;

[0030] Figure 16B It is based on various implementation plans. Figure 15 An exemplary diagram of both in the optimized partition set; and

[0031] Figure 17 It is a flowchart of the method steps for generating a building's floor structure design based on room floor plans, according to various implementation schemes. Detailed Implementation

[0032] 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.

[0033] System Overview

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

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

[0036] 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) can provide a multiprocessing environment in any technically feasible manner.

[0037] 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.

[0038] 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 capable of displaying visual content and receiving input (…). For example (From the user's) touchscreen.

[0039] In some implementations, computing instance 110 can be used with any number and / or type of other devices ( For example The computing instance 110, along with other instances, input devices, output devices, input / output devices, etc., are integrated into the user device. Some examples of user devices include, but are not limited to, desktop computers, laptop computers, smartphones, smart TVs, game consoles, tablet computers, etc.

[0040] 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 can be distributed across any number of other software applications, which reside in instances of the memory 116 of any number of instances of computing instance 110 and execute 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 can be combined into a single software application.

[0041] Specifically, computational instance 110 is configured to implement one or more computer-aided design (“CAD”) applications that can be used for the automated design of structural systems for buildings. As described earlier herein, in a conventional approach to designing structural systems for buildings, a structural engineer independently generates multiple baseline designs using one or more conventional CAD applications based on building plans, design and structural engineering principles, and design insights derived from the structural engineer’s overall design experience. The structural engineer then progressively refines the baseline designs using the conventional CAD applications, typically executing a finite element analysis solver to evaluate the 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.

[0042] One drawback of the above 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. In particular, the process of improving baseline designs is often very time-consuming, as evaluating design decisions involves performing computationally complex finite element analyses on many improved designs. Therefore, in a typical design process, only a small number of baseline designs for a given structural system can be generated and improved. 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.

[0043] Generative design technology for structural systems used in building design

[0044] To address the above 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 types of design objectives and design constraints. As described in more detail below, structural design application 120 defines a general optimization design problem and then decomposes it into multiple levels of less complex optimization problems, referred to herein as compositional optimization problems. Each of the compositional optimization problems is associated with a different aspect of the structural system design. To solve the general optimization design problem, structural design application 120 executes a general design process that dynamically adjusts itself based on the results generated in solving the compositional optimization problems.

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

[0046] 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, mesh generation application 150, iterative optimization application 172, and overall sorting engine 190. In the same or other embodiments, the iterative optimization application 172 includes, but is not limited to, the frame specification application 170 and the iterative sizing application 180.

[0047] In some embodiments, interface engine 108 displays a graphical user interface (“GUI”) 106 via display device 104. Interface engine 108 may receive any number and / or type of input via GUI 106 and may display any number and / or type of output via GUI 106. In some embodiments, 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 GUI 106. In the same or other embodiments, interface engine 108 displays via GUI 106 a portion (excluding or including all) of any number of solutions to the overall optimization design problem and / or any number of solutions constituting the optimization problem.

[0048] In some embodiments, the 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 quantity and / or type of auxiliary data. The structural design application 120 can generate the design problem definition 122 based on any quantity and / or type of input data in any technically feasible manner. As shown, in some embodiments, the structural design application 120 generates the design problem definition 122 at least in part based on input received via GUI 106. In the same or other embodiments, the interface engine 108 can display a portion (excluding or including all) of the design problem definition 122 via GUI 106.

[0049] The overall design optimization problem will generate any number of designs for the building's structural system 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)-164(W), and building wind load data 162, which are included in the computer-aided design (not shown) of the building, where W can be any positive integer.

[0050] In some embodiments, building plan 124 includes, but is not limited to, building outline 126 and floor outlines 128(1)-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)-128(F) is the outline of a different floor of the building. For purposes of explanation only, floor outlines 128(1)-128(F) are also referred to individually as “floor outline 128” and collectively as “floor outline 128”.

[0051] In the same or other embodiments, instead of building outline 126 and / or floor outline 128, or in addition to building outline 126 and / or floor outline 128, building floor plan 124 may also include any amount and / or type of data related to the structural system of the designed building. For example, in some embodiments, building floor plan 124 includes, but is not limited to, floor plans (not shown) of each of the floors, wherein each floor plan specifies floor outline 128, any number of rooms, 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 restricted to the grid lines included in the predefined column grid.

[0052] 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 can specify any quantity and / or type of limitation associated with the building. For example, in some embodiments, constraints 132 include, but are not limited to, those imposed by the user ( For example Any number of design constraints generally specified via GUI 106, any number of restrictions derived from design constraints and / or any other type of user input, any number and / or type of restrictions associated with building plan 124, any number and / or type of restrictions associated with any number and / or type of building codes and / or zoning regulations, and / or any number and / or type of restrictions associated with any aspect of construction.

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

[0054] In the same or other embodiments, the structural design application 120 generates any number of constraints 132, which specify (but are not limited to) any number of design safety factors associated with any number and / or type of building codes. In some embodiments, each of the design safety factors specifies (but is not limited to) the maximum allowable stress of a type of structural member under one or more types of loads. For example (Shear stress, bending stress, etc.). 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 implementations, design safety factors may be defined separately for the serviceability limit state and the ultimate limit state.

[0055] Objective function 134 encapsulates any number and / or type of design objectives in any technically feasible manner. 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 just a few. In some implementations, structural design application 120 receives objective function 134 as user input ( For example (via GUI 106). In other embodiments, the structural design application 120 can generate the objective function 134 in any technically feasible manner.

[0056] In some embodiments, objective function 134 quantifies the convergence of the design or any part thereof with respect to design objectives. Objective function 134 may 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 an aggregation of measures, each associated with one or more of the design objectives.

[0057] 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 based on the design variables optimized during the optimization operation. For example, in some embodiments, iterative sizing application 180 ignores any penalties associated with mesh spacing.

[0058] 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 dimensional ranges of any number of structural members of any number of types, the 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.

[0059] 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, mesh generation application 150, iterative optimization application 172, frame specification application 170, iterative sizing 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 is limited to 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 the overall design flow and / or 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.

[0060] Wind direction 164(1)-164(W) specifies any number of directions associated with the wind loads that the structural design application 120 will consider. In some embodiments, each of the wind loads is a load imposed by the wind on the building. For illustrative purposes only, wind direction 164(1)-164(W) is also referred to herein separately as “wind direction 164” and collectively as “wind direction 164”. In some embodiments, the structural design application 120 is based on user input ( For example The wind direction 164 is determined by the data received via GUI 106. In the same or other embodiments, the structural design application 120 can determine the wind direction 164 in any technically feasible manner.

[0061] Building wind load data 162 specifies, but is not limited to, any amount and / or type of lateral load that can be caused by winds 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)-164(W). Structural design application 120 or iterative sizing application 180 can 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 is based on building profile 126, wall locations, the created structural system, and user input ( For example (Received via GUI 106) to calculate building wind load data 162, wherein the user input specifies, but is not limited to, average wind speed, structural factors, terrain type, mountain factors, or any combination thereof.

[0062] In some implementations, after generating the design problem definition 122, the structural design application 120 defines an overall design optimization problem based on the objective function 134 and constraints 132, simultaneously considering gravity and building wind loads, when generating any number of designs for the building's structural system. 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 a layout and gravity design optimization problem, a frame mesh optimization problem, a frame system definition optimization problem, a vertical and lateral load design optimization problem, or any combination thereof.

[0063] In some implementations, in order 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)-148(N) based on the building plan 124 and design instructions 130 and optionally evaluates gravity design target values ​​146(1)-146(N), where N can be any positive integer. For illustrative purposes only, gravity designs 148(1)-148(N) are also referred to herein as “gravity design 148” and collectively as “gravity design 148”. Similarly, gravity design target values ​​146(1)-146(N) are also referred to herein as “gravity design target value 146” and collectively as “gravity design target value 146”.

[0064] Each of the gravity designs 148 is a different CAD design of the building's structural system, said different CAD designs being optimized based on objective function 134 and constraint 132, taking gravity into account but not the building's wind loads. "CAD design" is also referred to herein as "design". In some embodiments, the design of any part (including all) of the structural system specifies, but is not limited to, the CAD layout of said part of the structural system. Figure 1 (not shown in the image) and any quantity and / or type of size adjustment 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 (not shown in the diagram). 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.

[0065] 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 said part of the structural system. In some embodiments, the structural members specified in each of the layouts include, but are not limited to, any number of slabs, beams, and columns in any combination.

[0066] In some embodiments, dimensional adjustment data includes, but is not limited to, any number and / or type of dimensional adjustments to structural members specified in the layout. As mentioned herein, dimensional adjustments to a given structural member can specify, but are not limited to, any amount and / or type of data affecting the dimensions of the structural member. For example, in some embodiments, dimensional adjustments to a reinforced concrete slab specify the concrete grade, slab thickness, and the thickness and distribution of the reinforcing steel. In the same or other embodiments, dimensional adjustments to a steel column specify the cross-sectional profile.

[0067] 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), wherein each member of the frame resists both vertical and lateral loads. In some embodiments, each member of the frame includes, but is not limited to, any number and / or type of beams interconnected via moment-resisting joints and any number and / or type of columns. 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 of the framework specifications specifies a different framework in the framework system.

[0068] Because the gravity design application 140 does not consider any lateral loads when generating the gravity design 148 ( For example (Building wind load), therefore gravity design 148 does not need to include frame system specifications. Gravity design target values ​​146(1)-146(N) are the target values ​​of gravity design 148(1)-148(N). Gravity design application 140 can generate gravity design 148 in any technically feasible manner.

[0069] Combined with the following text Figure 2 In more detail, in some implementations, the gravity design application 140 implements a branch-merge design process to generate a gravity design 148. During the branching phase, the gravity design application 140 partitions each floor of the structural system into multiple sections ( 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. 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 of the segment layouts 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.

[0070] In some implementations, the gravity design application 140 independently initializes and optimizes the sizing data of each element in the segment layout to generate an optimized segment design. Figure 1 (Not shown in the image). Before optimizing the dimensional adjustment data, the gravity design application 140 can determine relevant data of any quantity (including the absence of any quantity) and / or type in any technically feasible manner. For example, in some embodiments, the gravity design application 140 uses domain-knowledge-based rules to determine the plate span type ( For example (Single-way span, double-way span, cantilever, etc.). In the same or other implementations, the gravity design application 140 uses domain-knowledge-based rules to select any number of continuous beam systems ( For example (Multiple groups of aligned edges) are treated as a single beam. To optimize the dimensional adjustment data for a given section design, the gravity design application 140 then optimizes the dimensional adjustment data comprising the slabs, beams, and columns based on constraints 132 and an objective function 134, taking gravity into account but not the building's wind loads. The gravity design application 140 also calculates the target value for optimizing the section design.

[0071] 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 dimensional adjustment data of the merged design (not shown) and calculates the associated target values.

[0072] In some implementations, gravity design application 140 determines different combinations of optimized floor designs to generate gravity design 148. Gravity design application 140 can 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 optimized floor designs that are closer to the design target. Gravity design application 140 then calculates gravity design target values ​​146(1)-146(N) based on objective function 134 and gravity designs 148(1)-148(N).

[0073] Although not shown, in some embodiments, the structural design application 120 does not need to solve the frame mesh optimization problem and / or the frame optimization problem. The structural design application can determine whether to solve the frame mesh optimization problem and / or the frame optimization problem in any technically feasible manner. In some embodiments, the structural design application 120 solves the frame mesh optimization problem and the frame optimization problem by default. In the same or other embodiments, if the design instruction 130 includes a predefined column mesh, the structural design application 120 does not solve the frame mesh optimization problem. Instead, the structural design application 120 uses predefined column mesh lines to determine one or more frame meshes instead of solving the frame mesh optimization problem, and modifies the techniques described herein accordingly.

[0074] Those skilled in the art will recognize that beams and columns in reinforced concrete frame structural systems are typically connected via rigid joints, and therefore the frame system is inherently defined. For this reason, in some embodiments, if gravity design 148 specifies a reinforced concrete frame structural system, the structural design application 120 does not solve either the frame mesh optimization problem or the frame optimization problem. Instead, the structural design application configures an iterative sizing application 180 to generate frame specifications specifying the frame at all possible locations while solving the vertical and lateral load design optimization problems. The techniques described herein are modified accordingly.

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

[0076] Each of the frame grids 158(1)-158(N) includes, but is not limited to, any number of grid line sets (not shown), where each grid line set is associated with a different direction. Together, the grid lines specify the permissible position of the frame of the building's structural system. For illustrative purposes only, frame grids 158(1)-158(M) are also referred to herein individually as "frame grid 158" and collectively as "frame grid 158".

[0077] Combined with the following text Figure 4 In more detail, in some embodiments, the mesh generation application 150 implements any number and / or type of unsupervised clustering techniques to generate the frame mesh 158. In some embodiments, the mesh generation application 150 determines the edge set based on gravity design 148. Figure 1 (Not shown in the diagram). 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 mesh generation application 150 generates different groups of edges for each of the gravity designs 148 and then determines the edge set based on the union of the edge groups.

[0078] Subsequently, in some implementations, the mesh 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). Then, the mesh generation application 150 applies any number and / or type of unsupervised clustering techniques to the weighted direction set to generate a base direction set (not shown in the image). Figure 1 (not shown in the image), the basic direction set includes, but is not limited to, any number of basic directions ( Figure 1 (Not shown in the image).

[0079] In the same or other embodiments, the mesh generation application 150 generates a weighted set of equations based on the equations of the edges included in the edge set and optionally based on the gravity design target value 146. Figure 1 (Not shown in the diagram). For each of the fundamental directions, the mesh generation application determines a corresponding subset of weighted equations (not shown) of the weighted equation set, which includes, but is not limited to, any number of weighted equations that are generally parallel to the fundamental directions.

[0080] For each of the weighted equation subsets, the mesh generation application 150 applies any number and / or type of unsupervised clustering techniques to the weighted equation subsets to determine any number of mesh line sets in the associated fundamental directions. Based on the mesh line sets in the fundamental directions, the mesh generation application 150 generates a frame mesh 158. In some embodiments, each of the frame meshes 158 comprises different combinations of mesh line sets in each of the fundamental directions.

[0081] In some implementations, the structural design application 120 generates configurations 168(1)-168(Z) based on gravity designs 148(1)-148(N) and frame grids 158(1)-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. Typically, each of configurations 168(1)-168(N) represents a different combination of gravity designs 148(1)-148(N) and frame grids 158(1)-158(M). The structural design application 120 can generate configurations 168(1)-168(Z) in any technically feasible manner. For example, in some implementations, the structural design application 120 generates an exhaustive combination of gravity designs 148(1)-148(N) and frame meshes 158(1)-158(M), and therefore Z equals the product of N and M. In some other implementations, the structural design application 120 generates an exhaustive combination of the optimal X gravity designs 148(1)-148(N) and the optimal X frame meshes 158(1)-158(M), and therefore Z equals the square of X, where X can be any integer (e.g., X can be N).

[0082] 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)-168(Z). More specifically, in some implementations, the structural design application 120 can configure any number of instances of the iterative optimization application 172 to generate structural designs 188(1)-188(Z) and building target values ​​186(1)-186(Z) sequentially, simultaneously, or in any combination thereof based on configurations 168(1)-168(Z).

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

[0084] Structural designs 188(1)-188(Z) are the designs of the structural system of a building. The iterative optimization application 172 optimizes the design based on the objective function 134 and constraints 132, taking into account both gravity and wind loads on the building. For illustrative purposes only, structural designs 188(1)-188(Z) are also referred to separately as “structural design 188” and collectively as “structural design 188” in this document. Building target values ​​186(1)-186(Z) are the target values ​​of structural designs 188(1)-188(Z). For illustrative purposes only, building target values ​​186(1)-186(Z) are also referred to separately as “building target value 186” and collectively as “building target value 186” in this document.

[0085] 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 iterative sizing application 180. In operation, the iterative optimization application 172 coordinates any number of design optimization iterations through the framework specification application 170 and the iterative sizing application 180. (The following is in conjunction with...) Figure 5 A more detailed description of the framework specification application 170 is provided below. Figure 6 The iterative sizing 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 structural design 188(1) and building target value 186(1) based on configuration 168(1). Figure 1 Describe the functionality of iteratively optimizing application 172.

[0086] In some implementations, to initiate a first design optimization iteration, the iterative optimization application 172(1) inputs the gravity design 148(1), the frame mesh 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 of the gravity design 148(1) and the frame mesh 158(1) in the wind direction 164. Figure 1 (Not shown in the text). For each of the 164 wind directions, 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).

[0087] 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 iterative sizing application 180 generates structural designs 188(1) and calculates the building target value 186(1) to complete each design optimization iteration.

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

[0089] To initiate each subsequent design optimization iteration, the iterative optimization application 172(1) inputs the building target value 186(1) generated by the iterative sizing 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 again determines the left frame count and the right frame count. Subsequently, the frame specification application 170 generates the frame system specification 178(1) again based on the re-determined left frame count and the re-determined right frame count.

[0090] 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 170 configures a genetic algorithm to iteratively and collectively optimize the Boolean values ​​of each of the potential frame locations across the set of potential frame locations based on building target values ​​186(1) associated with previous design optimization iterations (if any). During each design optimization iteration, after determining the Boolean values ​​of the potential frame locations using the genetic algorithm, the frame specification application 170 selects a location from the set of potential frame locations whose corresponding Boolean values ​​are 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 of the selected locations.

[0091] 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 to the gravity design 148(1) according to the frame system specification 178(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.

[0092] In some implementations, the iterative sizing application 180 defines and iteratively solves a nested optimization problem based on constraints 132 and an objective function 134, simultaneously considering gravity and building wind loads, to optimize the sizing of beams and columns included in the current structural design. To initiate 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 static 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.

[0093] To initiate each mid-level iteration, the iterative sizing application 180 distributes the building's wind loads across the frames corresponding to the frame code of the current structural design to generate fixed lateral loads for each member of the frame. For each member of the frame, the iterative sizing application 180 initiates any number of bottom-level iterations. During each bottom-level iteration for a given frame, the iterative sizing application 180 iteratively optimizes the sizing of columns and beams within the frame based on the fixed lateral loads associated with the frame. Notably, during each bottom-level iteration, the iterative sizing application 180 iteratively redistributes the fixed lateral loads across the structural members within the associated frame.

[0094] After the iterative sizing application 180 solves the nested optimization problem, iterative sizing application 180 sets the structural design 188(1,1) to be equal to the current structural design. Then, iterative sizing application 180 calculates the building target value 186(1) based on the structural design 188(1) and the objective function 134.

[0095] Then, the iterative optimization application 172(1) determines whether to initiate another design optimization iteration. The iterative optimization application 172(1) can determine whether to initiate another design optimization iteration in any technically feasible manner. In some embodiments, the iterative optimization application 172(1) determines whether to initiate another design optimization iteration based on any number and / or type of completion criteria specified by parameter data 138. In some embodiments, if the iterative optimization application 172(1) determines to initiate another design optimization iteration, 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 sorting engine 190.

[0096] In some implementations, after the overall sorting engine 190 receives structural designs 188(1)-188(Z) and building target values ​​186(1)-186(Z), the overall sorting engine 190 generates a sorted list of structural designs 198. The sorted 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 sorting engine 190 specifies the structural designs 188 in the sorted list of structural designs 198 in order of convergence decrease with respect to the design targets, based on the building target values ​​186.

[0097] As shown in the figure, in some embodiments, the overall sorting engine 190 transmits the sorted 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 (excluding or including all) of the sorted structural design list 198 and / or any number of solutions to any number of composition optimization problems in any memory available to at least one other software application. In some embodiments, the structural design application 120 transmits any part (excluding or including all) of the sorted structural design list 198 and / or any number of solutions to any number of composition optimization problems to any number of other software applications in any technically feasible manner.

[0098] In some implementations, structural design application 120, gravity design application 140, mesh 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 components, layouts, designs, frame systems, frames, or any combination thereof. In the same or other implementations, structural design application 120, gravity design application 140, mesh generation application 150, iterative optimization application 172, frame specification application 170, 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.

[0099] It is worth noting that, in some implementations, structural design application 120, gravity design application 140, mesh 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 principles to design, optimize, and / or analyze any number and / or type of structural members, layouts, designs, frame systems, frames, or any combination thereof.

[0100] Examples of fundamental principles of design and structural engineering include, but are not limited to, the compatibility of displacement concepts, structural idealization, the superposition principle, 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 floor slabs, beams, columns, frames, and / or frame systems to simplify the analysis and / or design of different parts (including the entirety) of the structural system.

[0101] Advantageously, incorporating any number (including all) of the functionalities described herein in the context of structural design application 120, gravity design application 140, mesh generation application 150, iterative optimization application 172, frame specification application 170, and iterative sizing application 180 into a CAD application increases the likelihood that the CAD application can generate optimized designs of structural systems that approximate 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 the fundamental principles of design and structural engines to evaluate design decisions can significantly reduce the time required for optimization design. Furthermore, compared to conventional CAD applications, structural design application 120 can explore the design space of the structural system more efficiently and systematically because it decomposes the overall optimization design problem into multiple component optimization problems. In the same or other embodiments, since any number of interface engines 108, gravity design application 140, mesh generation application 150, frame specification application 170, and iterative sizing application 180 can be configured to retain only the best solutions, the design space of the structural system can be explored in a more direct and therefore more efficient manner.

[0102] 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. Numerous modifications and variations to the functionality provided by the structural design application 120, interface engine 108, gravity design application 140, mesh generation application 150, iterative optimization application 172, frame specification application 170, iterative sizing application 180, and overall sorting engine 190 will be readily 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, mesh 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 in lieu of building wind loads.

[0103] 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, mesh generation application 150, iterative optimization application 172, frame specification application 170, iterative sizing application 180, and overall sorting engine 190 described herein can be integrated into any number of software applications (including one) and any number of components of the system 100, or distributed across any number of software applications and any number of components. Furthermore, modifications can be made as needed. Figure 1 The connection topology between various units in the system.

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

[0105] Gravity design generated via branch-merge design process

[0106] Figure 2 It is based on various implementation plans. Figure 1 A more detailed illustration of the gravity design application 140. (As previously mentioned 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.

[0107] As mentioned earlier 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 designs 148. In the same or other embodiments, the gravity design application 140 includes, but is not limited to, a design concept engine 220, any number of instances (not explicitly shown) of a floor design engine 210, and a multi-floor optimizer 290.

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

[0109] Each of the floor structure templates 222 is a template for the layout of a portion of the structural system corresponding to 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 immediately adjacent lower floor (if one exists) 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.

[0110] 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)-222(W) of respective specified, but not limited, slabs (not shown), characterized by slab material / type (not shown) and having positions with dimensions specified to be associated with the dimensions of floor profiles 128(1)-128(W). In the same or other embodiments, the horizontal cross-sections of the floor slabs specified in floor structure templates 222(1)-222(W) respectively match the floor profiles 128(1)-128(W).

[0111] An example of a 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 a slab material / type is a precast hollow core slab with precast beams, constructed using rectangular panels with an aspect ratio of 1.25. Yet another example of a 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 the slab material / type in any technically feasible manner.

[0112] In some implementations, the design instruction 130 specifies the panel material / type. In other implementations, the design concept engine 220 implements any number of expert system techniques to determine the panel material / type. For example, in some implementations, the 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 the floor profile 128, constraints 132, objective function 134, design variable data 136, or any combination thereof.

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

[0114] Although not shown, each of the sorted 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 partial design 268. Figure 2 (not explicitly shown in the text) and corresponding instances of some target values ​​266 ( Figure 2 (Not explicitly shown in the text). For illustrative purposes only, instances of the optimized partial design 268 are also referred to separately as "optimized partial design 268" and collectively as "optimized partial design 268" herein. Similarly, instances of the partial objective value 266 are also referred to separately as "partial objective value 266" and collectively as "partial objective value 266" herein.

[0115] Each of the optimized partial designs 268 is a design of at least a portion of the structural system and specifies, but is not limited to, dimensional adjustment data for the constituent structural members, said dimensional adjustment data being optimized based on constraint 132 and objective function 134 without considering lateral loads. Each of the partial objective values ​​266 corresponds to a different optimized partial design in optimized partial design 268 and is a value of objective function 134 of optimized partial design 268.

[0116] Each of the optimized partial designs 268 included in the ordered list of floor designs 288 associated with a given floor structure is a different design of the floor structure. For illustrative purposes only, the optimized partial design 268 corresponding to a given floor structure is also referred to separately as "optimized partial design 268 of the floor structure" and collectively as "optimized partial design 268 of the floor structure" in this document.

[0117] Design concept engine 220 can configure any number of instances of floor design engine 210 to generate ordered floor design lists 288(1)-288(F) sequentially, simultaneously, or in any combination thereof in any technically feasible manner. For illustrative purposes 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”.

[0118] As shown in the figure, in some embodiments, the gravity design application 140 configures the floor design engines 210(1)-210(F) to simultaneously generate sorted floor design lists 288(1)-288(F) based on the floor structure templates 222(1)-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 sequentially generate sorted floor design lists 288(1)-288(F).

[0119] The floor design engine 210 can generate a sorted list of floor designs 288 for a given floor structure in any technically feasible manner, based on the floor structure template 222 and design instructions 130. For illustrative purposes only, the following will further explain... 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 sorted 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.

[0120] 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 branches the floor optimization problem associated with a given floor structure into multiple different segment optimization problems. In some implementations, the partitioning engine 224 may branch each of the floor optimization problems into a different number of segment optimization problems.

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

[0122] As shown in the figure, in some embodiments, partitioning engine 224 generates segments 230(1)-230(S) based on floor structure template 222(1) and design instructions 130, where S can be any positive integer. In the same or other embodiments, each of the segments 230(1)-230(S) associated with floor structure template 222(1) is associated with a different portion of the slab specified in floor structure template 222(1). In some embodiments, partitioning engine 224 determines the value of S before generating segments 230(1)-230(S). For example, in some embodiments, 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 partitioning engine 224 based on floor structure template 222(1).

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

[0124] For example, in some embodiments, if the floor is U-shaped, the partitioning engine 224 partitions the floor structure template 222 into at least one or more east wings, one or more middle 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 from panels, the partitioning engine 224 partitions the floor structure template 222 into segments 230(1)-230(S) based at least in part on the dimensions of each of the panels.

[0125] Partition engine 224 configures segment design engine 240 to independently solve the segment optimization problem of each of segments 230(1)-230(S). In some implementations, in order to solve the segment optimization problem of segments 230(1)-230(S), partition engine 224 configures segment design engine 240 to generate sorted segment design lists 278(1)-278(S) based on segments 230(1)-230(S) and design instructions 130, respectively.

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

[0127] The partitioning engine 224 can configure any number of instances of the partition design engine 240 to generate ordered partition design lists 278(1)-278(S) sequentially, simultaneously, or in any combination thereof in any technically feasible manner. For illustrative purposes only, instances of the partition design engine 240 are also referred to herein as "partition design engine 240" individually and collectively.

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

[0129] The segment design engine 240 can generate each of the sorted segment design lists 278 in any technically feasible manner. For illustrative purposes only, the following will explain... Figure 2 The functionality of the segment design engine 240 (1) in some embodiments is described in more detail within the context of the segment design engine 240 (1) that generates a sorted 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 sorting engine 270.

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

[0131] For illustrative purposes only, instances of partial design 258 are also referred to individually as "partial design 258" and collectively as "partial design 258" herein. Each of partial designs 258 is a design of at least a part of the structural system. For each of segments 230, the partial 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 "partial design 258 of segment 230".

[0132] 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 partial designs 258 generated by the layout variation engine 250 for segment 230 (1). The layout variation engine 250 can generate any number of partial designs 258 for each of segments 230 in any technically feasible manner.

[0133] In some implementations, the layout variation engine 250 includes, but is not limited to, any number of instances (not explicitly shown) of segment layout 252, 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 of segment layouts 252 is a layout of one of segments 230. Each of the segment layouts 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.

[0134] In some implementations, the layout variation engine 250 implements any number and / or type of expert system techniques to generate any number of segment layouts 252 based on segment 230 and optionally on any amount (excluding) of design instructions 130. For example, in some implementations, 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 the absence of any amount) of design instructions 130.

[0135] In the same or other implementations, the layout variation engine 250 uses a trained “screening” machine learning model to predict which of the segment layouts 252 (if any) is below standard. The layout variation engine 250 then discards any of the 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 trained screening machine learning model.

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

[0137] As shown in the figure, in some implementations, the layout variation engine 250 configures the gravity design optimizer 260 to generate optimized partial designs 268(1)-268(K) and partial target values ​​266(1)-266(K) based on partial designs 258(1)-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 partial designs 268(1)-268(K) and partial target values ​​266(1)-266(K) sequentially, simultaneously, or in any combination thereof in any technically feasible manner. For illustrative purposes only, instances of the gravity design optimizer 260 are also referred to herein as "gravity design optimizer 260" individually and collectively.

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

[0139] The gravity design optimizer 260 can perform any number and / or type of optimization operations on the dimensional adjustments of structural members included in the partial design 258 to generate an optimized partial design 268. (See below for further details.) Figure 3 In more detail, in some implementations, the gravity design optimizer 260 sequentially optimizes the dimensional adjustments of the plates, beams and columns included in the partial design 258 to generate the optimized partial design 268.

[0140] As shown in the figure, in some implementations, the segment design sorting engine 270 generates a sorted list of segment designs 278(1) based on optimized partial designs 268(1)-268(K) and partial target values ​​266(1)-266(K). The segment design sorting engine 270 can generate the sorted list of segment designs 278(1) in any technically feasible manner. For example, in some implementations, the segment design sorting engine 270 sorts the optimized partial designs 268(1)-268(K) based on partial target values ​​266(1)-266(K).

[0141] In some implementations, the segment design sorting engine 270 filters out any number of optimized partial designs 268(1)-268(K) based on any number and / or type of screening criteria when generating a sorted list of segment designs 278(1). Therefore, in such implementations, the total number of optimized partial designs 268 specified in the sorted list of segment designs 278(1) is less than K. Optimized partial designs 268(1)-268(K) are also referred to herein as “potential segment designs”, and the optimized partial designs 268 specified in the sorted list of segment designs 178(1) are also referred to herein as “segment designs”. For example, in some implementations, the screening criteria are N optimal partial target values ​​266(1)-266(K) and associated optimized partial designs 268(1)-268(K) specified via the sorted list of segment designs 278(1), where N is the maximum change count. The segment design sorting engine 270 discards part of the target values ​​266(1)-266(K) and the remainder of the associated optimized part of the design 268(1)-268(K).

[0142] In some implementations, for each floor, the floor design engine 210 configures the incremental merging engine 280 to generate a floor design list 288 associated with the floor, based on the floor-associated, ordered 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 ordered floor design lists 288(1)-288(S) in any technically feasible manner.

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

[0144] In some implementations, the incremental merging engine 280 performs (S-1) different expansion iterations to generate a sorted list of floor designs 288(1). During the first expansion iteration, the incremental merging engine 280 sets the segment ranking value of each of segments 230(1)-230(S) to be equal to the best value among the partial objective values ​​266 included in the sorted list of segment designs 278(1)-278(S). The incremental merging engine 280 selects segment 230 with the worst segment ranking value from segments 230(1)-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. Then, the incremental merge engine 280 selects the segment with the worst segment order from the subset of segments 230(1)-230(S) adjacent to the first merge participant as the second merge participant.

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

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

[0147] 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 sorted 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 sorted list of floor designs 288 (1).

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

[0149] In some implementations, the multi-floor optimizer 290 is based on a sorted list of floor designs.

[0150] 288(1)-288(F) performs any number and / or type of incremental merge and / or aggregation operations.

[0151] To generate gravity designs 148(1)-148(N). In the same or other embodiments, the multi-story optimizer 290 executes any number and / or type of search algorithms in any combination to generate gravity designs 148. For example, in some embodiments, the multi-story optimizer 290 executes 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.

[0152] The multi-story optimizer 290 calculates the gravity design target values ​​146(1)-146(N) corresponding to the gravity designs 148(1)-148(N) in any technically feasible manner. For example, in some embodiments, the multi-story optimizer 290 applies the objective function 134 to the gravity designs 148(1)-148(N) to calculate the gravity design target values ​​146(1)-146(N) separately. Since the multi-story optimizer 290 combines the optimized partial designs 268 corresponding to different floor structures and does not need to optimize the optimized partial designs 268 for lateral loads, in some embodiments the multi-story optimizer 290 does not optimize the dimensional adjustments of any of the structural members.

[0153] In the same or other embodiments, the multi-story optimizer 290 calculates and specifies any number of vertical loads for each of the optimized sub-designs 268 associated with gravity design 148. For example, in some embodiments, the multi-story optimizer 290 sums the vertical loads at the column interfaces of the optimized sub-designs 268 associated with gravity design 148 to determine the corresponding vertical loads for gravity design 148. In the same or other embodiments, for an optimized sub-design 268 corresponding to a given floor structure, when there are no columns in the optimized sub-design 268 corresponding to a floor structure one floor below said floor structure, the multi-story optimizer 290 uses transfer beams. The transfer beams bear the loads from such “isolated” columns and transfer said loads to one or more existing columns and / or beams in the optimized sub-design 268 corresponding to a floor structure one floor below said floor structure.

[0154] 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 the figure, in some implementations, the gravity design optimizer 260 generates optimized partial designs 268 and partial target values ​​266 based on partial designs 258 and design instructions 130. (As previously mentioned in this document...) Figure 1 Each instance of the partial design 258 is a design of at least a portion of the structural system. More specifically, in some embodiments, each instance of the partial design 258 received by the gravity design optimizer 260 is a design of at least a portion of one of the floor structures.

[0155] As shown in the figure, in some embodiments, the gravity design optimizer 260 generates a floor design dataset 368 based on a partial design 258. In the same or other embodiments, the floor design dataset 368 includes, but is not limited to, floor layout 310, floor size adjustment data 320, floor live load data 322, and floor static 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.

[0156] Floor dimensional adjustment data 320 specifies, but is not limited to, any quantity and / or type of dimensional adjustment 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 of the rooms included in floor layout 310. Floor static load data 324 includes, but is not limited to, any quantity and / or type of static load associated with floor layout 310.

[0157] Although not shown, in some embodiments, floor design dataset 368 specifies any number and / or type of default connections between the structural members specified in floor layout 310. For example, in some embodiments, floor design dataset 368 specifies that each of the connections between the structural members specified in floor layout 310 is a rigid joint. It is worth noting that floor design dataset 368 does not specify any lateral loads, and gravity design optimizer 260 does not consider any lateral loads ( For example (Building wind load).

[0158] 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 sizing adjustments specified in the plate data 312 based on constraints 132 and an objective function 134, without considering any lateral loads. The gravity plate optimizer 360 can optimize the plate sizing adjustments in any technically feasible manner.

[0159] In some implementations, the gravity plate optimizer 360 sorts different design options from best to worst based on corresponding target values. The gravity plate optimizer 360 then performs a bisection algorithm to find the design option with the best target value that satisfies constraint 132. In some other implementations, the gravity plate optimizer 360 iteratively optimizes the slab sizing via a non-gradient-based optimization algorithm. For example, in some implementations, the gravity plate 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 plate optimizer 360 uses basic structural engineering principles to determine the minimum thickness that satisfies constraint 132 and the minimum amount of reinforcing steel required for said minimum thickness.

[0160] In some implementations, the gravity plate optimizer 360 calculates initial values ​​for both live and static loads before modifying the plate's sizing. As the gravity plate optimizer 360 iteratively modifies the plate's sizing, it recalculates the associated static loads. In some implementations, the initial values ​​for the static loads include, but are not limited to, surface finishes that remain unchanged after subsequent modifications by the gravity plate optimizer 360. For exampleThe portion generated by the slab (floor tiles), and the portion generated by the slab's self-weight recalculated from the gravity slab optimizer when the gravity slab optimizer 360 modifies the slab's sizing adjustment. In some embodiments, after the gravity slab optimizer 360 completes the modification of the slab's sizing adjustment, the gravity slab optimizer 360 updates the floor sizing adjustment data 320, the floor live load data 322, and the floor static load data 324. In the same or other embodiments, the gravity design application 140 uses domain knowledge-based rules to determine the slab span type ( For example (Single-way crossing, two-way crossing, cantilever, etc.)

[0161] Subsequently, in some implementations, based on the slab span type, the gravity design optimizer 260 distributes static and live loads across a subset of beams specified in the beam list 314. The gravity design optimizer 260 updates the floor live load data 322 and the floor static load data 324 accordingly. The gravity design optimizer 260 then configures the gravity beam optimizer 370 to optimize the sizing of the beams specified in the 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 sizing in any technically feasible manner. For example, in some implementations, the gravity beam optimizer 370 may use a bisection algorithm to optimize the beam sizing.

[0162] For example, in some embodiments, the gravity beam optimizer 370 iteratively optimizes the beam sizing via a bisection algorithm and any number and / or type of structural engineering fundamentals. In the same or other embodiments, the gravity beam optimizer 370 optimizes the beam sizing 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 the modification of the beam sizing, the gravity beam optimizer 370 updates the floor sizing data 320 and the floor static load data 324.

[0163] Subsequently, in some implementations, the gravity design optimizer 260 distributes static and live loads on the columns specified in the column list 316 and updates the floor live load data 322 and floor static load data 324 accordingly. The gravity design optimizer 260 then configures the gravity column optimizer 380 to optimize the sizing of the columns 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 sizing in any technically feasible manner.

[0164] For example, in some embodiments, the gravity column optimizer 380 iteratively optimizes column sizing via a bisection algorithm and any number and / or type of structural engineering fundamentals. In the same or other embodiments, the gravity column optimizer 380 optimizes column sizing 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 the modification of the column sizing, the gravity column optimizer 380 updates the floor sizing data 320 and the floor static load data 324.

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

[0166] In some embodiments, the gravity design optimizer 260 transfers the optimized partial design 268 and / or partial target values ​​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 partial design 268 and / or partial target values ​​266 in memory accessible to at least one other software application. In some embodiments, the gravity design optimizer 260 stores the optimized partial design 268 and partial target values ​​266 in memory accessible to the gravity design application 140.

[0167] 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, the gravity design optimizer 260 omits the floor design dataset 368 and configures the gravity plate optimizer 360, gravity beam optimizer 370, and gravity column optimizer 380, thereby modifying parts of the design 258 in any technically feasible manner.

[0168] Use unsupervised clustering to generate frame meshes.

[0169] Figure 4 It is based on various implementation plans. Figure 1 A more detailed illustration of the mesh generation application 150. For illustrative purposes only. Figure 4 The described implementation scheme, in conjunction with the preceding discussion of this document, addresses the issues discussed herein. Figure 1 The functionality of the mesh generation application 150 is described within the context of the mesh optimization problem described in the framework.

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

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

[0172] As shown in the figure, in some embodiments, the mesh generation application 150 includes, but is not limited to, a basic orientation engine 410, a mesh equation engine 440, and a mesh specification engine 490. Upon receiving a gravity design 148, the mesh generation application 150 generates an edge set 402. To generate the edge set 402, the mesh generation application 150 initializes the edge set 402 as an empty list. For each gravity design 148, the mesh 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 edge corresponding to a different beam. Each of the edges is associated with both direction and length.

[0173] In some embodiments, the mesh generation application 150 associates each of the edges with a gravity design 148 including the corresponding beam. In the same and other embodiments, the mesh generation application 150 represents each edge on the boundary of the gravity design 148 including the corresponding beam as a boundary edge. The mesh 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.

[0174] In some implementations, the mesh generation application 150 inputs edge set 402 and any portion of optional parameter data 138 into a base orientation engine 410. In response, the base orientation engine 410 generates a sorted list of orientation clusters 408. The sorted list of orientation clusters 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.

[0175] 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 unique directions for the edges included in the edge set 402. The base direction engine 410 then weights the directions based on the total length of the non-boundary edges in each direction and the total length of the boundary edges in that direction to generate corresponding weighted directions (not shown). Subsequently, the base direction engine 410 generates the weighted direction set 412, including but not limited to the weighted directions. In some other implementations, the base direction engine 410 may determine and weight the directions in any technically feasible manner based on any amount and / or type of criteria associated with the generated frame mesh 158.

[0176] Then, the base direction engine 410 inputs any portion of the weighted direction set 412 and optional 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)-428(D), where D can be any positive integer. The direction cluster sets 428(1)-428(D) are also referred to individually herein as "direction cluster set 428" and collectively as "direction cluster set 428". Each of the direction cluster sets 428 specifies, but is not limited to, a different distribution of the weighted directions included in the weighted direction set 412 over any number of direction clusters (not shown). It is worth noting that the number of direction clusters included in any given pair of direction cluster sets 428 can be the same or different.

[0177] Subsequently, the directional clustering engine 420 can perform any number and / or type of sorting and / or filtering operations on the directional clusters 428 to generate a sorted list 408 of directional clusters. The directional clustering engine 420 and / or the base directional engine 410 can determine the total number (denoted herein as D) of the directional clusters 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 directional clusters in the directional clusters 428. In some other embodiments, the directional clustering engine 420 implements a default value for D.

[0178] More specifically, in some embodiments, the directional clustering engine 420 includes, but is not limited to, K-means clustering algorithms 424(1)-424(D) and cluster sorting engine 430. Each of the K-means clustering algorithms 424(1)-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)-424(D) are also referred to herein separately 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)-424(D) to simultaneously generate directional cluster sets 428(1)-428(D).

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

[0180] The directional clustering engine 420(0) can be configured to generate directional cluster sets 428(1)-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)-422(D) respectively into the K-means clustering algorithm 424(1)-424(D). In response, the K-means clustering algorithm 424(1)-424(D) outputs directional cluster sets 428(1)-428(D) respectively.

[0181] Clustering settings 422(1)-422(D) are also referred to herein as “clustering settings 422” individually and collectively. Each of the clustering settings 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 of the clustering settings 422 specifies different combinations of K values ​​(i.e., the number of clusters to be generated) and seeds.

[0182] 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 a K value and a seed for each of the clustering settings 422. In some other embodiments, the directional clustering engine 420 determines an allowable range of K values ​​and any number and / or type of seed heuristic based on parameter data 138. In yet another embodiment, 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.

[0183] As shown in the figure, in some implementations, the directional clustering engine 420 inputs directional clusters 428(1)-428(D) into the cluster sorting engine 430. In response, the cluster sorting engine 430 can perform any number and / or type of sorting and / or filtering operations on the directional clusters 428(1)-428(D) to generate a sorted list of directional clusters 408. (Sorted list of directional clusters)

[0184] 408 includes, but is not limited to, any number and / or type of criteria based on any technically feasible standard.

[0185] Any number of directional clusters 428(1)-428(D) can be sorted in this manner.

[0186] In some implementations, the cluster ranking engine 430 includes, but is not limited to, the elbow heuristic 432. The elbow heuristic 432 is based on the elbow rule. As those skilled in the art will recognize, the elbow rule refers to a method used to determine the optimal number of clusters into which a set of points can be clustered. Right now K-value is a well-known technique. As shown in the figure, in some implementations, the elbow rule heuristic 432 determines the elbow point 434 based on the orientation clusters 428. In some implementations, for each of the orientation clusters 428, the elbow rule heuristic 432 determines a value based on a variance metric. The elbow rule heuristic 432 clusters the K-value and the variance-based metric of the orientation clusters 428 into two groups, and then sets the elbow point 434 as the intersection of these two groups.

[0187] In some implementations, for each of the directional clusters 428, the cluster sorting engine 430 calculates the distance to the elbow 434 based on the associated K value and a variance-based metric. The cluster sorting engine 430 then sorts the directional clusters 428 based on the distance to the elbow 434 to generate a sorted list of directional clusters 408. In some implementations, the cluster sorting engine 430 can filter out any number of directional clusters 428 included in the sorted list of directional clusters 408 based on any technically feasible criteria. For example, in some implementations, the cluster sorting engine 430 determines the minimum variance value required for the sorted list of directional clusters 408 based on parameter data 138. If the sorted list of directional clusters 408 includes those directional clusters with variance greater than the required minimum value, the cluster sorting engine 430 deletes those directional clusters. For example, in some implementations, the cluster sorting engine 430 determines the maximum permissible value for the variance-based metric based on parameter data 138. For each of the directional clusters 428 included in the sorted directional cluster list 408, if the associated value of the variance-based metric is higher than the maximum allowed value, the cluster sorting engine 430 removes the directional cluster 428 from the sorted directional cluster list 408.

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

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

[0190] Despite Figure 4Not depicted herein, but in some other embodiments, the mesh generation application 150 generates different instances of a base direction set 436 for each of any number of direction clusters included in the sorted list of direction clusters 408. Instances of the base direction set 436 are also collectively referred to herein as "base direction set 436". Each of the base direction sets 436 may include, but is not limited to, different total numbers of base directions 438. The mesh generation application 150 inputs each of the base direction sets 436 into different instances of the mesh equation engine 440 to generate one or more frame meshes 158 for each of the base direction sets 436.

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

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

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

[0194] As shown in the figure, in some implementations, the equation partitioning engine 450 generates weighted equation subsets 458(1)-458(B) based on the weighted equation set 442 and the basic directions 438(1)-438(B), respectively. For illustrative purposes only, the weighted equation subsets 458(1)-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)-458(B) represent different subsets of the weighted equation set 442 associated with the basic directions 438(1)-438(B), respectively. The equation partitioning engine 450 can generate the weighted equation subsets 458(1)-458(B) in any technically feasible manner.

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

[0196] 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 of the basic directions 438(1)-438(B), the edge partitioning engine determines a distinct subset of edges included in the edge set 402 that are generally parallel to the basic direction 438. As used herein, when the direction associated with the edge is within the tolerance of the basic direction 438 ( For example When within 3 degrees of the fundamental direction 438, the edges are approximately parallel to the fundamental direction 438. For each of the fundamental directions 438, the equation engine generates a weighted subset of equations 458 associated with the fundamental direction 438 based on a subset of the edges associated with the fundamental direction and optionally the gravity design target value 146(1)-146(N).

[0197] As shown in the figure, in some implementations, the grid equation engine 440 inputs any part (including any part that does not exist) of the parameter data 138 and the weighted equation subsets 458(1)-458(B) into the equation clustering engine 460(1)-460(B). In response, the equation clustering engine 460(1)-460(B) generates a sorted list of equation clusters 468(1)-468(B). For illustrative purposes only, the sorted list of equation clusters 468(1)-468(B) is also referred to herein as the sorted list of equation clusters 468 and collectively as the "sorted list of equation clusters 468".

[0198] In some implementations, the grid equation engine 440 inputs parameter data 138 and any portion (including the absence of any portion) of the weighted equation subsets 458(1)-458(B) sequentially, simultaneously, or in any combination thereof into any number of instances of the equation clustering engine 460. For example, in some implementations, the grid equation engine 440 sequentially inputs the weighted equation subsets 458(1)-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 sorted list of equation clusters 468(1)-468(B).

[0199] Upon receiving one of the weighted equation subsets 458, the grid 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 clusters (not shown). Each of the equation clusters specifies, but is not limited to, a different distribution of the weighted equations over any number of equation clusters (not shown). It is worth noting that the number of equation clusters included in any given pair of equation cluster sets can be the same or different.

[0200] Subsequently, the grid equation engine 440 can perform any number and / or type of sorting and / or filtering operations on the equation clusters to generate a sorted list 468 of equation clusters. Therefore, in some embodiments, the sorted list 468 of equation clusters specifies, but is not limited to, one or more equation clusters. More precisely, the sorted list 468(b) of equation clusters (where b is an integer from 1 to B) specifies, but is not limited to, one or more equation clusters associated with the fundamental direction 438(b).

[0201] The equation clustering engine 460 can be obtained in any technically feasible way. For exampleThe grid equation engine 440 receives or determines any amount and / or type of configuration data. Some examples of configuration data are, but are not limited to, the total number of equation families, any number and / or type of settings associated with each of the generated equation families, any number and / or type of sorting criteria, and any number and / or type of filtering criteria. For example, in some implementations, the grid equation engine 440 determines any amount and / or type of configuration data based on parameter data 138.

[0202] Although not depicted, in some embodiments, the equation clustering engine 460 performs the same type of clustering, sorting, 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 in a set of equation clusters.

[0203] 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 sorts the equation clusters based on increasing distances to elbows 434 to generate a sorted list 468 of equation clusters. In some implementations, the equation clustering engine 460 may perform any number and / or type of filtering operations on the sorted list 468 of equation clusters.

[0204] As shown in the figure, in some implementations, the mesh specification engine 490 generates frame meshes 158(1)-158(M) based on a sorted list of equation clusters 468(1)-468(B), where M can be any positive integer. Each frame mesh 158 includes, but is not limited to, different combinations of B mesh line sets, where each combination of the B mesh line sets includes a mesh line set for each of the basic directions 438(1)-438(B). The mesh specification engine 490 can generate the frame meshes 158 in any technically feasible manner.

[0205] In some implementations, in order to generate the frame mesh 158(m), where m is an integer between 1 and M, the mesh specification engine 490 obtains the mesh from a sorted list of equation clusters.

[0206] Choose one from the set of equation families in each of 468(1)-468(B). Then, the mesh specification...

[0207] Engine 490 generates a different set of mesh lines for each of the B selected equation families.

[0208] Subsequently, the mesh specification engine 490 aggregates B mesh line sets to generate a frame mesh of 158 (m).

[0209] The mesh specification engine 490 can generate a set of mesh lines for each of the selected set of equation families in any technically feasible manner. In some embodiments, for a given set of equation families, the mesh specification engine 490 generates a set of mesh lines, which includes, but is not limited to, different mesh lines for each equation family included in the set. In the same or other embodiments, the mesh specification engine 490 generates mesh lines for a given cluster based on the equations associated with the centroid of the cluster. In some embodiments, after generating the mesh lines, the mesh specification engine 490 captures each of the mesh lines to any nearby building features (…). For example (boundary edge) and extend each of the grid lines beyond the boundary edge associated with the nearest floor.

[0210] In some implementations, the set of grid lines for each of the B selected sets of equations specifies one or more equations that are generally parallel to the fundamental direction 438 associated with the selected set of equations. Thus, for each of the fundamental directions 438(1)-438(B), each of the frame grids 158(1)-158(M) includes, but is not limited to, one or more grid lines parallel to the fundamental direction 438.

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

[0212] In some other embodiments, the mesh specification engine 490 implements a genetic algorithm to iteratively determine different combinations of equation clusters. For example, in some embodiments, the mesh specification engine 490 implements a genetic algorithm that includes, but is not limited to, B distinct design variables representing a sorted list 468 of equation clusters. In the same or other embodiments, the genetic algorithm determines the fitness 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.

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

[0214] Define the framework system via genetic algorithm

[0215] Figure 5 It is based on various implementation plans. Figure 1 A more detailed illustration of the framework specification application 170; for illustrative purposes only, Figure 4 The described implementation scheme, in conjunction with previous articles, Figure 1 The functionality of the frame specification application 170 is described within the context of the frame mesh 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 vertical and lateral loads.

[0216] As mentioned earlier in this article Figure 1 In some embodiments, to initiate a first design optimization iteration, the iterative optimization application 172 inputs wind direction 164(1)-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, which specifies, but is not limited to, at least one frame ( Figure 5 (Not shown) Position in each of the 164 wind directions.

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

[0218] 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 iterative sizing 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.

[0219] 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 in a frame system (not shown) 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.

[0220] 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)-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)-514(W) based on the frame grid 158(1), gravity design 148(1), and wind direction 164(1)-164(W), respectively. For illustrative purposes only, the potential frame location sets 514(1)-514(W) are also referred to herein as "potential frame location set 514" and are collectively referred to as "potential frame location set 514".

[0221] In some implementations, each of the potential frame location set 514 includes, but is not limited to, different sets of locations, where each location is within a tolerance of a different grid line in the frame grid 158 and corresponds to a different potential frame for the gravity design 148. In some other implementations, prior to executing the frame specification application 170 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 of the locations 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 for the gravity design 148.

[0222] As mentioned herein, a “potential” frame in 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, which 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 set of potential frame locations 514 are also referred to herein as “potential frame locations.”

[0223] In the same or other embodiments, the potential frame location set 514(1)-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)-164(W) when the constituent structural members are internally connected via moment joints. In some embodiments, each of the grid lines is associated with at most one location in the potential frame location set 514. The wind direction distribution engine 510 can generate the potential frame location set 514 in any technically feasible manner.

[0224] 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 on 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 of the potential frames is on a different grid line in the frame grid 158. The wind direction allocation engine 510 then calculates the projection of each of the wind directions 164 onto each of the potential frames. 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.

[0225] 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 static and live loads of all floors in the building. In the same or other embodiments, the frame specification application 170 configures the frame partitioning engine 530(1)-530(W) based on the building load centroid 520 to branch the potential frame location set 514(1)-514(W) into left frame group 542(1)-542(W) and right frame group 544(1)-544(W).

[0226] Each of the frame partitioning engines 530(1)-530(W) is a different instance of frame partitioning engine 530 (not explicitly shown). For illustrative purposes only, frame partitioning engines 530(1)-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)-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)-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 as “potential frame locations” herein.

[0227] In some implementations, for each of the 164 wind directions, the frame specification application 170 inputs the wind direction 164(w) (where w is an integer from 1 to W), the potential frame location set 514(w), and the building load centroid 520 into the frame partitioning engine 530(w). In response, the frame partitioning engine 530(w) sets the left frame group 542(w) to a subset of the potential frame location set 514(w) specifying the positions to the left of the building load centroid 520 with respect to wind direction 164(w). The frame partitioning engine 530(w) sets the right frame group 544(w) to a subset of the potential frame location set 514(w) specifying the positions to the right of the building load centroid 520 with respect 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).

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

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

[0230] 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) to be a frame 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)-572(W) to integers within the left frame count range 562(1)-562(W), respectively. For the left frame count range 562(1)-562(W), the frame specification application 170(1-1) sets the lower bound to one and correspondingly sets the upper bound to the size of the left frame group 542(1)-542(W). Thus, each of the left frame count ranges 562(1)-562(2) is an integer range.

[0231] 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) to be a frame 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)-574(W) to integers within the right frame count range 564(1)-564(W), respectively. For the right frame count range 564(1)-564(W), the frame specification application 170 sets the lower bound to one and correspondingly sets the upper bound to the size of the right frame group 544(1)-544(W). Thus, each of the right frame count ranges 564(1)-564(W) is an integer range.

[0232] After configuring the genetic algorithm 550, the framework specification application 170 enables 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 of the left frame counts 572(1)-572(W) to a random integer within each of the left frame count ranges 562(1)-562(W), and sets each of the right frame counts 574(1)-574(W) to a random integer within each of the right frame count ranges 564(1)-564(W). In some other embodiments, the genetic algorithm 550 sets each of the left frame counts 572(1)-572(W) and each of the right frame counts 574(1)-574(W) to one.

[0233] In some implementations, after the genetic algorithm 550 determines or re-determines the left frame count 572 and the right frame count 574 for a given design optimization iteration, the frame selection engine 580 generates a frame system specification 178 for the design optimization iteration. As shown in the figure, 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.

[0234] In some implementations, the frame selection engine 580 implements frame selection rules (not shown) based on encapsulating design and structural engineering principles to generate frame system specifications 178. According to design and structural engineering principles, the effectiveness of a frame in resisting wind increases with increasing distance from the building's 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 to be selected from the left frame group 542(w) and the right frame group 544 in descending order of distance from the building's load center of mass 520.

[0235] In the same or other implementations, for each of the left frame groups 542(w) (where w is an integer from 1 to W), the frame selection engine 580 selects the left frame count 572(w) with the position specified in the left frame group 542(w) based on the frame selection rules. Therefore, the frame selection engine 580 selects the position 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 positions in the left frame group 542(w) that are farthest from the building load centroid 520.

[0236] Similarly, in some implementations, for each of the right frame groups 544(w) (where w is an integer from 1 to W), the frame selection engine 580 selects the right frame count 574(w) with the specified position in the right frame group 544(w) based on the frame selection rules. Therefore, the frame selection engine 580 selects the position in the right frame group 544(w) that is farthest from the building load centroid 520. For example, if the right frame count 574(1) is three, the frame selection engine 580 selects the three positions in the right frame group 544(w) that are farthest from the building load centroid 520.

[0237] 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 of the selected locations. The frame system specification 178 can specify the frame system in any technically feasible manner. For example, in some embodiments, the frame system specification 178 is a list of selected locations.

[0238] 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 by at least one other software application. In some embodiments, the framework specification application 170 stores the framework system specification 178 in memory accessible by the iterative optimization application 172, and the iterative optimization application 172 inputs the framework system specification 178 into the iterative sizing application 180.

[0239] 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 can 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 can 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.

[0240] As indicated by the dashed arrow, in some implementations, upon receiving a building target value 186 associated with the current design optimization iteration as input, the framework specification application 170 regenerates the framework system specification 178 for the new design optimization iteration. 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.

[0241] 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. Then, the frame selection engine 580 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.

[0242] 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 elapsed since the last input received by the framework specification application 170 exceeds a maximum waiting time.

[0243] Optimize structural member dimensions for vertical and lateral loads

[0244] Figure 6 It is based on various implementation plans. Figure 1 A more detailed illustration of the iterative sizing application 180; for illustrative purposes only. Figure 6 The described implementation scheme, in conjunction with previous articles, Figure 1 The functionality of the iterative sizing application 180 is described within the context of solving the vertical and lateral load design optimization. More specifically, the iterative sizing application 180 adds or modifies the connections and sizing 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 static loads, live loads, and building wind loads included in the building wind load data 162.

[0245] 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 can be performed in any technically feasible manner. The iterative sizing application 180 can modify connections and / or sizing adjustments between any type of structural members in any type of design for 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 connections and / or sizing adjustments in the structural system design based on any amount of data (including the absence of any amount), any number and / or type of optimization criteria, and any number and / or type of constraints 132.

[0246] As shown in the figure, in some implementations, the iterative sizing application 180 generates structural design 188 and building target values ​​186 based on gravity design 148, frame system specifications 178, design specifications 130, and building wind load data 162. (This text previously combined...) Figure 1 This describes gravity design 148, design specifications 130, and building wind load data 162. This article previously combined... Figure 5 The framework system specification 178 is described in detail.

[0247] In the same or other embodiments, the iterative sizing application 180 includes, but is not limited to, a design initialization engine 620, a structural system iteration controller 630, a frame system iteration controller 650, and frame iteration engines 670(1)-670(R). Each of the frame iteration engines 670(1)-670(R) is a different instance of the frame iteration engine 670 (not explicitly shown). For illustrative purposes only, the frame iteration engines 670(1)-670(R) are also referred to herein individually as “frame iteration engine 670” and collectively as “frame 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 the frame system specification 178. In some other embodiments, the iterative sizing application 180 may include, but is not limited to, any number (including one) of instances of the frame iteration engine 670.

[0248] As shown in the figure, in some implementations, the design initialization engine 620 initializes the structural design dataset 610 based on the gravity design 148, the frame system specification 178, and the design description 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 the gravity design 148.

[0249] 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, dimensional adjustment data 614, frame specifications 616(1)-616(R), connection data 618, live load data 622, static load data 624, lateral load data 626, and design specification 130, wherein R may be any positive integer.

[0250] 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 shown in italics, in some embodiments, building layout 612 is fixed and therefore not modified by the iterative dimensional adjustment application 180. Dimensioning data 614 specifies, but is not limited to, dimensional adjustment data for any quantity and / or type of structural members included in the current structural design.

[0251] Frame specifications 616(1)-616(R) are also referred to herein as “Frame Specification 616” and are collectively referred to as “Frame Specification 616”. In some embodiments, each of Frame Specification 616 specifies a different frame (not shown), and these frames are collectively referred to herein as “Frame System” (not shown). In the same or other embodiments, the Frame System corresponds to Frame 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 Frame System Specification 178(1,1).

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

[0253] 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 of the frame specifications 616.

[0254] 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 iterative sizing application 180. Static load data 624 includes, but is not limited to, any number and / or type of static 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, static loads, and lateral loads included in the live load data 622, static load data 624, and lateral load data 626 may be specified at any granularity level with respect to the current structural design. For example, in some embodiments, the live loads and static loads are specified with respect to a horizontal region ( For example,Distributed load of the room.

[0255] 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 of the member lateral loads is associated with one of the structural members in 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 of the structural members. Each of the building lateral loads 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.

[0256] 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 the design specification 130 to the structural design dataset 610. As previously described herein, the design specification 130 includes, but is not limited to, constraints 132, objective function 134, design variable data 136, and parameter data 138. In the same or other embodiments, the design initialization engine 620 copies any amount and / or type of data from the gravity design 148 to initialize the building layout 612 and sizing adjustment data 614.

[0257] 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 set 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 set of structural members in the current structural design and generates frame specification 616 specifying, but not limited to, the identified set of structural members. Therefore, the total number of frame specifications 616 is equal to the number of locations specified in frame system specification 178.

[0258] In the same or other embodiments, the design initialization engine 620 initializes 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 of frame specifications 616, the design initialization engine 620 specifies via 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 connection data 618 that each connection between structural members not specified in frame specification 616 in the current structural design is a pin joint or a hinged joint.

[0259] In some embodiments, the design initialization engine 620 copies data from the gravity design 148 to initialize the live load data 622 and the static load data 624. In other embodiments, the design initialization engine 620 calculates the live load data 622 and the static load data 624 based on the building layout 612, dimensional adjustment data 614, and optionally design specifications 130. In some embodiments, the design initialization engine 620 initializes the lateral load data 626 to specify an initial value of zero for each of any number and / or type of member lateral load.

[0260] 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 engine 670(1)-670(R) can read, write, and / or modify the structural design dataset 610. In some other embodiments, the iterative sizing application 180 can route data of any quantity 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 engine 670(1)-670(R) in any technically feasible manner.

[0261] 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, simultaneously considering gravity and any number and / or type of lateral building loads. In some implementations, one or more of the constraints 132 are safety design factors that ensure the structural design 188 satisfactorily resists both vertical and lateral loads.

[0262] 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, thereby solving 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.

[0263] In some implementations, in order to initiate each “top loop iteration”, the structural system iteration controller 630 is configured to optimize the dimensional adjustment 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 dimensional adjustment data 614 for any number and / or type of structural members in the current design in any technically feasible manner.

[0264] 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 static 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 fundamental 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 dimensional adjustment data 614 of beams and / or columns in the current structural design.

[0265] In some other embodiments, the structural system iterative controller 640 executes a bisection-based beam optimization algorithm that iteratively optimizes the beam dimensional adjustment data 614 based on an objective function 134 and constraints 132, thereby updating the static 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 dimensional adjustment data 614 based on an objective function 134 and constraints 132, thereby updating the static load data 624 after each iteration while keeping the lateral load data 626 fixed.

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

[0267] 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.

[0268] 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, in order to initiate 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 across the frame corresponding to the frame specification 616.

[0269] For example, as shown 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 across the frame corresponding to frame specification 616. In some embodiments, the building wind load data 162 includes, but is not limited to, data for any number of directions ( For example, Different building wind loads for each of the wind directions 164(1)-164(W)).

[0270] The lateral load distribution engine 660 can distribute building lateral loads specified by the frame system iteration controller 650 across frames corresponding to frame specification 616 in any technically feasible manner. In some embodiments, the lateral load distribution engine 660 applies any number and / or type of basic rules to distribute building lateral loads across corresponding frames, each basic rule encapsulating any number and / or type of structural engineering fundamentals into frame specification 616. In the same or other embodiments, the lateral load distribution engine 660 distributes building lateral loads across frames based on the stiffness of the frames. 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 a portion of the building lateral load distributed by the lateral load distribution engine 660 to the frame. Thus, for each frame specification 616, the frame lateral load specifies a portion of the building lateral load distributed by the lateral load distribution engine 660 to the corresponding frame. Frame lateral loads are also referred to herein as “frame-based lateral loads”.

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

[0272] As shown in the figure, in some implementations, the framework system iteration controller 650 configures framework iteration engines 670(1)-670(R) to independently solve the underlying layers of the optimization problem for each of the framework specifications 616(1)-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 underlying layers of the optimization problem for each of the framework specifications 616(1)-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 underlying layers of the optimization problem for each of the framework specifications 616(1)-616(R).

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

[0274] To address the underlying optimization problem of frame specification 616, frame iteration engine 670 can optimize the dimensional adjustment data 614 of structural members specified in frame specification 616 in any technically feasible manner, while keeping the associated lateral loads of the frame fixed. As shown in 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 dimensional readjustment engine 690.

[0275] In some implementations, the frame iteration controller 672 initiates any number of iterations included in the bottom loop to optimize the dimensional adjustment data 614 of the structural members 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 for the frame corresponding to frame specification 616, based at least in part 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.

[0276] In some implementations, 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, frame analyzer 680 applies any number and / or type of fundamental rules to frame code 616 based on frame lateral loads to calculate partial bending moment diagrams (not shown) and partial shear force diagrams (not shown). More specifically, in some implementations, frame analyzer 680 applies portal method, equivalent column method, or moment distribution method to dimensional adjustment data 614 for structural members specified in frame code 616 based on frame lateral loads to generate partial bending moment diagrams and partial shear force diagrams.

[0277] Subsequently, in some embodiments, the frame analyzer 680 determines any number and / or type of vertical loads associated with the frame corresponding to frame specification 616 based on live load data 622 and static load data 624. The frame analyzer 680 then uses an overlay method to generate a bending moment diagram 662 for the frame corresponding to frame specification 616 based on the vertical loads associated with the frame and partial 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 for the frame corresponding to frame specification 616 based on the vertical loads associated with the frame and partial shear force diagrams.

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

[0279] For example, in some embodiments, the lateral load sizing engine 690 executes a bisection-based frame optimization algorithm that jointly optimizes the beam and column sizing data 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 data 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 data 614 of structural members specified in frame specification 616 in any technically feasible manner while keeping the associated lateral loads on the frame constant.

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

[0281] In some implementations, if the maximum number of bottom loop iterations (not shown) has been reached for frame specification 616, 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 dimensional adjustment data 614 of the structural members specified in frame specification 616 between bottom loop iterations.

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

[0283] As indicated by the dashed arrow, if the frame iteration controller 672 does not initiate another bottom loop iteration, it indicates to the frame system iteration controller 650, in any technically feasible manner, that the bottom loop of frame specification 616 has completed. In some implementations, when the bottom loop of frame specification 616 completes, 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.

[0284] After the instance of the frame iteration engine 670 has completed the bottom loop of frame specifications 616(1)-616(R), the frame system iteration controller 650 may optionally perform 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 when the building wind load is applied to the building results in unbalanced torsional forces. 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.

[0285] 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 a design safety factor (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 dimensional readjustment 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 relative to the building's wind load on the weaker side of the building (…). example like(in the left frame group 542 or the right frame group 544) of the frame.

[0286] After the frame system iteration controller 650 optionally performs any number of optimization and / or refinement operations on the frame specification 616, the intermediate loop iteration is completed. The frame system iteration controller 650 then determines whether to initiate another intermediate loop iteration. The frame system iteration controller 650 may determine whether to initiate 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, the frame system iteration controller 650 does not initiate another top loop iteration. In the same or other embodiments, the frame system iteration controller 650 determines whether to initiate another intermediate loop iteration based at least in part on the magnitude of any changes to the dimensional adjustment 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 bottom loop iterations. In some embodiments, if the frame system iteration controller 650 determines that the relevant dimensional adjustment options have been explored, the frame system iteration controller 650 does not initiate another bottom loop iteration.

[0287] As indicated by the dashed arrow, if the framework system iteration controller 650 does not initiate another intermediate loop iteration, it indicates to the structure system iteration controller 630 that the intermediate loop is complete. In some implementations, when the intermediate loop completes, the framework system iteration controller 650 has already solved the intermediate layer of the nested optimization problem of the framework system relative to the top loop iteration.

[0288] Then, the structural system iteration controller 630 determines whether to initiate another top loop iteration. The structural system iteration controller 630 can determine whether to initiate 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, the structural system iteration controller 630 does not initiate another top loop iteration. In the same or other embodiments, the structural system iteration controller 630 determines whether to initiate another top loop iteration based at least in part on the magnitude of any changes to the sizing data 614 between top loop iterations. In some embodiments, if the structural system iteration controller 630 determines that relevant sizing options have been explored, the frame system iteration controller 650 does not initiate another bottom loop iteration.

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

[0290] 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 by 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).

[0291] 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 structural system. Those skilled in the art will recognize that beams and columns in a reinforced concrete frame structural 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 iterative sizing application 180, design initialization engine 620 generates frame specification 616, which specifies the frame at all appropriate locations of gravity design 148. In the same or other embodiments, if frame system specification 178 is not entered into iterative sizing application 180 and gravity design 148 specifies vertical loads, iterative sizing application 180 does not execute structural system iteration controller 630 before performing a first structural system design iteration.

[0292] Will understand, in Figure 6The example of the iterative sizing application 180 depicted and described in conjunction with this figure is illustrative, and variations and modifications to the iterative sizing application 180 are possible. For example, the functionality provided by the iterative sizing application 180 described herein can be integrated into or distributed across any number of components of the iterative sizing application 180. Furthermore, the connection topology between the various components of the iterative sizing application 180 can be modified as needed.

[0293] 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 and / or route said data to any number of components, between said components, and from said components in any technically feasible manner. In some embodiments, the iterative sizing application 180 receives gravity design 148, frame system specification 178, design specification 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 structural system iteration controller 630, frame system iteration controller 650, and frame iteration engine 670 to co-optimize the initial structural design based on design specification 130 and building lateral loads.

[0294] Figures 7A to 7B A flowchart illustrating the method steps for generating at least one design of a building's structural system according to various implementation schemes. (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.

[0295] As shown in the figure, method 700 begins at 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. Then, the gravity design application 140 selects the first floor. In step 704, the partitioning engine 224 partitions the floor structure template 222 of the selected floor into any number of segments 230, and then selects the first segment from the segments 230 of the selected floor.

[0296] In step 706, the layout variation engine 250 generates multiple partial designs 258 for the selected segment 230. In step 708, the gravity design optimizer 260 optimizes the partial designs 258 of the selected segment 230 based on constraints 132 and objective function 134 to generate optimized partial designs 268 for the selected segment 230. In step 710, the segment design sorting engine 270 sorts the optimized partial designs 268 of the selected segment 230 based on objective function 134 to generate a sorted list of segment designs 278 for the selected segment 230.

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

[0298] However, if in step 712 the partitioning engine 224 determines that the selected segment 230 is the last segment among the segments 230 associated with the selected floor, then method 700 proceeds directly to step 716. In step 716, the incremental merging engine 280 performs incremental per-segment merging and optimization operations on the sorted segment design list 278 associated with the selected floor to generate a sorted floor design list 288 for the selected floor.

[0299] In step 718, the gravity design application 140 determines whether the selected floor is the last floor. If in step 718 the gravity design application 140 determines that the selected floor is not the last floor, then method 700 proceeds to step 720. In 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.

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

[0301] 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-720 may be performed sequentially, simultaneously, or in any combination thereof for each of the floors. Similarly, steps 706-714 may be performed sequentially, simultaneously, or in any combination thereof for each of the segments 230.

[0302] Figures 8A to 8B A flowchart illustrating the steps of methods for generating a frame mesh for a building's structural system, based on various implementation schemes. (See references...) 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.

[0303] As shown in the figure, method 800 begins at step 802, where mesh generation application 150 acquires a gravity design 148 and optionally a gravity design target value 146 associated with the gravity design 148. In step 804, mesh 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.

[0304] In 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. In 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. In step 810, the direction clustering engine 420 performs any number and / or type of sorting and / or filtering operations on the direction cluster set 428 to generate a sorted list of direction cluster sets 408.

[0305] In step 812, for each of any number of direction clusters 428 that has the highest ranking according to the sorted list of direction clusters 408, the mesh generation application 150 generates a base direction set 436 based on the direction clusters included in the direction clusters 428. In step 814, the mesh generation application 150 selects a first base direction from the base direction set 436.

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

[0307] In step 822, the grid equation engine 440 performs any number and / or type of clustering operations on the weighted equations included in a selected subset of weighted equations from the weighted equation subset 458 to generate one or more equation clusters. In step 824, the grid equation engine 440 performs any number and / or type of sorting and / or filtering operations on the equation clusters to generate a sorted list 468 of equation clusters for the base direction 438 associated with the selected subset of weighted equations from the weighted equation subset 458.

[0308] In step 826, the mesh equation engine 440 determines whether a selected subset of weighted equations in the weighted equation subset 458 is the last weighted equation subset in the weighted equation subset 458 associated with the selected base direction set 436. If in step 826 the mesh equation engine 440 determines that a selected subset of weighted equations in the weighted equation subset 458 is not the last weighted equation subset in the weighted equation subset 458 associated with the selected base direction set 436, then method 800 proceeds to step 828.

[0309] In step 828, the mesh equation engine 440 selects the next weighted equation subset 458 associated with the selected basic direction set 436, and method 800 returns to step 822, where the mesh equation engine 440 generates one or more new sets of equations. Method 800 continues to loop between steps 822 and 828 until step 826, when the mesh equation engine 440 determines that a selected weighted equation subset 458 is the last weighted equation subset 458 associated with the selected basic direction set 436.

[0310] If, in step 826, the mesh equation engine 440 determines that a selected subset of weighted equations 458 is the last weighted subset of weighted equations associated with the selected base direction set 436, then method 800 proceeds directly to step 830. In step 830, the mesh specification engine 490 generates any number of frame meshes 158 based on a sorted list 468 of equation clusters of the selected weighted subset of weighted equations 458.

[0311] In step 832, the mesh generation application 150 determines whether the selected basic direction set 436 is the last one in the basic direction set 436. If the mesh generation application 150 determines in step 832 that the selected basic direction set 436 is not the last one in the basic direction set 436, then method 800 proceeds to step 834. In step 834, the mesh generation application 150 selects the next one in the basic direction set 436, and method 800 returns to step 818, where the equation partitioning engine 450 determines a weighted subset of equations 458 based on the selected basic direction set 436. Method 800 continues to loop between steps 818 and 834 until step 822, when the mesh generation application 150 determines that the selected basic direction set 436 is the last one in the basic direction set 436.

[0312] If, in step 822, the mesh generation application 150 determines that the selected basic direction set 436 is the last of the basic direction sets 436, then method 800 proceeds directly to step 836. In step 836, the mesh generation application 150 stores and / or transfers any number of frame meshes 158 to any number of software applications for use in other design activities. Then, method 800 terminates.

[0313] For illustrative purposes only, the method 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 of the basic direction set 436. Similarly, steps 820 to 828 may be performed sequentially, simultaneously, or in any combination thereof for each of the weighted equation subset 458.

[0314] 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.

[0315] As shown in the figure, method 900 begins at step 902, where the wind direction distribution engine 510 determines a set 514 of potential frame locations for each of the wind directions 164 based on the building's gravity design 148 and frame mesh 158. In step 904, the wind direction distribution engine 510 calculates the building load centroid 520 of the building based on the gravity design 148.

[0316] In step 906, for each of the 164(w) wind directions (where w is an integer from 1 to W), the frame partitioning engine 530 bifurcates 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. In step 908, the frame specification application 170 implements a genetic algorithm 550 with two design variables for each of the 164(w) wind directions: a left frame count 572(w) and a right frame count 574(w).

[0317] In 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. In step 912, for each of the 164(w) wind directions, 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. In step 914, for each of the 164(w) wind directions, 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.

[0318] In 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 the selected locations. In step 918, the frame specification application 170 stores and / or provides the frame system specification 178 to any number of software applications for use in other design activities.

[0319] In 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, in step 920, the framework specification application 170 determines that it has not acquired the building target value 186, then method 900 terminates.

[0320] However, if in step 920 the frame specification application 170 determines that it has acquired the building target value 186, then method 900 proceeds to step 922. In step 922, the frame specification application 170 causes the genetic algorithm 550 to redetermine the left frame count 572 and the right frame count 574 based on the building target value 186. Then, method 900 returns to step 912, where the frame selection engine 580 selects a position 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.

[0321] Method 900 continues to loop between steps 912 and 922 until step 920, when the framework specification application 170 determines that it has not acquired the building target value 186. Then, method 900 terminates.

[0322] Figures 10A to 10B A flowchart illustrating the steps of a method for designing a structural system for a building to resist lateral loads, based on various implementation schemes. (Although references are provided...) 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.

[0323] As shown in the figure, method 1000 begins at step 1002, where design initialization engine 620 generates structural design dataset 610, which specifies, but is not limited to, a frame system based on gravity design 148 and frame system specification 178. Then, structural system iterative controller 630 initializes the lateral loads on the members to zero. In step 1004, structural system iterative controller 640 sequentially optimizes the dimensional adjustments of beams and columns specified in structural design dataset 610 based on constraints 132 and objective function 134, while keeping the lateral loads on the members fixed.

[0324] In step 1006, the lateral load distribution engine 660 distributes the lateral loads of one or more buildings ( For example The building wind loads included in the building wind load data 162 are distributed on the frames corresponding to frame specification 616 to determine any number of frame lateral loads for each of the frames. Then, the frame system iterative controller 650 selects the frames corresponding to frame specification 616(1).

[0325] In 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. In step 1010, the lateral load sizing engine 690 jointly optimizes the sizing of beams and columns in the selected frame based on the bending moment diagram 662, the shear force diagram 664, constraint 132, and objective function 134.

[0326] In step 1012, the frame iteration controller 672 determines whether it has completed the optimization of the selected frame. If, in step 1012, the frame iteration controller 672 determines that it has not yet completed the optimization of 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.

[0327] However, if in step 1012 the frame iteration controller 672 determines that it has completed the optimization of the selected frame, then method 1000 proceeds directly to step 1014. In step 1014, the frame system iteration controller 650 determines whether the selected frame corresponds to the last one in frame specification 616. If in 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.

[0328] In step 1016, the frame iteration controller 672 selects the next corresponding frame in frame specification 616. Then, method 1000 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 between steps 1008 and 1016 until step 1014, when the frame iteration controller 672 determines that the selected frame corresponds to the last one in frame specification 616.

[0329] If, in 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. In step 1018, the frame system iteration controller 650 determines whether the frame system iteration controller 650 has completed the optimization of the frame system.

[0330] If, in step 1018, the frame system iteration controller 650 determines that it has not yet completed the optimization of the frame system, then method 1000 returns to step 1006, where the lateral load distribution engine 660 redistributes the building's lateral loads on the frame corresponding to frame specification 616. Method 1000 continues to loop between steps 1006 and 1018 until, in step 1018, the frame system iteration controller 650 determines that it has completed the optimization of the frame system.

[0331] If, in step 1018, the frame system iterative controller 650 determines that it has completed the optimization of the frame system, then method 1000 proceeds to step 1020. In step 1020, the structural system iterative controller 630 determines whether it has completed the optimization of the structural design dataset 610.

[0332] If, in step 1020, the structural system iterative controller 630 determines that it has not yet completed the optimization of the structural design dataset 610, then method 1000 returns to step 1004, whereby the structural system iterative controller 640 sequentially optimizes the dimensional adjustments of beams and columns in the structural design dataset 610 while keeping the lateral loads on the members fixed. Method 1000 continues to loop between steps 1004 and 1020 until, in step 1020, the structural system iterative controller 630 determines that it has completed the optimization of the structural design dataset 610.

[0333] If, in step 1020, the structural system iteration controller 630 determines that it has completed the optimization of the structural design dataset 610, then method 1000 proceeds to step 1022. In 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. In step 1024, the iterative sizing 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.

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

[0335] Structural systems that generate floors of arbitrary shapes

[0336] Now return to the reference Figure 1 In some implementations, the structural design application 120 may include, but is not limited to, a mesh-based design application 1100. In the same or other implementations, the mesh-based design application 1100 may reside in the memory 116 of the computing instance 110 and execute on the processor 112 of the computing instance 110.

[0337] Combined with the following text Figures 11 to 14In more detail, in some implementations, the grid-based design application 1100 automatically generates CAD designs for structural systems that enable floors of arbitrary shapes in buildings of arbitrary shapes to resist vertical loads. For example (Gravity). The CAD design of the structural system is also referred to as "structural system design" in this document. The grid-based design application 1100 can be executed independently to generate structural system designs for individual floors, or it can be integrated into any number and / or type of design process in any technically feasible manner.

[0338] In some embodiments, the gravity design application 140 is modified to use a mesh-based design application 1100 instead of the floor design engine 210 to generate a gravity design 148 that enables buildings of arbitrary shapes to resist vertical loads. Although not shown, in the same or other embodiments, the iterative optimization application 172 can use any number of gravity designs 148 generated by the mesh-based design application 1100 to generate a structural design 188 that enables buildings of arbitrary shapes to resist both vertical and lateral loads.

[0339] Generally speaking, compared to the floor design engine 210, the grid-based design application 1100 can generate designs for structural systems with floors of a wider variety of shapes and sizes. (As previously mentioned in this article...) Figure 2 In some embodiments, the floor design engine 210 independently generates partial designs 258 for segments 230. Each segment 230 represents a structural system for a relatively small rectangular portion of the floor. In contrast, in some embodiments, a grid-based design application 1100 generates corresponding designs for structural grids and structural systems for relatively large, arbitrarily shaped floor portions referred to herein as “segments”.

[0340] In some implementations, each structural grid includes, but is not limited to, indicating the main structural members ( For example Different arrangements of grid lines for preferred locations of beams. In the same or other embodiments, each layout of the structural system for a given area is associated with one of any number of structural grids for each design and associated with the area. In some embodiments, grid-based design application 1100 and / or any number of other applications use grid lines to facilitate the representation of areas of arbitrary shapes using a polygonal quadrilateral data structure. In a polygonal quadrilateral data structure, a polygon can be represented by one to four grid lines, each grid line having one or more parent edges, and each parent edge having zero or more child edges.

[0341] In the same or other embodiments, the grid-based design application 1100 combines structural system designs for one or more zones to generate one or more structural system designs for any floor within any type of building. For example, in some embodiments, the floor design engine 210 generates structural system designs for floors of arbitrary shapes within a multi-story office building. In the same or other embodiments, the floor design engine 210 generates structural system designs for floors of arbitrary shapes within a single-story residential building.

[0342] In some other embodiments, the grid-based design application 1100 can represent floors and shapes of arbitrary shapes in any technically feasible manner. In the same or other embodiments, the gravity design application 140 and / or the iterative optimization application 172 use a polygonal quadrilateral data structure or another data structure capable of efficiently representing polygonal shapes to generate structural system designs associated with at least a portion of an arbitrarily shaped building.

[0343] In some implementations, because the zone can be significantly larger than segment 230, the time required for the grid-based design application 1100 to generate a structural design for a given floor can be significantly reduced compared to the time required for the floor design engine 210 to generate the structural design for that floor. In some implementations, the grid-based design application 1100, instead of the floor design engine 210, can successfully generate large buildings within the time allocated to design activities. For example The structural design of floors in a large factory. Furthermore, compared to the floor design engine 210, because users are generally familiar with grid-based design, they can more easily and efficiently perform other design activities using designs generated by the grid-based design application 1100.

[0344] Figure 11 It is based on various implementation plans. Figure 1 An illustration of the grid-based design application 1100. Return to reference. Figure 1 In some implementations, the grid-based design application 1100 resides in the memory 116 of the computing instance 110 and executes on the processor 112 of the computing instance 110. As shown, in some implementations, the grid-based design application 1100 generates a sorted list of floor designs 288 based on zones 1112(1)-1112(A) included in the partitioned floor outline 1110, design specification 130, and zone specifications 1120(1)-1120(A) (where A can be any positive integer).

[0345] In some embodiments, zones 1112(1)-1112(A) are associated with zone descriptions 1120(1)-1120(A), respectively. Each of zones 1112(1)-1112(A) may specify any number and / or type of objects and / or areas of any size and shape. Each zone 1112 is associated with any number of boundary edges defining the boundaries of zone 1112. In some embodiments, the boundaries of zones 1112(1)-1112(A) are non-overlapping, and the set of zones 1112(1)-1112(A) represents floors of any type of building. In some embodiments, the building is a low-rise building, a mid-rise building, or a large factory.

[0346] Zone 1112 can be determined in any technically feasible manner. For example, in some embodiments, the user specifies zone 1112 via GUI 106. In some other embodiments, the grid-based design application 1100 can determine zone 1112 in any technically feasible manner. For example, in some embodiments, the grid-based design application 1100 compares changes in floor plans of different floors to determine zone 1112. In the same or other embodiments, the grid-based design application 1100 clusters the edge orientations of building features to identify zones 1112 with similar building feature orientations.

[0347] As mentioned earlier in this article Figure 1 In some embodiments, design specification 130 includes, but is not limited to, constraints 132 associated with the building, objective function 134, design variable data 136, and parameter data 138. As explicitly shown with respect to area specification 1120(1), in some embodiments, area specifications 1120(1)-1120(A) include, but are not limited to, design concepts 1122(1)-1122(A), domain knowledge 1124(1)-1124(A), and mesh constraint sets 1126(1)-1126(A), respectively. In some embodiments, any number and / or type of area specifications 1120(1)-1120(A) may cover any number and / or type of design specification 130.

[0348] Area descriptions 1120(1)-1120(A) are also referred to separately as “Area Description 1120” and collectively as “Area Description 1120” in this document. Design concepts 1122(1)-1122(A) are also referred to separately as “Design Concept 1122” and collectively as “Design Concept 1122” in this document. Domain knowledge 1124(1)-1124(A) are also referred to separately as “Domain Knowledge 1124” and collectively as “Domain Knowledge 1124” in this document. Mesh constraint sets 1126(1)-1126(A) are also referred to separately as “Mesh Constraint Set 1126” and collectively as “Mesh Constraint Set 1126” in this document.

[0349] Design concepts 1122(1)-1122(A) specify, but are not limited to, any quantity and / or type of data defining the characteristics of a structural system designed for sections 1112(1)-1112(A) of a building floor. An example of design concept 1122 is a two-way spanning cast-in-place concrete floor structure where the beams have I-beam sections and the columns have hollow box sections. Another example of design concept 1122 is an oriented strand board (OSB) floor structure with rectangular glued laminated timber sections. Yet another example of design concept 1122 is a two-way reinforced concrete slab with reinforced concrete beams.

[0350] Domain knowledge 1124(1)-1224(A) may include, but is not limited to, any amount and / or type of knowledge relating to the design and analysis of a structural system. For example, in some embodiments, each piece of domain knowledge 1124(1)-1124(A) includes, but is not limited to, knowledge that can be used to determine the plate span type for each plate. For example Any number and / or type of knowledge-based rules (such as one-way crossings, two-way crossings, cantilevered structures, etc.). Mesh constraint sets 1126(1)-1126(A) specify, but are not limited to, any number and / or type of constraints on the structured mesh of zones 1112(1)-1112(A). For example, in some embodiments, mesh constraint set 1126(1) specifies, but is not limited to, the minimum spacing, maximum spacing, and maximum cantilever length associated with the structured mesh of zone 1112(1).

[0351] The ordered floor design list 288 corresponds to floors including, but not limited to, zones 1112(1)-1112(A). In some embodiments, the ordered floor design list 288 includes, but is not limited to, any number of designs for the structural system of the corresponding floor and the target values ​​of the designs. The target values ​​of the designs determine the order of the designs within the ordered floor design list 288. As previously mentioned herein... Figure 2 The structural system of the floors mentioned above is also referred to as the "floor structure" in this article.

[0352] In some embodiments, each design of the floor structure specifies, 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, 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 immediately adjacent lower floor (if one exists) or the foundation. In some embodiments, each layout and each design of the floor structure 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, and optionally any number of grid lines.

[0353] As shown in the figure, in some implementations, the grid-based design application 1100 includes, but is not limited to, an edge clustering engine 1140(1)-1140(A), a grid orientation set 1148(1)-1148(A), a grid transformation engine 1150(1)-1150(A), a gridded region set 1160(1)-1160(A), a region design engine 1170(1)-1170(A), a sorted region design list 1180(1)-1180(A), and a region combination engine 1190. The edge clustering engine 1140(1)-1140(A), the grid orientation set 1148(1)-1148(A), the grid transformation engine 1150(1)-1150(A), the gridded region set 1160(1)-1160(A), the region design engine 1170(1)-1170(A), and the sorted region design list 1180(1)-1180(A) are associated with region 1112(1)-1112(A).

[0354] Edge Clustering Engine 1140(1)-1140(A) are different instances of a single software application referred to herein as “Edge Clustering Engine 1140”, and are also referred to herein as “Edge Clustering Engine 1140”. Mesh Variation Engine 1150(1)-1150(A) are different instances of a single software application referred to herein as “Mesh Variation Engine 1150”, and are also referred to herein as “Mesh Variation Engine 1150”. Zone Design Engine 1170(1)-1170(A) are different instances of a single software application referred to herein as “Zone Design Engine 1170”, and are also referred to herein as “Zone Design Engine 1170”.

[0355] In some implementations, the number of instances of the edge clustering engine 1140, the mesh transformation engine 1150, the region design engine 1170, or any combination thereof may differ from the total number of regions 1112, and the techniques described herein are modified accordingly. Instances of the edge clustering engine 1140 may be executed sequentially, simultaneously, or in any combination thereof. Instances of the mesh transformation engine 1150 may be executed sequentially, simultaneously, or in any combination thereof. Instances of the region design engine 1170 may be executed sequentially, simultaneously, or in any combination thereof.

[0356] For illustrative purposes only, grid-oriented sets 1148(1)-1148(A) are also referred to as “grid-oriented sets 1148” in this document and are collectively referred to as “grid-oriented sets 1148”. Gridded area sets 1160(1)-1160(A) are also referred to as “gridded area sets 1160” in this document and are collectively referred to as “gridded area sets 1160”. Sorted area design lists 1180(1)-1180(A) are also referred to as “sorted area design lists 1180” in this document and are collectively referred to as “sorted area design lists 1180”.

[0357] For illustrative purposes only, Figure 11 In the context of [the above], variable x represents any integer from 1 to A (inclusive). In some embodiments, any instance of the edge clustering engine 1140 can generate a grid-oriented set 1148(x) in any technically feasible manner based on zone 1112(x) and any amount (including the absence of any amount) and / or type of additional data. In the same or other embodiments, any instance of the grid variation engine 1150 can generate a grid zone set 1160(x) in any technically feasible manner based on zone 1112(x), grid-oriented set 1148(x), and any amount (including the absence of any amount) and / or type of additional data. In some embodiments, any instance of the zone design engine 1170 can generate a sorted list of zone designs 1180(x) in any technically feasible manner based on the gridded zone set 1160(x), design specification 130, and any amount (including none) and / or type of additional data.

[0358] As shown in the figure, in some implementations, the edge clustering engine 1140(x) generates a mesh orientation set 1148(x) based on region 1112(x). The mesh orientation set 1148(x) specifies, but is not limited to, one or more mesh orientations (not shown), where each mesh orientation is a different orientation characterizing the corresponding structural mesh. More precisely, the structural mesh corresponding to a given mesh orientation includes, but is not limited to, zero or more mesh lines having the mesh orientation and zero or more mesh lines perpendicular to the mesh orientation.

[0359] In some implementations, the arrangement of grid lines in the structural grid indicates the main structural components ( For example The potential locations of beams, columns, etc. It is worth noting that each grid orientation represents a pair of orthogonal directions, and each pair of orthogonal directions is represented by a single grid orientation. For example, a pair of orthogonal directions at 0 degrees and 90 degrees can be represented by a single grid orientation at 0 degrees or 90 degrees.

[0360] As shown in the figure, in some implementations, the edge clustering engine 1140 includes, but is not limited to, the grid orientation engine 1142. The grid orientation engine 1142 implements, but is not limited to, any number and / or type of unsupervised clustering operations and / or algorithms, and optionally any number and / or type of sorting operations and / or filtering operations, to determine one or more grid orientations based on the boundary edges of region 1112(x).

[0361] In some implementations, the clustering operations and algorithms implemented by the grid orientation engine 1142 are combined with those previously described in this paper. Figure 4 The clustering operation and algorithm implemented by the basic orientation engine 410 are similar. However, it is worth noting that while the basic orientation engine 410 determines any number of orientations, the grid orientation engine 1142 determines any number of grid orientations, each grid orientation representing a different pair of orthogonal orientations.

[0362] More specifically, in some implementations, in order to determine the grid orientation set 1148(x) of region 1112(x), the grid orientation engine 1142 determines a unique grid orientation represented by the boundary edges and any number and / or type of internal building features of the optional region 1112(x). For example (e.g., floor openings, partition walls, etc.). In the same or other implementations, each of the grid orientations is a different angle from 0 degrees to 180 degrees. The grid orientation engine 1142 weights each of the grid orientations based on the total length of the associated boundary edges and associated building features. Subsequently, the grid orientation engine 1142 bases the weights on the K value ( Right now Multiple instances of the K-means clustering algorithm are performed on weighted grid orientation using different combinations of the number of clusters to be generated and the seed to generate multiple grid orientation cluster sets. Each grid orientation cluster set specifies, but is not limited to, a different distribution of weighted grid orientation across any number of grid orientation clusters.

[0363] Then, the mesh orientation engine 1142 performs the elbow rule heuristic to determine the elbow point based on the mesh orientation clusters. The mesh orientation engine 1142 sorts the mesh orientation clusters based on the increasing distance to the elbow point to determine the highest-ranked mesh orientation cluster. Subsequently, the mesh orientation engine 1142 generates a mesh orientation set 1148(x), which includes, but is not limited to, one or more mesh orientations, wherein each mesh orientation specifies the centroid of a different mesh orientation cluster in the highest-ranked mesh orientation cluster set.

[0364] As shown in the figure, in some implementations, the mesh transformation engine 1150(x) generates a meshed region set 1160(x) based on region 1112(x), mesh orientation set 1148(x), region description 1120(x), and design description 130. The meshed region set 1160(x) includes, but is not limited to, one or more meshed regions (…). Figure 11 (Not shown in the image), where each meshed region is a version of region 1112(x) based on a different structured grid partition. More precisely, each meshed region included in the set of meshed regions 1160(x) is partitioned by a structured grid having one of the grid orientations included in the set of grid orientations 1148(x).

[0365] Combined with the following text Figure 12 More specifically, in some embodiments, the mesh transformation engine 1150(x) generates different structured meshes for any number of combinations of mesh orientations and any number and / or types of other mesh variables. In some embodiments, mesh variables include, but are not limited to, mesh orientation, mesh spacing, mesh aspect ratio, offset alignment, and feature snapping. The mesh transformation engine 1150(x) applies each of the structured meshes individually to region 1112(x) to generate a meshed region set 1160(x). Therefore, in some embodiments, the size of the meshed region set 1160(x) is larger than the size of the mesh orientation set 1148(x).

[0366] As shown in the figure, in some implementations, the zone design engine 1170(x) generates a sorted list of zone designs 1180(x) based on the gridded zone set 1160(x), zone description 1120(x), and design description 130. The sorted list of zone designs 1180(x) includes, but is not limited to, one or more zone designs (…). Figure 11 (not shown in the image) and the corresponding area target value ( Figure 11 (Not shown in the table). Each zone design is a different design of the structural system of zone 1112(x). The objective value of each zone is the objective function value of the corresponding zone design. The order of the zone designs in the sorted list of zone designs 1180(x) reflects the order based on the objective values ​​of the corresponding zones.

[0367] The zone design engine 1170(x) can generate a sorted list of zone designs 1180(x) in any technically feasible manner. In some implementations, and in conjunction with the following... Figure 13In more detail, the zone design engine 1170(x) generates different zone layouts for each gridded zone included in the gridded zone set 1160(x). The zone design engine 1170(x) generates each zone layout based on the different gridded zones, design concept 1122(x), domain knowledge 1124(x), and any amount and / or type of other relevant data. Each zone layout specifies, but is not limited to, the location, type, material, and optional initial sizing adjustments of any number and / or type of structural members.

[0368] In some implementations, the zone design engine 1170(x) derives one or more zone designs from each zone layout. In some implementations, each zone design specifies, but is not limited to, the location, type, material, and dimensional adjustments of structural members specified in the associated zone layout. The zone design engine 1170(x) can derive each zone design from the associated zone layout in any technically feasible manner.

[0369] Combined with the following text Figure 13 In more detail, in some embodiments, for each zone layout, the zone design engine 1170(x) generates a corresponding initial zone design that specifies the location, type, material, and initial dimensional adjustments of the structural members specified in the zone layout. In the same or other embodiments, for each initial zone design, the zone design engine 1170(x) performs any number and / or type of optimization operations on the dimensional adjustments of the structural members based on constraint 132 and objective function 134 to generate the corresponding zone design. In some embodiments, the zone design engine 1170(x) uses the objective function to calculate a zone objective value for each zone design. Subsequently, the zone design engine 1170(x) performs any number and / or type of sorting and / or filtering operations on the zone designs based on the zone objective value to generate a sorted list 1180(x) of zone designs.

[0370] As shown in the figure, in some embodiments, the zone combination engine 1190 generates a sorted list of floor designs 288 based on a sorted list of zone designs 1180(1)-1180(A). The sorted list of floor designs 288 includes, but is not limited to, any number of floor designs and optionally corresponding floor target values. Each floor design is a different design of a structural system that enables the floor to resist vertical loads. In some embodiments, each floor design specifies, but is not limited to, the location, type, material, and dimensional adjustments of each of any number of structural members included in the structural system of the floor. Each floor target value is an objective function value for the corresponding floor design. The sorting of the floor designs within the sorted list of floor designs 288 reflects a sorting based on the corresponding floor target values.

[0371] The zoning engine 1190 can generate floor designs and calculate floor target values ​​in any technically feasible manner. In some implementations, the zoning engine 1190 generates any number of zoning design combinations (not shown) based on a sorted list of zoning designs 1180(1)-1180(A). Each zoning design combination specifies one zoning design from each of the sorted lists of zoning designs 1180(1)-1180(A).

[0372] The zoning engine 1190 can determine zoning design combinations in any technically feasible manner. As shown in the figure, in some embodiments, the zoning engine 1190 includes, but is not limited to, a genetic algorithm 1192. In some embodiments, the zoning engine 1190 is configured with the genetic algorithm 1192 to iteratively optimize the selection of zoning design combinations from a sorted list of zoning designs 1180(1)-1180(A) based on floor target values ​​associated with previously selected zoning design combinations.

[0373] As shown in italics, in some implementations, the region combination engine 1190 defines indices in a sorted list of region designs 1180(1)-1180(A) as integer design variables for the genetic algorithm 1192. The region combination engine 1190 configures the genetic algorithm 1192 to set each integer design variable to an integer within the index range corresponding to the integer design variable in the region design list 1180. During each iteration, the region combination engine 1190 determines one or more sets of values ​​for the integer design variables and outputs the corresponding region design combination.

[0374] In some implementations, after the genetic algorithm 1192 outputs each zone design combination, the zone combination engine 1190 generates the corresponding floor design and calculates the corresponding floor target value. In the same or other implementations, the zone combination engine 1190 will check for violations of any number and / or type of constraints ( For example Zero or more penalties associated with (e.g., minimum grid spacing, service area height, etc.) are added to the floor target value to generate a modified floor target value. Then, the zone combination engine 1190 inputs the floor target value or the modified floor target value into a genetic algorithm, enabling the genetic algorithm to iteratively optimize the selection of zone design combinations. In some implementations, after determining that any type of termination criterion (e.g., minimum grid spacing, service area height, etc.) has been met... For example When the total number of iterations reaches 100, the combination engine 1190 causes the genetic algorithm 1192 to stop iterating.

[0375] For each zone design combination, the zone combination engine 1190 aggregates the specified zone designs and optionally performs any number and / or type of additional design and / or optimization operations to generate the corresponding floor design. Some examples of additional design operations include, but are not limited to, adjusting one or more structural members to conform to any number and / or type of constraints 132. For example(Constraints related to building codes).

[0376] The zone combination engine 1190 can calculate floor target values ​​in any technically feasible manner. In some embodiments, the zone combination engine 1190 uses an objective function 134 to calculate the floor target values ​​for each floor design. In other embodiments, the zone combination engine 1190 calculates the floor target values ​​for each floor design based on the zone target values ​​of the constituent zone designs.

[0377] Subsequently, the zone combination engine 1190 performs any number and / or type of sorting and / or filtering operations on the floor designs based on the floor target values ​​to generate a sorted list 288 of floor designs. For example, in some embodiments, the zone combination engine 1190 sets the variable R to the minimum of the number of floor designs and the maximum change count (denoted as N) specified in the parameter data 138. The zone combination engine 1190 then generates the sorted list 288 of floor designs, which includes, but is not limited to, the top R floor target values ​​and their corresponding floor designs, sorted in descending order of convergence between the floor target values ​​and the design objectives.

[0378] In some embodiments, the grid-based design application 1100 and / or the structural design application 120 transfer any portion of the sorted floor design list 288 to any number of other software applications in any technically feasible manner. In the same or other embodiments, the grid-based design application 1100 stores any portion of the sorted floor design list 288 in memory accessible by at least one other software application. In some embodiments, the grid-based design application 1100 stores any portion of the sorted floor design list 288 in memory accessible by the structural design application 120.

[0379] Advantageously, incorporating any and all of the functionalities described herein in the context of the grid-based design application 1100 into the CAD application increases the likelihood that the CAD application can generate structural systems for floors that meet design objectives. Compared to conventional CAD applications, the grid-based design application 1100 can explore the design space of the structural system more efficiently and systematically because it automatically decomposes the overall design problem into multiple component optimization problems. In this regard, in some implementations, the grid-based design application 1100 addresses component optimization problems to explore and optimize design choices associated with the structural grid, spanning direction, dimensional adjustments of structural members, and design combinations for different zones.

[0380] 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.

[0381] Figure 12 It is based on various implementation plans. Figure 11 A more detailed illustration of the mesh transformation engine 1150. In some implementations, including... Figure 12 The implementation scheme depicted herein includes, but is not limited to, zones 1112(1) and 1112(2). In the same or other implementation schemes, including... Figure 2 The implementation scheme described herein includes a grid variation engine 1150 in a grid-based design application 1100, the number of which is equal to the number of zones 1112 included in the floor outline 1110 of the partition.

[0382] As shown in the figure, in some embodiments, the mesh transformation engine 1150(1) generates a meshed region set 1160(1) based on region 1112(1), mesh orientation set 1148(1), region description 1120(1), and design description 130. In the same or other embodiments, the mesh transformation engine 1150(2) generates a meshed region set 1160(2) based on region 1112(2), mesh orientation set 1148(2), region description 1120(2), and design description 130. Mesh transformation engines 1150(1) and 1150(2) can generate meshed region sets 1160(1) and 1160(2) respectively in any technically feasible manner. For illustrative purposes only, Figure 12 In the context of , the integer variable x represents 1 or 2.

[0383] As shown in mesh transformation engine 1150(2), in some embodiments, each mesh transformation engine 1150(x) includes, but is not limited to, mesh variable combination engine 1240 and meshing engine 1250. Mesh variable combination engine 1240 includes, but is not limited to, mesh variable set 1242 that specifies any number and / or type of mesh variables. Each mesh variable is associated with one or more properties of the structured mesh. As shown in italics, in some embodiments, mesh variable set 1242 specifies, but is not limited to, mesh orientation, mesh spacing, mesh aspect ratio, offset alignment, and feature snapping. For illustrative purposes only, the value of mesh spacing is also referred to herein separately as “mesh spacing” and collectively as “mesh spacing”.

[0384] As used herein, "offset" is a gap that occurs when the structural mesh is not precisely aligned with the architectural features of zone 1112(x). In some embodiments, offset alignment indicates the alignment and / or distribution of offsets within zone 1112(x). In the same or other embodiments, valid values ​​for offset alignment include, but are not limited to, top / left, bottom / right, and even distribution.

[0385] In some implementations, feature snapping is a Boolean value associated with a “snap distance.” When feature snapping is true, if grid lines are within the snap distance of a building feature, the meshing engine 1250, included in the mesh variation engine 1150(x), automatically snaps grid lines to the building feature and adjusts any other grid lines so that, overall, the grid lines conform to the mesh constraint set 1126(x). In some implementations, snapping grid lines to a building feature can result in an actual grid spacing different from the grid spacing included in the grid variable set 1242. In the same or other implementations, the type of grid spacing variation that the meshing engine 1250 can apply when snapping grid lines to a building feature can vary based on design concept 1122. For example, in some implementations, for floors using timber, steel joists, or precast joists, when snapping grid lines to a building feature, it is permissible to decrease rather than increase the grid spacing included in the grid variable set 1242. In the same or other implementations, for cast-in-place concrete floors, when snapping grid lines to a building feature, it is permissible to decrease and increase the grid spacing included in the grid variable set 1242.

[0386] In some implementations, the mesh variable combination engine 1240 generates one or more sets of values ​​for the mesh variable set 1242 that are feasible for the design concept 1122(x). Each set of values ​​for the mesh variable set 1242 that is feasible for the design concept 1122(x) is also referred to herein as a “mesh variable combination”. The mesh variable combination engine 1240 can generate any number of mesh variable combinations in any technically feasible manner.

[0387] In some implementations, to generate mesh variable combinations, the mesh variable combination engine 1240 selects different combinations of effective mesh orientations, feasible mesh spacing / mesh aspect ratio pairs, effective offset alignment, and effective feature capture. The mesh orientations included in the mesh orientation set 1148(x) are effective mesh orientations. The mesh variable combination engine 1240 can determine feasible mesh spacing / mesh aspect ratio pairs in any technically feasible manner. For example, in some implementations, the mesh variable combination engine 1240 determines feasible mesh spacing / mesh aspect ratio pairs based on the mesh constraint set 1126, domain knowledge 1124(x), design specification 130, or any combination thereof. In the same or other implementations, effective offset alignment and effective feature capture are predefined.

[0388] The mesh variable combination engine 1240 can select any number of combinations of effective mesh orientation, feasible mesh spacing / mesh aspect ratio pairs, effective offset alignment, and effective feature capture in any technically feasible manner. As shown in italics, in some embodiments, the mesh variable combination engine 1240 exhaustively selects all possible combinations of effective mesh orientation, feasible mesh spacing / mesh aspect ratio pairs, effective offset alignment, and effective feature capture. In some other embodiments, the mesh variable combination engine 1240 can 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, any number and / or type of other optimization algorithms and / or optimization operations, or any combination thereof, to generate any number of mesh variable combinations.

[0389] As shown in the figure, in some embodiments, the meshing engine 1250 generates a meshed region set 1160(x) based on region 1112(x) and combinations of mesh variables associated with region 1112(x). In some embodiments, the meshing engine 1250 generates a different structured mesh (not shown) for each of the combinations of mesh variables. For each combination of mesh variables, the meshing engine 1250 can generate a corresponding structured mesh based on region 1112(x) in any technically feasible manner.

[0390] In some implementations, for each combination of mesh variables, the meshing engine 1250 generates a corresponding structural mesh based on the boundary of zone 1112(x) and the values ​​of mesh orientation, mesh spacing, mesh aspect ratio, and offset alignment specified in the combination of mesh variables. In the same or other implementations, if the feature snap value specified in the combination of mesh variables is true, the meshing engine 1250 determines whether any mesh line in the structural mesh is within the snap distance of the building feature represented by zone 1112(x). If any mesh line is within the snap distance of any building feature represented by zone 1112(x), the meshing engine 1250 automatically snaps the approximate mesh line to the building feature and adjusts any other mesh lines included in the structural mesh so that the structural mesh conforms to the mesh constraint set 1126(x). For example (Maximum spacing). The meshing engine 1250 can perform any number and / or type of alignment operations, spacing operations, any other type of operations, or any combination thereof on the mesh lines included in the structured mesh to ensure that the structured mesh conforms to the mesh constraint set 1126(x).

[0391] The meshing engine 1250 then applies each structured mesh to region 1112(x) to generate a set of meshed regions 1160(x). Therefore, in some embodiments, the set of meshed regions 1160(x) includes, but is not limited to, a plurality of meshed regions 1260, which is equal to the number of combinations of mesh variables associated with region 1112(x). The meshing engine 1250 can apply a given structured mesh to region 1112(x) in any technically feasible manner. For example, in some embodiments, the meshing engine 1250 merges region 1112(x) and the structured mesh to generate a meshed region 1260(x) that specifies each shape included in region 1112(x) and each mesh line included in the structured mesh. In the same or other embodiments, the meshing engine 1250 partitions region 1112(x) based on the grid lines included in the structured grid to generate meshed region 1260(x), said meshed region including but not limited to any number of mesh modules (not shown), wherein each of the mesh modules represents a different non-overlapping portion of region 1112(x).

[0392] For illustrative purposes only, Figure 12 Examples of the floor outlines of the zones 1110, 1112(1), 1112(2), grid orientation sets 1148(1), 1148(2), gridded zone sets 1160(1) and 1160(2) are depicted. Figure 12 In the example depicted, the floor outline 1110 of the partition includes, but is not limited to, partitions 1112(1) and 1112(2). Partition 1112(1) has holes 1210 and each boundary edge of partition 1112(1) has an orientation of 0 degrees or 90 degrees. Because 0 degrees and 90 degrees are orthogonal, the boundary edges of partition 1112(1) can be represented by the same grid orientation. More specifically, in Figure 12 In the example depicted, the grid orientation set 1148(1) includes, but is not limited to, a grid orientation of 90 degrees.

[0393] exist Figure 12 In the example depicted, the mesh transformation engine 1150(1) generates a mesh set 1160(1), which includes, but is not limited to, mesh regions 1260(1)-1260(E), where E can be any integer greater than or equal to 2. Since the only valid value for mesh orientation is 90 degrees, and 90 degrees corresponds to the vertical direction, each of the mesh regions 1260(1)-1260(E) is partitioned by zero or more vertical mesh lines and zero or more horizontal mesh lines. As depicted, the values ​​for mesh spacing, mesh aspect ratio, offset alignment, and feature snapping can vary across the mesh regions 1260(1)-1260(E).

[0394] As previously described herein, in some embodiments, each of the meshed regions 1260(1)-1260(E) represents region 1112(1) as a distinct set of mesh modules. As referred to herein, a “mesh module” of meshed region 1260 is a discrete portion of meshed region 1260, defined by the mesh lines included in meshed region 1260 and the boundary edges of meshed region 1260. Any number of mesh modules can be partially cut ( For example (Through the boundary edges of area 1112(1), hole 1210, etc.). Figure 12 In the example depicted, meshed region 1260(1) includes, but is not limited to, 43 mesh modules. In contrast, meshed region 1260(2) includes, but is not limited to, 6 mesh modules. As shown in meshed regions 1260(1) and 1260(2), the size and shape of the mesh modules can vary both within and on meshed region 1260.

[0395] exist Figure 12 In the example depicted, each boundary edge of zone 1112(2) has an orientation of 0 degrees, 90 degrees, or 9 degrees. Because 0 degrees and 90 degrees are orthogonal, 0-degree and 90-degree boundary edges can be represented by the same grid orientation. 9-degree boundary edges can be represented by different grid orientations. Figure 12 In the example depicted, the grid orientation set 1148(2) includes, but is not limited to, a 90-degree grid orientation and a 9-degree grid orientation.

[0396] exist Figure 12 In the example depicted, the mesh transformation engine 1150(2) generates a set of meshed regions 1160(2), which includes, but is not limited to, meshed regions 1260(E+1)-1260(F) and meshed regions 1260(F+1)-1260(G), where F can be any integer greater than or equal to (E+2) and G can be any integer greater than or equal to (F+2). For illustrative purposes, each of the meshed regions 1260(E+1)-1260(F) corresponds to a 9-degree mesh orientation and is therefore partitioned by zero or more mesh lines with a 9-degree orientation and zero or more mesh lines with a 99-degree orientation. As depicted, the values ​​of mesh spacing, mesh aspect ratio, offset alignment, and feature snapping can vary across the meshed regions 1260(E+1)-1260(F). For illustrative purposes, each of the meshing zones 1260(F+1)–1260(G) corresponds to a 90-degree mesh orientation and is therefore partitioned by zero or more vertical mesh lines and zero or more horizontal mesh lines. As depicted, the values ​​for mesh spacing, mesh aspect ratio, offset alignment, and feature snapping can vary across the meshing zones 1260(F+1)–1260(G).

[0397] Each of the meshed regions 1260(E+1)-1260(G) represents region 1112(2) as a distinct set of mesh modules. Figure 12 In the examples depicted, meshed region 1260 (E+1) includes, but is not limited to, 22 mesh modules. Meshed region 1260 (F) includes, but is not limited to, 3 mesh modules. Meshed region 1260 (F+1) includes, but is not limited to, 28 mesh modules. Meshed region 1260 (G) includes, but is not limited to, 3 mesh modules.

[0398] Various embodiments have been described for illustrative purposes, but these descriptions are not intended to be exhaustive or limited to the disclosed embodiments. In particular, as previously mentioned herein... Figure 11 In some embodiments, the partitioned floor outline 1110 may include any number of zones 1112, the grid-based floor application 1100 may include any number of grid transformation engines 1150, and the number of zones 1112 may be the same as or different from the number of grid transformation engines 1150. Furthermore, in some embodiments, the grid variable set 1242 may include any number and / or type of variables related to generating the structural grid.

[0399] As mentioned above, this is for illustrative purposes only. Figure 12 An example depicting a partitioned floor outline 1110, along with associated examples of zones 1112, grid orientation sets 1148, gridded zone sets 1160, and gridded zones 1260. In some other embodiments, the partitioned floor outline 1110 can be associated with any number of zones 1112, any number of grid orientation sets 1148, and any number of gridded zone sets 1160. Furthermore, each grid orientation set 1148 can include any number of grid orientations, and each gridded zone set 1160 can include any number of gridded zones 1260.

[0400] Figure 13 It is based on various implementation plans. Figure 11 A more detailed illustration of one of the design engines in Zone Design 1170. More precisely, Figure 13 A zone design engine 1170(1) is described, which generates a sorted list of zone designs 1180(1) based on a gridded zone set 1160(1), a design specification 130, and a zone specification 1120(1).

[0401] As mentioned earlier in this article Figure 12In some embodiments, the gridded region set 1160(1) includes, but is not limited to, gridded regions 1260(1)-1260(E), where E can be any positive integer. In the same or other embodiments, gridded regions 1260(1)-1260(E) are versions of regions 1112(1) partitioned based on different structured grids. In some embodiments, the grid orientation can vary on the structured grid.

[0402] As shown in the figure, in some embodiments, the area design engine 1170(1) includes, but is not limited to, area layout engines 1310(1)-1310(E), area layout 1320(1)-1320(E), size adjustment engine 1330(1)-1330(E), area design 1338(1)-1338(E), area target value 1336(1)-1336(E), sorting / filtering engine 1340, and arbitration direction 1302. In some other embodiments, the arbitration direction 1302 can be omitted from the area design engine 1170(1).

[0403] In some implementations, the zone layout engines 1310(1)-1310(E) generate zone layouts 1320(1)-1320(E) based on gridded zones 1260(1)-1260(E), design command 130, zone command 1120(1), and arbitration direction 1302, respectively. In the same or other implementations, the sizing engines 1330(1)-1330(E) generate zone designs 1338(1)-1338(E) and zone target values ​​1336(1)-1336(E) based on zone layouts 1320(1)-1320(E), design command 130, and zone command 1120(1), respectively.

[0404] The area layout engine 1310(1)-1310(E) are different instances of a single software application referred to herein as “area layout engine 1310”, and are also referred to herein as “area layout engine 1310” individually and collectively. The size adjustment engine 1330(1)-1330(E) are different instances of a single software application referred to herein as “size adjustment engine 1330”, and are also referred to herein as “size adjustment engine 1330” individually and collectively.

[0405] In some implementations, the number of instances of the zone layout engine 1310 and / or the sizing engine 1330 may differ from the number of gridded zones 1260 included in the gridded zone set 1160(1), and the techniques described herein are modified accordingly. Instances of the zone layout engine 1310 may be executed sequentially, simultaneously, or in any combination thereof. Instances of the sizing engine 1330 may be executed sequentially, simultaneously, or in any combination thereof.

[0406] As described in more detail below, in some embodiments, the arbitration direction 1302 specifies one or more crossing direction preferences in any technically feasible manner. For example, in some embodiments, the arbitration direction 1302 specifies 90 degrees and is associated with a “crossing direction” rule that determines the crossing direction of a plate relative to a structural element that may provide auxiliary support. For illustrative purposes, as used herein, a “structural element” describes a component that can potentially be used in a structural system. In contrast, a “structural member” is a specific component included in a structural system. An example of a crossing direction rule is if plates have an arbitration range relative to each other ( For example If the two span lengths are within 10%, then the span direction closest to (in terms of angle) the arbitration direction 1302 will be selected as the span direction of the plate relative to the support beam.

[0407] Now return to the reference Figure 11 In some implementations, the zone design engines 1170(1)-1170(A) implement the same preference for arbitration direction 1302. Therefore, arbitration direction 1302 can increase the consistency of cross-floor design across directions, and thus increase the consistency of each floor design included in the sorted floor design list 288.

[0408] For illustrative purposes only, Figure 13 In the context of this, variable x represents any integer from 1 to E (inclusive). In some embodiments, any instance of the zone layout engine 1310 can generate zone layout 1320(x) in any technically feasible manner based on gridded zone 1260(x) and any amount (including the absence of any amount) and / or type of additional data. In the same or other embodiments, any instance of the sizing engine 1330 can generate zone design 1338(x) and optional zone target value 1336(x) in any technically feasible manner based on zone layout 1320(x) and any number (including the absence of any amount) and / or type of additional data.

[0409] As shown for zone layout engine 1310(1), in some embodiments, zone layout engine 1310(x) generates zone layout 1320(x) based on any part of meshed zone 1260(x), arbitration direction 1302, design instruction 130 (including any non-existent part), and zone instruction 1120(x) (including any non-existent part). Zone layout 1320(x) specifies the layout of the structural system of zone 1112(1). In some embodiments, zone layout 1320(x) specifies, but is not limited to, the location, type, material, and optional initial sizing adjustments of any number of structural members.

[0410] In some implementations, the zone layout engine 1310(x) determines that each grid module included in the gridded zone 1260(x) represents a different plate in the structural system specified by the zone layout 1320(x). For illustrative purposes only, Figures 11 to 17 In this context, the term "plate" can refer to, but is not limited to, a single plate, a plate panel, or a portion of a plate, wherein said portion is located between two main structural members ( For example Between the two beams. It is worth noting that each mesh module is defined by one to four (inclusive) mesh lines and zero or more boundary edges of the meshed area 1260(x).

[0411] Therefore, regardless of the shape of a given mesh module, the shape of the plate represented by the mesh module can be represented using the polygonal quadrilateral data structure described earlier herein. In some embodiments, the zone layout engine 1310(x) uses the polygonal quadrilateral data structure to represent the location of structural members of arbitrary shapes in the zone layout 1320(x). In some other embodiments, the zone layout engine 1310(x) can represent the location of structural members in the zone layout 1320(x) in any technically feasible manner.

[0412] The zone layout engine 1310(x) can determine the material and type of each plate in any technically feasible manner. For example, in some embodiments, the zone layout engine 1310(x) determines the material of each plate based on design concept 1122(x). In the same or other embodiments, to determine the type of each plate, the zone layout engine 1310(x) calculates the span length of the plate relative to the grid lines. As previously described herein, each grid line included in the gridded zone 1260(x) has one of two orthogonal directions. For a given plate, if the plate has only one boundary-defining grid line or all boundary-defining grid lines share the same direction, the zone layout engine 1310(x) calculates a span length in the span direction orthogonal to the boundary-defining grid line. Otherwise, the zone layout engine 1310(x) calculates two span lengths in two span directions orthogonal to the two directions of the boundary-defining grid line.

[0413] In some implementations, the zone layout engine 1310(x) determines the type of each board based on the span length associated with the board, any amount of zone instructions 1120(x) (including the absence of any amount), and any amount of design instructions 130 (including the absence of any amount). For example, in some implementations, the zone instructions 1120(x) and / or design instructions 130 include, but are not limited to, one or more knowledge-based rules that can be used to determine the board span type for the board associated with design concept 1122(x). For example(e.g., one-way span, two-way span, cantilever, etc.). In some such implementations, the zone layout engine 1310(x) uses relevant knowledge-based rules to determine the slab span type for each slab based on the associated span length.

[0414] In some implementations, if the zone layout engine 1310(x) calculates two span lengths for a given unidirectional spanning board, the zone layout engine 1310(x) selects one of the corresponding span directions as the span direction of the board, at least in part, based on the span length. More specifically, the zone layout engine 1310(x) analyzes the span length in conjunction with any quantity (including the absence of any quantity) of zone instructions 1120(x), any quantity (including the absence of any quantity) of design instructions 130, arbitration direction 1302, or any combination thereof to determine the span direction of the board.

[0415] In some implementations, if the crossing direction rule associated with arbitration direction 1302 does not apply to a given one-way crossing slab, the zone layout engine 1310(x) determines the crossing direction of the slab based on the default crossing direction rule for the corresponding type of slab. For example, in some implementations, the default crossing direction rule is to set the crossing direction of a one-way crossing slab without a joist to be the same as the direction corresponding to the shorter crossing length associated with the slab. In the same or other implementations, the default crossing direction rule is to set the crossing direction of a one-way crossing slab supported on a joist to be the same as the direction corresponding to the longer crossing length associated with the slab, thereby causing the joist to cross in the direction corresponding to the shorter crossing length.

[0416] Zone layout engine 1310(x) can determine the location, type, and material of any number of other structural members in any technically feasible manner. For example, in some embodiments, zone layout engine 1310(x) determines the location of beams and columns based on grid lines and constraints of any quantity and / or type specified in zone instructions 1120(x) and / or design instructions 130. In the same or other embodiments, if design concept 1122(x) indicates that the structural system of zone 1112(x) will include joists, zone layout engine 1310(x) determines the location of joists based on their spanning direction and associated spanning length relative to the joists. After determining the location, type, and material of any number of structural members based on gridded zone 1260(x), zone layout engine 1310(x) generates zone layout 1320(x).

[0417] In some embodiments, the sizing engine 1330(x) generates a zone design 1338(x) and an optional zone target value 1336(x) based on zone layout 1320(x), any part of design instruction 130 (including any absent part), and any part of zone instruction 1120(x) (including any absent part). Zone design 1338(x) specifies a structural system that enables zone 1112(x) to resist vertical loads. In some embodiments, zone design 1338(x) specifies, but is not limited to, the location, type, material, and sizing adjustments of structural members specified in zone layout 1320(x). In the same or other embodiments, zone target value 1336(x) quantifies the convergence of zone design 1338(x) to the design objective.

[0418] The sizing engine 1330(x) can generate a zone design 1338(x) and optionally calculate zone target values ​​1336(x) in any technically feasible manner. In some embodiments, the sizing engine 1330(x) generates an initial zone design (not shown) that specifies, but is not limited to, the location, type, material, and initial sizing adjustments of structural members specified in the zone layout 1320(x). The sizing engine 1330(x) can determine the initial sizing adjustments of structural members in any technically feasible manner. For example, in some embodiments, the sizing engine 1330(x) determines the initial sizing adjustments based on default values ​​of any number and / or type.

[0419] In some embodiments, the sizing engine 1330(x) performs any number and / or type of optimization operations on the initial sizing of structural members based on constraint 132 and objective function 134, without considering lateral loads, to generate zone design 1338(x) and zone target value 1336(x). The zone design engine 1170(x) can optimize the sizing of structural members specified in the initial zone design in any technically feasible manner to generate zone design 1338(x). In some embodiments, the sizing engine 1330(x) can implement any number of optimization techniques that are the same as or similar to the optimization techniques implemented by gravity design optimizer 260 in various embodiments. Gravity design optimizer 260 is mentioned earlier in this document. Figure 3 It was described in detail.

[0420] As depicted in italics, in some embodiments, the sizing engine 1330(x) optimizes the sizing of plates, beams, and columns included in the initial zone design, based on constraint 132 and objective function 134, while simultaneously considering vertical loads, to generate zone design 1338(x). In some embodiments, the sizing engine 1330(x) uses objective function 134 to calculate the zone target value 1336(x) of zone design 1338(x). In the same or other embodiments, the sizing engine 1330(x) uses objective function 134 to calculate the target value of any number of partially optimized versions of the initial zone design, while optimizing the sizing of structural members.

[0421] As shown in the figure, in some implementations, the sorting / filtering engine 1340 generates a sorted list of zone designs 1180(1) based on zone designs 1338(1)-1338(E) and zone target values ​​1336(1)-1336(E). As described earlier herein, each of the zone designs 1338(1)-1338(E) is a different design for enabling zone 1112(1) to resist vertical loads in a structural system. In some implementations, the zone target values ​​1336(1)-1336(E) quantify the convergence of the zone designs 1338(1)-1338(E) with respect to the design target.

[0422] The sorting / filtering engine 1340 can perform any number and / or type of sorting operations, any number and / or type of filtering operations, any number and / or type of other operations, or any combination thereof, on the zone designs 1338(1)-1338(E) based on the zone target values ​​1336(1)-1336(E) to generate a sorted list of zone designs 1180(1). For example, in some embodiments, the sorting / filtering engine 1340 sets the variable R to the minimum of the number of zone designs 1338 and the maximum change count (denoted as N) specified in the parameter data 138. The sorting / filtering engine 1340 sorts and optionally filters the zone designs 1338(1)-1338(E) based on the zone target values ​​1336(1)-1336(E). Then, the sorting / filtering engine 1340 generates a sorted list of district designs 1180 (1) according to the district target value 1336 and the corresponding R of the district target value 1336 in descending order of convergence with the design criteria. The sorted list of district designs includes, but is not limited to, the R best district designs 1338.

[0423] Figure 14 This is a flowchart illustrating the steps of a method for designing a structural system for generating floors of arbitrary shapes within a building, based on various implementation schemes. (Although references are available...) Figures 1 to 6 as well as Figures 11 to 13The 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.

[0424] As shown in the figure, method 1400 begins at step 1402, where the grid-based design application 1100 selects zones 1112 (1) included in the floor outline 1110 of the partition. In step 1404, the edge clustering engine 1140 clusters the zones based on the direction of the boundary edges and, optionally, the internal architectural features of the selected zones. For example Perform any number and / or type of clustering operations (such as floor openings, partitions, etc.) to determine one or more grid orientations.

[0425] In step 1406, the mesh transformation engine 1150 generates one or more structured meshes based on the selected area and one or more combinations of mesh orientation, mesh spacing, and zero or more other mesh variables. In step 1408, the mesh transformation engine applies one or more structured meshes to the selected area to generate one or more meshed areas 1260. In step 1410, the area layout engine 1310 determines the spanning direction of the plate represented by the meshed area 1260 based on any amount and / or type of domain knowledge and optionally an arbitration direction 1302. In step 1412, for each meshed area 1260, the area layout engine 1310 generates an area layout 1320 for the meshed area 1260 based on the associated spanning direction and any amount and / or type of domain knowledge.

[0426] In step 1414, the sizing engine 1330 determines an optimized sizing adjustment for the zone layout 1320 based on constraint 132 and objective function 134 to generate zone designs 1338 and zone target values ​​1336. In step 1416, the sorting / filtering engine 1340 sorts the zone designs 1338 based on the zone target values ​​1336 and optionally filters them to generate a sorted list 1180 of zone designs for the selected zones. In step 1418, the edge clustering engine 1140 performs any number and / or type of clustering operations based on the direction of the boundary edges of the selected zones to determine one or more grid orientations.

[0427] In step 1418, the grid-based design application 1100 determines whether the selected area is the last area in area 1112. If, in step 1418, the grid-based design application 1100 determines that the selected area is not the last area in area 1112, then method 1400 proceeds to step 1420. In step 1420, the grid-based design application 1100 selects the next area 1112, and method 1400 returns to step 1404, where the edge clustering engine 1140 determines one or more grid orientations for the selected area.

[0428] However, if in step 1418, the grid-based design application 1100 determines that the selected zone is the last zone in zone 1112, then method 1400 proceeds directly to step 1422. In step 1422, the zone combination engine 1190 generates combinations of zone designs 1338 to generate a sorted list of floor designs 288.

[0429] In step 1424, the grid-based design application 1100 stores and / or transfers any portion of the sorted floor plan design list 288 to any number of software applications for use in other design activities. Method 1400 then terminates.

[0430] For illustrative purposes only, the steps of method 1400 are depicted and described as occurring sequentially. However, as those skilled in the art will recognize, steps 1404 to 1420 may be performed sequentially, simultaneously, or in any combination thereof for each region 1112.

[0431] Design floor structure based on room floor plan

[0432] Now return to the reference Figure 1 In some implementations, gravity design application 140 and / or grid-based design application 1100 are used instead of or in addition to them. Figure 1 The structural design application 120 may include, but is not limited to, a room-based design application 1500. In some other embodiments, the room-based design application 1500 may be incorporated into any type of software application. For example In other implementations, the room-based design application 1500 can be executed as a standalone software application.

[0433] As follows Figures 15 to 17 In more detail, in some implementations, the room-based design application 1500 automatically generates, but is not limited to, any number of CAD designs for the floor structure, taking into account any number of walls. The CAD design of the floor structure is also referred to herein as “floor structure design” and “floor structural system design.” As previously mentioned herein… Figure 2 As described above, the floor structure is part of the structural system corresponding to the floors of a building. Importantly, each floor structure design can designate zero or more walls of a specified room as load-bearing walls.

[0434] Figure 15 It is based on various implementation plans. Figure 1 A diagram of the 1500 room-based design application. Return to reference. Figure 1In some implementations, the room-based design application 1500 may reside in the memory 116 of computing instance 110 and execute on the processor 112 of computing instance 110. As shown, in some implementations, the room-based design application 1500 generates a sorted design list 1594 based on building outline 126, design instructions 130, room floor plan 1502, and floor instructions 1510.

[0435] As mentioned earlier in this article Figure 1 The building outline 126 is the outline of any type of building with any number of floors. In some embodiments, the building is a single-story residential building. In some other embodiments, the building can be any type of residential building. In other embodiments, the building can be any type of office building. Design instructions 130 include, but are not limited to, constraints 132 associated with the building, objective function 134, design variable data 136, and parameter data 138.

[0436] Room plan 1502 specifies, but is not limited to, any number of walls that define, but are not limited to, any number of rooms included in the building floors corresponding to building outline 126. As shown, in some embodiments, floor instructions 1510 include, but are not limited to, design concept 1122, domain knowledge 1124, and maximum joist length 1512. In the same or other embodiments, any number and / or type of floor instructions 1510 may override any number and / or type of design instructions 130.

[0437] As mentioned earlier in this article Figure 11 Design concept 1122 specifies, but is not limited to, any amount and / or type of data that defines the characteristics of the structural system to be designed for use in building floors. An example of design concept 1122 is a oriented strand board (OSB) floor structure with rectangular glued laminated timber or softwood sections. Domain knowledge 1124 may include, but is not limited to, any amount and / or type of knowledge relevant to the design and analysis of floor structures (e.g., examining the vibration of wood flooring).

[0438] The maximum joist length 1512 specifies the maximum joist length that can be used in the floor structure. In some embodiments, the maximum joist length 1512 reflects design concept 1122 and / or domain knowledge 1124. As described in more detail below, in some embodiments, the maximum joist length 1512 is the dominant design criterion for subdividing and merging discrete portions of floor areas 1530. In some other embodiments, any number and / or type of design criterion, in addition to or besides the maximum joist length 1512, may be used as the dominant design criterion.

[0439] In some implementations, the sorted design list 1594 includes, but is not limited to, subsets of floor structure designs 1598(1)-1598(L), corresponding subsets of floor target values ​​1596(1)-1596(L), and corresponding subsets of unstructured wall datasets 1586(1)-1586(L), where L can be any positive integer. For illustrative purposes only, floor structure designs 1598(1)-1598(L) are also referred to separately as “floor structure designs 1598” and collectively as “floor structure designs 1598”. Floor target values ​​1596(1)-1596(L) are also referred to separately as “floor target values ​​1596” and collectively as “floor target values ​​1596”. Unstructured wall datasets 1586(1)-1586(L) are also referred to separately as “unstructured wall datasets 1586” and collectively as “unstructured wall datasets 1596”.

[0440] The structural design of each floor 1598 is to enable the floors associated with room plan 1502 to resist vertical loads. For example Different designs for floor structures (gravity). In some embodiments, each floor structure design 1598 specifies, but is not limited to, adjustments to the location, type, material, and size of any number and / or type of structural members included in the floor structure. In the same or other embodiments, structural members include, but are 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, 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 immediately adjacent lower floor (if one exists) or the foundation.

[0441] In some embodiments, horizontal structural members include, but are not limited to, slabs, beams, and joists. In the same or other embodiments, vertical structural members include, but are not limited to, columns and load-bearing walls. It is worth noting that each of the floor structure designs 1598(1)-1598(L) may incorporate zero or more walls as load-bearing walls as defined in room plan 1502.

[0442] In some embodiments, building outline 126 may represent a building of any shape, room plan 1502 may represent a floor of any shape, and room plan 1502 may specify any number of rooms of any shape having zero or more openings or holes or any combination thereof. In the same or other embodiments, room-based design application 1500 may generate floor structure designs 1598(1)-1598(L) in any technically feasible manner, the floor structure designs having any number and / or type of arbitrary shapes and / or based on any number and / or type of arbitrary shapes. In some embodiments, room-based design application 1500 generates and represents floor structure designs 1598(1)-1598(L) using the polygonal quadrilateral data structure described herein in conjunction with mesh-based design application 1100.

[0443] The floor target values ​​1596(1)-1596(L) are the values ​​of the objective function 134 for the floor structural designs 1598(1)-1598(L). In some implementations, the floor target values ​​1596(1)-1596(L) are related to the convergence between the floor structural designs 1598(1)-1598(L) and the design objective. In some implementations, the room-based design application 1500 sorts and optionally filters the floor structural designs 1598, the floor target values ​​1596, and the unstructured wall dataset 1586 based on the target value 1596 to generate a sorted design list 1594.

[0444] Non-structural wall datasets 1586(1)-1586(L) specify, but are not limited to, any walls specified in room plan 1502 but not in floor structural design 1598(1)-1598(L). Therefore, non-structural wall datasets 1586(1)-1586(L) specify, but are not limited to, the non-load-bearing walls of floor structural design 1598(1)-1598(L). Non-structural wall dataset 1586 may specify any quantity (including any quantity that is not present) and / or additional data of any type associated with non-load-bearing walls. For example, in some embodiments, non-structural wall dataset 1586 may specify the location, material, subtype, or any combination thereof of non-load-bearing walls.

[0445] In some implementations, the room-based design application 1500 generates floor structure designs 1598 and optionally generates floor target values ​​1596, a dataset of unstructured walls 1586, a sorted design list 1594, or any combination thereof. In the same or other implementations, the room-based design application 1500 may sort and / or filter the floor structure designs 1598(1)-1598(L) based on any number and / or type of criteria in any technically feasible manner.

[0446] 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.

[0447] For illustrative purposes only, combined Figures 15 to 17 The functionality of the room-based design application 1500 is described in the context of generating any number of floor structure designs 1598, which include, but are not limited to, load-bearing walls and joists at least in part based on a maximum joist length 1512. Floor structures including load-bearing walls and joists, such as wood flooring structures, are commonly used in residential buildings.

[0448] As those skilled in the art will recognize, in some other embodiments, the techniques described herein can be modified to generate any type of floor structure design 1598 supported on the joists, using no other type of structural member and excluding any other type of structural member. In the same or other embodiments, the techniques described herein can be modified to generate the floor structure design 1598 based on any type of "dominant design criterion" that replaces or excludes the maximum joist length 1512.

[0449] As shown in the figure, in some implementations, the room-based design application 1500 includes, but is not limited to, a floor area engine 1520, a span analysis engine 1540, a subdivision engine 1550, a block combination engine 1560, a merging engine 1570, a span combination engine 1580, a structural dimension adjustment engine 1590(1)-1590(L) and a specification engine 1592.

[0450] In some implementations, the room-based design application 1500 decomposes the overall design optimization problem of optimizing the floor structure into simpler optimization problems, the floor structure being able to incorporate any number of walls defined by the room floor plan 1502. As described in more detail below, in some implementations, the simpler optimization problems involve subdividing uncrossable portions of the floor structure, combining different subdivision options, merging crossable portions of the floor structure into larger crossable portions of the floor structure, combining different crossing direction options, and optimizing the dimensions of structural members.

[0451] In some embodiments, if a given object can be traversed by a beam in at least one direction, then the object and any representation of the object are referred to herein as "traversable"; otherwise, the object and any representation of the object are referred to herein as "non-traversable". In some embodiments, if the maximum range of the object in a given direction ( For exampleIf the length, width, etc. of the joist are less than or equal to the maximum joist length of 1512, then the joist can cross the object in the stated direction. Otherwise, the joist cannot cross the object in the stated direction. For a given object, the direction in which the joist can cross the object is also referred to herein as the "crossing direction" of the object and any representation of the object.

[0452] In some other embodiments, the joist can be replaced by any type of structural element that can provide auxiliary support in any technically feasible manner. In such embodiments, if a given object can be traversed by a structural element in at least one direction, the object and any representation of the object herein are referred to as "traversable"; otherwise, the object and any representation of the object herein are referred to as "non-traversable". In some other embodiments, the maximum joist length 1512 can be replaced by the maximum length of any type of structural element that can provide auxiliary support. In some embodiments, if the maximum range of a given object in a given direction ( For example If the length, width, etc. of a structural element are less than or equal to the maximum length of a structural element that can provide auxiliary support, then the structural element can span the object in the said direction.

[0453] In some implementations, the floor region engine 1520 represents the entire floor structure as a floor structure polygon 1522. Importantly, if the entire floor structure is traversable, the floor structure polygon 1522 is an optimized solution to the optimization problem of subdividing the floor structure, combining different subdivision options, and merging parts of the floor structure into larger traversable portions of the floor structure. The floor region engine 1520 can determine whether the entire floor structure can be traversed in any technically feasible manner. As shown in the figure, in some implementations, the floor region engine 1520 uses a span analysis engine 1540 to determine whether the floor structure is traversable.

[0454] For illustrative purposes only, Figure 15 Depicts a single instance of the span analysis engine 1540, which is based on the input maximum span ( For example (Maximum beam length 1512) Each of any number of input polygons is analyzed independently. In some implementations, each input polygon represents an arbitrary shape of a different object. For example (The shape of the room). The span analysis engine 1540 can analyze the input polygon sequentially, simultaneously, or in any combination thereof in any technically feasible manner. In some other implementations, any software program ( For example The room-based design application 1500, floor area engine 1520, merging engine 1570, etc. can be configured with any number of instances of span analysis engine 1540 to analyze any number of polygons sequentially, simultaneously, or in any combination thereof in any technically feasible manner.

[0455] In some implementations, to analyze a given input polygon, the span analysis engine 1540 implements, but is not limited to, any number and / or type of unsupervised clustering operations and / or algorithms, and optionally any number and / or type of sorting operations and / or filtering operations, to determine one or more orientations of the boundary edges of the input polygon. In some implementations, the clustering operations and algorithms implemented by the span analysis engine 1540 are similar to those previously combined herein. Figure 4 The basic direction described in Engine 410 and / or combined with the previous text Figure 11 The clustering operations and algorithms implemented by the mesh orientation engine 1142 are described. Notably, the base orientation engine 410 determines any number of beam orientations, the mesh orientation engine 1142 determines any number of mesh orientations, and the span analysis engine 1540 determines any number of edge orientations for the boundary edges.

[0456] More specifically, in some implementations, to determine a set of edge directions (not shown) for a given input polygon, the span analysis engine 1540 determines unique edge directions represented by the boundary edges of the input polygon. The span analysis engine 1540 weights each edge direction based on the total length of the associated boundary edges. Subsequently, the span analysis engine 1540 calculates the weights based on a K value (…). Right now Multiple instances of the K-means clustering algorithm are performed on weighted edge directions using different combinations of the number of clusters to be generated and the seed to generate multiple edge direction cluster sets. Each edge direction cluster set specifies, but is not limited to, a different distribution of the weighted edge directions across any number of edge direction clusters.

[0457] The span analysis engine 1540 then executes the elbow rule heuristic to determine the elbow point based on the edge direction clusters. The span analysis engine 1540 sorts the edge direction clusters based on their distance to the elbow point to determine the highest-ranked edge direction cluster. Subsequently, the span analysis engine 1540 generates an edge direction set including, but not limited to, one or more edge directions, where each edge direction specifies the centroid of a different edge direction cluster within the highest-ranked edge direction cluster.

[0458] In some implementations, for each input polygon, the span analysis engine 1540 initializes instances of the primary direction set 1542 (not explicitly shown) and instances of the secondary direction set 1544 (not explicitly shown) to an empty set. For each edge direction in the edge direction set, the span analysis engine 1540 determines a length equal to the maximum input span ( For exampleThe span analysis engine 1540 determines whether a beam with a maximum length of 1512 (perpendicular to the edge direction) can span the entire input polygon. If the beam can span the entire input polygon, the span analysis engine 1540 adds the edge direction to an instance of the primary direction set 1542 as the primary direction. Otherwise, the span analysis engine 1540 adds the edge direction to an instance of the secondary direction set 1544 as the secondary direction.

[0459] After analyzing each input polygon, the span analysis engine 1540 outputs instances of a primary direction set 1542 and a secondary direction set 1544 associated with the input polygon. In some implementations, if an instance of the primary direction set 1542 specifies at least one edge direction, the associated object is traversable in the span direction orthogonal to the edge direction specified in the instance of the primary direction set 1542. Otherwise, the associated representation of the associated target and object is not traversable.

[0460] In some implementations, to determine whether an entire floor structure is traversable using the span analysis engine 1540, the floor region engine 1520 inputs the maximum joist length 1512 and the floor structure polygon 1522 into the span analysis engine 1540. In response, the span analysis engine 1540 generates instances of the primary direction set 1542(0) that the floor region engine 1520 stores as a primary direction set 1542(0), and instances of the secondary direction set 1544 that the floor region engine 1520 discards. If the primary direction set 1542(0) specifies at least one edge direction, the floor region engine 1520 determines that the entire floor structure is traversable. Otherwise, the floor region engine 1520 determines that the entire floor structure is not traversable.

[0461] If the floor area engine 1520 determines that the entire floor structure is traversable, then the floor area engine 1520 bypasses the subdivision engine 1550, the block combination engine 1560, and the merging engine 1570. As described in more detail below, the subdivision engine 1550, the block combination engine 1560, and the merging engine 1570 solve optimization problems involving subdividing untraversable portions of the floor structure, combining different subdivision options, and merging portions of the floor structure into larger traversable portions of the floor structure, respectively.

[0462] In some implementations, to bypass the subdivision engine 1550, block combination engine 1560, and merging engine 1570, the floor area engine 1520 inputs the floor structure polygon 1522 and the main direction set 1542(0) into the cross combination engine 1580 as a single instance (not explicitly shown) of the optimized partition set 1578 and a single instance (not explicitly shown) of the main direction set list 1576, respectively. In response, and in more detail below in the context of any number of instances of the optimized partition set 1578 and the associated instances of the main direction set list 1576, the cross combination engine 1580 generates floor structure layouts 1588(1)-1588(L).

[0463] However, if the floor area engine 1520 determines that the entire floor structure is uncrossable, the floor area engine 1520 partitions the building outline 126 via room plan 1502 to generate floor areas 1530, which include, but are not limited to, blocks 1532(1)-1532(B), where B is any positive integer. The floor area engine 1520 can partition the building outline 126 via room plan 1502 in any technically feasible manner. For example, in some embodiments, the floor area engine 1520 performs one or more partitioning operations on the building outline 126 based on one or more walls specified in room plan 1502. In the same or other embodiments, the floor area engine 1520 can extend into the interior of the room ( For example Each of zero or more walls (at a point not connected to any other wall) terminates until the wall meets another wall or the boundary of room plan 1502.

[0464] For illustrative purposes only, blocks 1532(1)-1532(B) are also referred to herein individually as “block 1532” and collectively as “block 1532”. Floor area 1530 is a template for a floor structure, specifying, but not limited to, any number of unclassified walls. Each block 1532 represents a distinct and non-overlapping portion of the associated floor structure. In some embodiments, each block 1532 represents a portion of floor area 1530 of arbitrary shape as a polygon and specifies zero or more walls. In the same or other embodiments, at least one of blocks 1532 represents a portion of the floor structure of arbitrary shape.

[0465] In some embodiments, the outline of room floor plan 1502 matches the building outline 126, and each block 1532 corresponds to a different internal part of the floor, such as a room, corridor, lobby, etc. In the same or other embodiments, the outline of room floor plan 1502 is smaller than the building outline 126, a subset of blocks 1532 each corresponds to a different internal part of the floor, and the remainder of blocks 1532 corresponds to other building features requiring structural support. For example (e.g., balconies, terraces, etc.). In some implementations, the floor area engine 1520 initializes the classification associated with the walls (not shown) to indicate that each wall is an unclassified wall.

[0466] The floor area engine 1520 generates primary direction sets 1542(1)-1542(B) and secondary direction sets 1544(1)-1544(B) based on blocks 1532(1)-1532(B). The primary direction sets 1542(1)-1542(B) are instances of the primary direction sets 1542 associated with blocks 1532(1)-1532(B), respectively. The secondary direction sets 1544(1)-1544(B) are instances of the secondary direction sets 1544 associated with blocks 1532(1)-1532(B), respectively. For illustrative purposes only, instances of the primary direction sets including primary direction sets 1542(0)-1542(B) are also referred to separately as "primary direction sets 1542" and collectively as "primary direction sets 1542" in this document. The secondary direction set 1544(1)-1544(B) is also referred to as "secondary direction set 1544" in this paper and is collectively referred to as "secondary direction set 1544".

[0467] The floor area engine 1520 can generate the primary direction set 1542(1)-1542(B) and the secondary direction set 1544(1)-1544(B) in any technically feasible manner. For example, in some embodiments, the floor area engine 1520 inputs the maximum joist length 1512 and polygons representing the shapes of blocks 1532(1)-1532(B) into the span analysis engine 1540. In response, the span analysis engine 1540 generates and outputs the primary direction set 1542(1)-1542(B) and the secondary direction set 1544(1)-1544(B).

[0468] As shown in the figure, in some embodiments, the subdivision engine 1550 generates a list of traversable blocks 1552 and a list of subdivision block sets 1558 based on the maximum beam length 1512, blocks 1532(1)-1532(B), a primary direction set 1542(1)-1542(B), and a secondary direction set 1544(1)-1544(B). In some embodiments, the subdivision engine 1550 includes, but is not limited to, a list of traversable blocks 1552, a list of non-traversable blocks 1554, a subdivision variation engine 1556, and a list of subdivision block sets 1558.

[0469] In some implementations, the segmentation engine 1550 initializes the traversable block list 1552 and the non-traversable block list 1554 to empty sets. Subsequently, the segmentation engine 1550 adds each of the blocks 1532 to either the non-traversable block list 1554 or the traversable block list 1552. Specifically, for an integer x from 1 to B, if the principal direction set 1542(x) is empty, the segmentation engine 1550 adds block 1532(x) to the non-traversable block list 1554. Otherwise, the segmentation engine 1550 adds block 1532(x) to the traversable block list 1552. As italicized, S blocks 1532 are included in the traversable block list 1552, and (BS) blocks 1532 are included in the non-traversable block list 1554, where S can be any integer from 0 to B.

[0470] For illustrative purposes, block 1532, which is included in the list of straversable blocks 1552, is also referred to herein as a "straversable block" (or "straversable block"). Figure 15 (Not shown in the text) and are collectively referred to as “crossable blocks”. Each crossable block represents a section of the floor structure that can be crossed by a joist. Block 1532, included in the list of uncrossable blocks 1554, is also referred to separately herein as a “non-crossable block” ( Figure 15 (Not shown in the image) and are collectively referred to as "uncrossable blocks". Each uncrossable block represents a section of the floor structure that cannot be crossed by a joist.

[0471] As shown in the figure, in some embodiments, the subdivision variation engine 1556 generates a subdivision block set list 1558 based on the uncrossable block list 1554. The subdivision block set list 1558 includes, but is not limited to, different subdivisi...

Claims

1. A computer-implemented method for automatically generating a design of a floor structure of a building, the method comprising: generating, based on a room plan included in a computer-aided design of the building, a plurality of blocks representing a plurality of portions of the floor structure, the plurality of portions being bounded by a plurality of walls; modifying the plurality of blocks based on a span length to generate a plurality of zones, wherein each zone included in the plurality of zones represents a different portion of the floor structure that is spannable in at least one direction by a structural element having the span length, wherein the structural element comprises a joist providing support to a floor slab, the span length being less than or equal to a maximum joist length; determining a plurality of wall classifications of the plurality of walls based on the plurality of zones; and generating at least a portion of the design of the floor structure based on the plurality of wall classifications and the plurality of zones.

2. The computer-implemented method of claim 1, wherein generating the plurality of blocks comprises performing one or more zoning operations on an outline of the building based on the plurality of walls.

3. The computer-implemented method of claim 1, wherein a first portion of the floor structure included in the plurality of portions of the floor structure corresponds to a room, a hallway, a vestibule, a balcony, or a patio.

4. The computer-implemented method of claim 1, wherein modifying the plurality of blocks comprises: determining that a portion of the floor structure represented by a first block included in the plurality of blocks is not spannable in any direction by the structural element; calculating one or more grid lines to subdivide the first block based on the span length; designating, via the first block, a different structural member for each grid line included in the one or more grid lines to generate a set of subdivisions; and replacing the first block in the plurality of blocks with the set of subdivisions to generate the plurality of zones.

5. The computer-implemented method of claim 1, wherein modifying the plurality of blocks comprises: merging a first block included in the plurality of blocks with at least a second block included in the plurality of blocks to generate a third block; determining, based on the span length, that a portion of the floor structure represented by the third block is spannable in at least one direction by the structural element; and replacing the first block and the at least the second block in the plurality of blocks with the third block to generate the plurality of zones.

6. The computer-implemented method of claim 1, wherein modifying the plurality of blocks comprises: zoning a first block included in the plurality of blocks based on the span length to generate a first set of subdivisions; merging at least one subdivision included in the first set of subdivisions with a second block included in the plurality of blocks to generate a zone; removing the at least one subdivision from the first set of subdivisions to generate a second set of subdivisions; and replacing both the first block and the second block in the plurality of blocks with the zone and the second set of subdivisions to generate the plurality of zones. ​ ​ ​ 7. The computer-implemented method of claim 1, wherein determining the plurality of wall classifications comprises classifying each wall included in the plurality of walls within at least one partition included in the plurality of partitions as a non-load-bearing wall.

8. The computer-implemented method of claim 1, wherein determining the plurality of wall classifications includes classifying a first wall included in the plurality of walls and coinciding with the boundary of at least one partition included in the plurality of partitions as a load-bearing wall supported by a first slab via at least one joist.

9. The computer-implemented method of claim 1, wherein generating at least a portion of the design of the floor structure comprises: An initial floor structure design is generated based on the multiple wall classifications and the multiple partitions, wherein the initial floor structure design specifies at least one load-bearing wall; as well as At least one optimization algorithm is executed on the initial floor structure design based on one or more constraints and one or more design objectives to generate a floor structure design specifying the floor structure.

10. The computer-implemented method of claim 9, wherein the one or more design objectives include at least one of minimizing total weight, minimizing occult carbon, minimizing material cost, or minimizing material waste.

11. 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 automatically generate a design for the floor structure of a building by performing the following steps: Based on the room floor plan included in the computer-aided design of the building, multiple blocks representing multiple parts of the floor structure are generated, the multiple parts being defined by multiple walls; The plurality of blocks are modified based on the span length to generate a plurality of partitions, wherein each of the plurality of partitions represents a different part of the floor structure, the different part being traversable in at least one direction by a structural element having the span length, wherein the structural element includes a joist that provides support for the floor slab, the span length being less than or equal to the maximum joist length; Based on the multiple partitions, determine multiple wall categories for the multiple walls; and At least a portion of the design of the floor structure is generated based on the multiple wall classifications and the multiple partitions.

12. The one or more non-transitory computer-readable media of claim 11, wherein the first portion of the floor structure, which is included in the plurality of portions of the floor structure, has an arbitrary shape.

13. The one or more non-transitory computer-readable media of claim 11, wherein the first portion of the floor structure, which is included in the plurality of portions of the floor structure, corresponds to a room, corridor, hallway, balcony, or terrace.

14. One or more non-transitory computer-readable media as claimed in claim 11, wherein modifying the plurality of blocks comprises: The portion of the floor structure represented by the first block among the plurality of blocks is determined to be uncrossable by the structural element in any direction; Based on the span length, one or more grid lines are calculated to subdivide the first block; By specifying different structural elements for each grid line included in the one or more grid lines via the first block, a set of subdivisions is generated; as well as The first block included in the plurality of blocks is replaced by the set of subdivisions to generate the plurality of partitions.

15. One or more non-transitory computer-readable media as claimed in claim 11, wherein modifying the plurality of blocks comprises: The first block included in the plurality of blocks is merged with at least the second block included in the plurality of blocks to generate a third block; Based on the span length, it is determined that a portion of the floor structure represented by the third block can be spanned by the structural element in at least one direction; as well as The third block replaces the first block and the at least the second block included in the plurality of blocks to generate the plurality of partitions.

16. One or more non-transitory computer-readable media as claimed in claim 11, wherein modifying the plurality of blocks comprises: The first block among the plurality of blocks is partitioned based on the span length to generate a set of subdivisions; The set of subdivisions is merged with a second block included in the plurality of blocks to generate a partition; as well as The partitions are used to replace the first and second blocks of the plurality of blocks to generate the plurality of partitions.

17. One or more non-transitory computer-readable media as claimed in claim 11, wherein determining the plurality of wall classifications includes classifying each wall included in the plurality of walls within at least one partition included in the plurality of partitions as a non-load-bearing wall.

18. One or more non-transitory computer-readable media as claimed in claim 11, wherein determining the plurality of wall classifications includes classifying a first wall included in the plurality of walls and coinciding with the boundary of at least one partition included in the plurality of partitions as a load-bearing wall supported by a first slab via at least one joist.

19. One or more non-transitory computer-readable media as claimed in claim 11, wherein generating the at least a portion of the design for the floor structure comprises: Multiple crossing directions are determined based on the multiple partitions and the crossing length; An initial floor structure design is generated based on the multiple wall classifications, the multiple partitions, and the multiple spanning directions. The initial floor structure design specifies at least one beam, at least one joist, and at least one load-bearing wall. as well as At least one optimization algorithm is executed on the initial floor structure design based on one or more constraints and one or more design objectives to generate the design of the floor structure.

20. A system for automatically generating designs of the floor structure of a building, 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: Computer-aided design of buildings includes generating multiple blocks from room floor plans that represent multiple parts of the floor structure, the multiple parts being defined by multiple walls; The plurality of blocks are modified based on the span length to generate a plurality of partitions, wherein each of the plurality of partitions represents a different part of the floor structure, the different part being traversable in at least one direction by a structural element having the span length, wherein the structural element includes a joist that provides support for the floor slab, the span length being less than or equal to the maximum joist length; Based on the multiple partitions, determine multiple wall categories for the multiple walls; and At least a portion of the design of the floor structure is generated based on the multiple wall classifications and the multiple partitions.

Images