extending bim with computational design

Extending BIM with Computational Design 1

Extending BIM with Computational Design By Lachmi Khemlani, Founder and Editor, AECbytes

IntroductionEstablishing building information modeling (BIM) as the current de facto standard in the engineering, architecture, and construction (AEC) industry for infrastructure design and construction is not only a tremendous improvement over the earlier computer-aided design (CAD) technology in terms of speed, efficiency, accuracy, and cost, but it is also in line with “smartening” technology. The objective of new advancements in computational design technology1 is to improve upon the earlier way of doing things. In the AEC industry, the CAD era—which can be considered the first “generation” of computational technology—was an undisputed improvement over the earlier hand-drawing era. Now, the CAD era has been supplanted by the next-generation BIM era, fueled by continuing advancements in areas like databases, computer graphics, and object-oriented programming.

In addition to the many benefits of BIM over CAD, one significant benefit is that the “intelligence” of BIM—where a building or infrastructure asset is represented by computational elements that carry information about themselves and their relationships to other elements—provides an excellent launching pad to develop more advanced capabilities. Like the adage “success builds on itself,” the same is true for intelligence, especially when it comes to computers. For instance, the development of object-oriented programming spurred a whole new generation of technologies, which are now spurring the development of even more advanced technologies.

It is the same with BIM. Now that we have an intelligent, object-oriented platform to build on, we can extend even further because BIM, by itself, is not particularly intelligent. Undoubtedly, it is a lot better than CAD. Once you create the building model, all the required drawings, schedules, and additional documentation can be automatically derived from it. However, you still must model each element of the building. It can quickly get very tedious, and what we would all like from our computational software is to reduce the tedium associated with a task.

The AEC industry should not stop with the benefits of BIM over CAD. We need to continue building on it to keep improving, to extend it with computational capabilities. This paper highlights the different ways that these goals are being done using OpenBuildings GenerativeComponents by Bentley Systems, one of the leading computational design applications in the AEC industry.

Overview of OpenBuildings GenerativeComponentsBentley Systems has been developing software for the AEC industry since 1984 and currently has over a hundred solutions in its product portfolio, encompassing the design, construction, and operation of roads and bridges, rail and transit, water and wastewater, public works and utilities, buildings and campuses, and industrial facilities. A key component of its portfolio is its suite of BIM applications for all these different infrastructure types, built on an open building environment and

1. Computational design is the application of computational strategies to the design process. Computational design involves creating a set of rules, requirements, and programs, using code or assembled via a graph known as visual programming. This process allows designers to create or explore results, which can solve design problems or speed up the process in finding or creating the solution.


into all of Bentley’s BIM applications, automatically included during installation. The algorithmic parametric modeling capabilities of OpenBuildings GenerativeComponents can now work with BIM elements, in addition to geometric elements, opening up the BIM model to the application of automation and smart technology to reduce the time and tedium of creating the entire model.

Figure 2 shows OpenBuildings GenerativeComponents running inside OpenBuildings Designer and the different components of its interface, providing

branded accordingly, such as OpenBuildings, OpenBridge, OpenRail, OpenRoads, and OpenSite.

Another long-standing software feature in Bentley’s portfolio is OpenBuildings GenerativeComponents. It was a Bentley stand-alone product but now is an integrated capability in OpenBuildings Designer (formerly known as AECOsim Building Designer). When it was introduced in 2003, BIM had barely been introduced in the AEC industry, and OpenBuildings GenerativeComponents worked exclusively with CAD entities, allowing script-based parametric modeling as an alternative to regular geometric modeling. Design firms found that it could be used to model complex forms that would be impossible to create otherwise, and most of the OpenBuildings GenerativeComponents examples from this time are of “signature” architecture, as shown in Figure 1.

As BIM started becoming more established in the engineering, architecture, and construction (AEC) industry in the early 2010s, OpenBuildings GenerativeComponents began being used alongside BIM. It has now been fully integrated

Figure 2. OpenBuildings GenerativeComponents feature. The interface elements are windows showing the node types, transaction list, the graphical script, and the viewing windows, which is built into OpenBuildings and used along side every day design tools.

Figure 1. Examples of the use of OpenBuildings GenerativeComponents in creating complex forms prior to its integration with Bentley’s OpenBuildings Designer.


an overview of how it works. You would typically start with one or more geometric or BIM elements in the graphics window and use them as the basis for creating a script that captures the logic of the element(s) being designed.

The script is built by dragging and dropping nodes, representing elements, from the Node Types window to the Graph window. With the BIM integration, the node types include BIM entities like walls, doors, and windows, in addition to geometric entities like points, lines, arcs, solids, surfaces, and meshes (Figure 2). Information properties are also included in all geometry nodes giving the elements properties needed for today’s deliverables. Nodes are connected by wires to capture their dependencies—the inputs to them and the outputs from them—and there are many properties and functions that can be associated with a node, depending upon its type. The input-output wires can also be used to connect to specific properties of nodes rather than the entire node to capture relationships between elements.

While developing the script, the model will create or change, depending on the actions provided that can be seen in the open View windows. All the steps in the script are recorded in a list in the

Transaction dialog, which allows you to rollback any of the steps or replay the script step by step to see the design’s trajectory. Any change made to the base reference objects that defines the model, as captured in the script, can instantly update the entire model (Figure 3).

There are some additional interface features in OpenBuildings GenerativeComponents that can be displayed if needed. There is the Editor window, shown below the Transactions window in Figure 4, which allows the code of the graphical script to be seen and fine-tuned if required. There is also a Control Panel, which can be used to collect key parameters of the script for easy access. These parameters are in the form of sliders, allowing their values to be quickly modified to see their impact on the design, as shown in the example in Figure 5.

Figure 3. An illustration of how changing the base reference object—a surface in this example—updates the underlying OpenBuildings GenerativeComponents model. Figure 5b. The shading device changes as the user moves the slider.

Figure 4. An OpenBuildings GenerativeComponents example showing additional interface components, including the Editor window and the Control window with sliders to change parameter values.

Figure 5a. Experimenting with a parameter value for a shading device through its slider in the Control Panel.


Implementation in Building DesignThe implementation of OpenBuildings GenerativeComponents in building design ranges from simple examples that require a limited number of nodes connected into a relatively simple, easy-to-understand script to more complex examples requiring many node types, connections, and a script that takes time and expertise to develop. A simple implementation is shown in Figure 7, where OpenBuildings GenerativeComponents helped create a landscape path along a centerline. While it may take some time to first create this script, the advantage becomes evident when a change is made to the centerline: the entire path is immediately recreated to match the new alignment. Also, once created, the script can be reused and shared with others, acting as the basis of creating similar or more complex scripts.

More advanced functionality in OpenBuildings GenerativeComponents is available through a programming and scripting interface, which allows user-defined nodes and functions to be created for more sophisticated implementations. A good example of this extension of OpenBuildings GenerativeComponents is by PLP Architecture on the Francis Crick Institute project, shown in Figure 6. They wanted to implement specific behaviors for the louvres on the roof to maximize shading throughout the year while still providing sufficient ventilation for the mechanical equipment underneath. They wrote their own functions, extending the built-in set delivered with OpenBuildings GenerativeComponents.

Figure 6. User-defined functions in OpenBuildings Designer GenerativeComponents for the Francis Crick project. (Courtesy: PLP Architecture).

Figure 7. A simple OpenBuildings GenerativeComponents implementation for creating a landscape path based on a centerline. Any change in the alignment of the centerline can automatically update the path without having to manually remodel it. (Example courtesy of 5D Design: https://www.youtube.com/watch?v=2IoMLdzOtOE&feature=youtube).


A more complex example comes from the architectural firm Johnson Pilton Walker (JPW), which used OpenBuildings GenerativeComponents extensively for its Parramatta Square project in Sydney, Australia. The project involved designing two buildings as part of the urban renewal initiative, with one of the buildings—8 Parramatta Square—set to become Australia’s tallest commercial tower at 55 stories and 243 meters in height (Figure 8). While JPW used traditional BIM modeling for much of the project, they also used OpenBuildings GenerativeComponents to automate several key processes. They include pulling in Excel data through OpenBuildings GenerativeComponents for creating all its 1,400 columns and beams; modeling the complex façade with over 8,000 panels, each of which was slightly different (Figure 9); and automating

modeling of the 179,000 ceiling panels for each floor, including the cutouts for accommodating structural elements and ductwork, and the placement of lighting fixtures (Figure 10). Using OpenBuildings GenerativeComponents led to dramatic efficiency improvements, taking the design team only hours instead of days to model the tower structure, façade, and ceilings. In addition, OpenBuildings GenerativeComponents’ iterative and automated scripting allowed the design team to quickly explore numerous options for shading and solar access, delivering an elegant, energy-efficient façade and comfortable indoor working environments.

Another example of the use of OpenBuildings GenerativeComponents in building design was the façade design for KPF London and

Figure 9. Using OpenBuildings GenerativeComponents to automate the design of façade panels for the 6 & 8 Parramatta Square project. (Courtesy: Johnson Pilton Walker).

Figure 8. The Parramatta Square area in Sydney, Australia. JPW was the lead designer for the 6 & 8 Parramatta Square buildings. (Courtesy: Johnson Pilton Walker).

Figure 10. Using OpenBuildings GenerativeComponents to automatically cut the ceiling panels on each floor to accommodate the structural elements. (Courtesy: Johnson Pilton Walker).


An example from the same project highlights the efficiency gains from the use of OpenBuildings GenerativeComponents. Its complex building façade, including a downdraft-deflecting canopy around the bottom of the building (Figure 13), was made up of over 3,000 facade panels that were repeatedly rearranged for design iterations. Without using OpenBuildings GenerativeComponents, it would have been tedious and laborious work, as well as inhibited exploration of further iterations for the design. Using OpenBuildings GenerativeComponents to automatically configure these panels encouraged continued design explorations of the underlying form without worrying about additional manual labor.

PLP Architecture’s Pinnacle Building project in London (Figure 11). They needed an economic and effective rain-screen façade for a tapering building, with both concave and convex geometry. The main goal was to minimize the thickness of the façade to maximize the leasable floor area, while still working with uniform rectangular façade panels (despite the complexity of the building shape) and one standardized substructure support connection for the panels. This plan would allow for easier fabrication and meet the constructability constraints. They needed to create a complex shape with standard components and straightforward installation to keep costs down. KPF London and PLP Architecture used OpenBuildings GenerativeComponents to experiment with various façade panel configurations to find an optimal solution. The result was a properly functioning rainscreen that also fulfilled the design criteria and constructability constraints (Figure 12).

Figure 11. The Pinnacle Building project in London. (Courtesy: PLP Architecture).

Figure 12. The use of OpenBuildings GenerativeComponents facilitated the design of rainscreen for the Pinnacle Building project that met functional requirements, as well as design criteria and constructability constraints. (Courtesy: PLP Architecture).


Implementation in Infrastructure DesignWhile the integration of OpenBuildings GenerativeComponents in Bentley’s infrastructure BIM applications—such as OpenRoads, OpenBridge, OpenRail, and OpenSite—has come in later than its integration with its architectural BIM application OpenBuildings, the potential for applying OpenBuildings GenerativeComponents’ algorithmic design capability in infrastructure design is enormous. For example, many infrastructure elements are designed based on one or more alignment curves. Designing them with OpenBuildings GenerativeComponents means that they can be instantly updated when the alignment changes, without manually remodeling the entire design. An example is shown in Figure 14, where a tunnel model is recreated for an updated alignment by simply running the OpenBuildings GenerativeComponents script again. Figure 15 shows the extent of detail in the model that was created with OpenBuildings GenerativeComponents. The ability to have this detailed model automatically updated for a new alignment can save hours or even days of rework, given that the tunnel likely runs across large distances.

Figure 13. The use of OpenBuildings GenerativeComponents enabled the design of the complex façade comprising over 3,000 façade panels in the Pinnacle Building project. (Courtesy: PLP Architecture).

Figure 14. A tunnel model created using an OpenBuildings GenerativeComponents script based on a road alignment is instantaneously recreated when the alignment is changed.


Some other examples of using OpenBuildings GenerativeComponents in infrastructure design come from Arcadis, a global design and engineering firm that is associated with several high-profile construction projects, including the London City Airport and the A2 motorway in the Netherlands. Figure 16 shows the use of OpenBuildings GenerativeComponents for creating a cut-and-cover tunnel based on a set of civil alignment lines. The idea is that if the alignment changes, the tunnel model could be recreated in a matter of minutes, avoiding manual rework. Figure 17 shows another example with an OpenBuildings GenerativeComponents script for a tunnel boring machine (TBM). A tunnel boring machine is used to excavate tunnels with a circular cross-section. The script not only creates the tunnels based on the specified alignment, but it also creates the segmental lining rings (which are specific to these types of tunnels), including which segments need to be tapered. Designing these segments involves using the generative design capabilities of OpenBuildings GenerativeComponents to run through all permutations and find the best solution for each ring.

Figure 16. A prototype cut-and-cover tunnel model created in OpenBuildings GenerativeComponents based on a set of alignment lines. (Courtesy: Arcadis).

Figure 15. The details in this tunnel model were all created with OpenBuildings GenerativeComponents, which means that they can be immediately recreated by running the script again for an updated alignment.

Figure 17. An OpenBuildings GenerativeComponents script can not only design a TBM tunnel based on the required alignment, but can also run all the options to determine the key segment (shown in pink), which has to be tapered for each lining. (Courtesy: Arcadis).


About the AuthorLachmi Khemlani is the founder and editor of AECbytes (www.aecbytes.com), a publication that has been researching, analyzing, and reviewing technology products and services for the building industry since 2003. She also consults on the development and implementation of AEC technology, authors research reports and white papers, and serves on juries for technology awards. She has a Ph.D. from the University of California, Berkeley, where she specialized in the application of computing technology to the building industry.

© 2021 Bentley Systems, Incorporated. Bentley, the Bentley logo, OpenBuildings and OpenBuildings GenerativeComponents, GenerativeComponents OpenRoads, OpenBridge, OpenRail, and OpenSite are either registered or unregistered trademarks or service marks of Bentley Systems, Incorporated or one of its direct or indirect wholly owned subsidiaries. Other brands and product names are trademarks of their respective owners. 26617 2/21

ConclusionsThe mission of computing in any field is two-fold: first, to eliminate drudgery by automating tedious, repetitive, and time-consuming tasks, and second, to increase the current level of intelligence and accuracy, allowing a lot more to be done with a lot less. We want to “work smarter, not harder.” Technology like BIM is a great start to improving the technological state-of-the-art of the AEC industry over the earlier CAD technology. However, it can go even further with the application of a computational design capability like OpenBuildings GenerativeComponents.

OpenBuildings GenerativeComponents is defining the relationships between elements and not just the elements themselves. They are the relationships that AEC professionals understand. By itself, BIM is focused on elements

and their properties—often in great detail, as you can see from the property list of an object in a BIM application. With OpenBuildings GenerativeComponents, you can now define how these elements relate to one another, their “cause-and-effect” dependencies, and the “rules” that govern them, which allows a change in one element to be propagated to the entire design. Making the design logic more explicit can lead not just to efficiency and automation gains, but also to more thought-out designs. Also, AEC firms can iterate more easily, trying various “what-if” scenarios to explore more solutions than they would have the time and the resources to do.

The intelligent building blocks of BIM provide an excellent foundation to continue building more automation and smarts using computational design capabilities like OpenBuildings GenerativeComponents.

extending bim with computational design

Documents