Optimizing Architectural Workflows: Revit vs. Dynamo+Revit

Introduction

This capstone, supervised by Professor Ambarish Golawar as part of the Building Information Modeling (BIM) Management program at George Brown College, aims to compare the workflow efficiency of two widely used software tools in the Architecture, Engineering, and Construction (AEC) industry: Revit and Dynamo. This study will explore the strengths and weaknesses of each program through case studies and testing and tracking of specific tasks or processes typically executed in construction drawings.

Capstone goals are to:

1. Explore the experiences of AEC professionals by examining case studies of projects that leverage Revit or Dynamo + Revit, delving into their project timelines and workflows.

2. Identify areas where each software excels or lacks in performance.

3. Select repetitive tasks to encompass common construction documentation practices in both Revit and Dynamo, including creating sheets, elevations, modeling elements, etc.

4. Automate workflow in Dynamo through custom scripts and compare efficiency of task automation in Dynamo versus manual drafting in Revit. Note the learning curve of Dynamo.

5. Develop a system to track process efficiency for each software, measuring factors such as the time required to execute tasks in Revit versus Dynamo and the level of automation achieved.

6. Document all research steps in the form of a comprehensive report, and identify the practical applications of each software along with the scenarios in which they enhance workflow

About Autodesk Revit

Revit is an easily navigable Building Information Modeling (BIM) software developed by Autodesk. Key features of Revit include parametric modeling, integrated design environment, building performance analysis, construction documentation, collaboration, and coordination. Revit has the benefit to strengthen stakeholder collaboration by providing a shared modeling environment for architects, engineers, and contractors to work on the same building model. It helps eliminate risks of miscommunication and reduces project completion time. The software provides an automated drawing and schedule generation feature, enabling architects to generate detailed drawings and schedules, thus saving time and reducing the risk of human error Revit has an intuitive user interface and offers customizable tools and templates. Additionally, the software improves construction planning and coordination, streamlining the documentation and construction delivery process.

Revit Performance Insights

To gather professional insights into Revit usage, I approached six of my colleagues at an architectural firm known for its expertise across the commercial, healthcare, industrial, and residential sectors. My department operates within the commercial sector, where we rely on Building Information Modeling (BIM) tools such as Revit for project documentation, coordination, and visualization. My coworkers, ranging from junior to intermediate level architectural technicians, utilize Revit on a daily basis, from schematic design phases to project completion. I posed a single, open-ended question, inviting them to reflect on their experiences with Revit and identify tasks they perceive as suitable for automation. The responses reveal a general frustration with tedious and menial tasks, a struggle shared by many professionals in the architecture and design industry

Notably, the following areas were brought up as in need of automation:

● Cleaning up and managing text, line, and dimension style since we often deal with many copied and duplicated annotation categories.

● Modifying family parameters and family creation.

● Creating, naming, and numbering sheets. Placing views on sheets in set positions automatically.

● Automating door and room schedules.

● Automating tagging and dimensioning.

These examples represent just a fraction of the automation opportunities identified by industry professionals, which have the potential to revolutionize our workflows. BIM

software possesses the capability to pave the way for greater efficiency, accuracy, and innovation within architecture.

Industry Needs in BIM Workflow

Professionals in the Architecture, Engineering and Construction (AEC) and Building Information Modeling (BIM) field often express the need for workflow improvement and increasing automation to reduce repetitive and time-consuming tasks while preventing human error Automation allows professionals to focus their productive time on more complex activities, leading to higher project quality Automation helps reduce the risk of costly mistakes and rework during the construction phase. Automated workflows facilitate improved collaboration among project stakeholders by streamlining communication and data exchange, reducing the likelihood of misunderstandings and conflict. By reducing manual labor, projects have significant cost savings, especially in an industry where profit margins are tight and budgets closely monitored. As projects become more complex and deadlines more demanding, workflows must be adjusted to meet changing project requirements and deadlines.

About Dynamo

Dynamo is a visual programming interface developed by Autodesk to be used in conjunction with Revit. This is a node-based program, where each node has an input and output port. A node’s output port connects to another node’s input port through a wire to transmit data or information, flowing in a single direction, similar to the form of a graphical flowchart. Users can create, upload, and share packages through Dynamo Package Manager Dynamo does not require knowledge of coding-based languages, although it is helpful, and it can make use of external libraries or Application Programming Interfaces (APIs), such as those available in Autodesk products.

BIM models contain a wealth of information valuable for project management, cost estimation, and facility management. Managing and updating these parameters can be challenging, especially in large-scale projects. Revit-Dynamo automation extracts this data and generates reports in various formats such as Excel or PDF, ensuring that stakeholders have access to up-to-date and accurate information. The scripts follow predefined rules, reducing the likelihood of inaccuracies. Dynamo integration into Revit has made it more powerful in terms of automating repetitive tasks. For example, creating 50 sheets is time consuming, and we would need to click to add a sheet each time. With Dynamo, we can create sheets directly from an excel file. Other tasks such as flipping grid heads, inserting families in batches, renumbering or revision of sheets, changing the text head, etc. can be automated as well, helping users do more with less effort and achieving better results. Dynamo can be customized for specific project needs. In early design stages, Revit-Dynamo automation allows the exploration of various design options by quickly generating multiple design alternatives. For example, Dynamo can be used for parametric model creation with key design parameters that allow the exploration of different design scenarios under defined rules.

To evaluate the value that Dynamo brings into a workflow, a benchmark can be the time it takes to carry the task manually, which is subjective depending on one’s individual modeling approach. The point is to prioritize productivity, and determine the kind of tasks that would benefit from automation. For example, someone takes 4 hours on average to manually produce a rebar model and this scenario is infrequent, occurring 12 times a year. A Dynamo solution would take 60 hours to be developed and the complex script takes 15 minutes to run (3 hours total in one year). In this scenario, the company sees no value within the first year. If we factor in the script development time, the company suffers losses for Dynamo implementation.

As another example, we consider a Dynamo tool for placing annotation tags within Revit views automatically. This is a simple task, and someone doing it manually would take 10 minutes, but this could turn into thousands of minutes per year companywide, since most projects require this annotation task. Let's assume that these 10 minutes need to be done 2500 times per year. The Dynamo script could run for 30 seconds to reach this result. If the script development time was around 80 hours, then that means 2500 x (10 mins – 30 secs) – 80 hours = over 300 hours saved per year This is an example of a scenario where Dynamo automation is highly beneficial.

Real World Examples

A test was conducted on a real-world project to assess the benefits of Dynamo over manual methods. This goes to say how companies can improve operational effectiveness with Dynamo, an essential tool in improving workflows in terms of speed and quality The first step for companies is to analyze their current workflows and identify areas of improvement. This experiment was on a 20-storey residential tower consisting of 200 apartments. Initially, the project was a non-workshared model as part of a design competition but once the project was awarded, it needed to become a proper workshared model to be used by a wider team. For this transition, automated tasks included creating five worksets based on office naming conventions, assigning existing elements to specified worksets, creating seven isolated workset views, creating 20 sheets based on an Excel spreadsheet, renaming all 65 views, sheets, and schedules to upper-case, adjusting 507 location of rooms and their associated room tags, renumbering 209 rooms sequentially based on their level, and renaming 209 rooms by apartment type model groups. The results from this experiment were impressive enough to raise discussion during the Autodesk Australia (AU) 2017 conference. Certain scripts offered more significant advantages than others. For example, creating worksets saved under 5 minutes but renaming rooms saved over two hours. The workset tool is also generally run once whereas the renaming room tool could be run multiple times in a project. In total, Dynamo saved 10 hours during project setup.

Another real world example explores how Dynamo can be used to manage data and automate object placement for existing building projects. This study notes the slowed efficiency of a project team caused by manual, repetitive, and tedious modeling, data entry, and quantifying. Dynamo is used as the tool for saving time and minimizing human error as well as quality control. This case study is on an existing landmark, Pavilion Roger-Gaudry at the University of Montreal finished in 1942. The building is composed of three volumes, one 22-storey central tower with two projecting 6-storey wings and 3,500 windows in

masonry works over 17 wings, The landmark’s exterior was modeled from an image-based process that includes point clouds and orthophotos. Its interior was modeled from CAD drawings, which were first cleaned up to resolve irregularities and set as the base model to reference. Among the 22 wings are storeys ranging from 6 to 10, which makes up an immense number of repetitive elements. Dynamo in this stage was used extensively to place rooms and doors, and to number the doors based on the CAD drawings. The Dynamo script read the linked CAD drawing of the floor plan to pick up blocks with room numbers from the CAD layer, check its position, and place the room. Data needed for object placement were extracted from the CAD using AutoCAD Data Extraction Tool. Doors were placed by a Dynamo script using an Excel file. Window numbering was deemed necessary for this project. There were nearly 25 types of windows in the scope of this project, each with highly detailed information. A Dynamo script allowed the obtaining of all information about the windows (by parameter), per wing (by workset), facade (by parameter), identification number (by parameter), storey (by calculations), opening dimensions (width x height), etc. within a few minutes. Likewise, information about the brick walls were exported to Excel through Dynamo for estimation/budgeting purposes. Dynamo allowed modelers to place about 80–90% of objects automatically with some manual clean up, becoming a time-saving operation.

Aerial view of the Pavilion Roger-Gaudry at the University of Montreal, 1948

Photo credit: Division de la gestion de documents et des archives de l’Université de Montréal

In the following technical report section, my aim is to tackle various challenges myself through Dynamo, similar to how the previously shared practical examples utilized this tool for automation. These challenges include purging redundant categories such as view templates from Revit projects and creating Dynamo scripts to streamline AutoCAD layer synchronization with Revit views, such as positioning columns and walls from 2D CAD into 3D. Throughout this process, I have documented my journey with Dynamo, noting encountered issues or successes, highlighting its usefulness in certain scenarios, and sharing examples of created scripts. Ultimately, the intent is to evaluate the overall experience as someone who has no prior knowledge of using Dynamo and to compare the efficiency of using Revit alone versus incorporating Dynamo into the workflow.

Technical Report Section

A1. Resolving Existing Issues

Cleaning up our modeling process is essential. However, without a dedicated BIM team or established templates for project guidance, we often find ourselves without a structured system. As an example, some commercial projects that are received in batches tend to follow a similar layout with some variations in plans or exterior elevations. To save time, drafters resort to duplicating models for new projects, then modifying the models to meet the needs, leading to the replication of standards; a problematic and confusing scenario. These models are cluttered with unnecessary elements: imported links that serve no purpose, redundant dimension styles, and numerous view templates that are either irrelevant or duplicated. These are elements that cannot be deleted from a working project model.

Luckily, Dynamo has what seems like an endless source of custom nodes created by users and shared among others to tackle commonly faced issues. Dynamo and Dynamo Player are found under the Manage tab of Revit. Dynamo Player is what allows Dynamo scripts to be run in Revit without users needing to understand the complexities of Dynamo. It is a way to execute pre-made Dynamo scripts by clicking on options. The custom Dynamo nodes are saved under Packages when one opens the Dynamo interface.

For example, I discovered and downloaded the Modelical package as I was browsing, which contains nodes for cleaning up drawings.

By simply using one node and a True/False Boolean, I was able to purge unused categories, such as view templates that are not in use, from a sample project within seconds. Notice the changes before and after using this tool.

The key here is to figure out which packages to search for This can be achieved by browsing the program to see what is available, as well as searching online forums or watching YouTube videos to get hints on which packages offer which nodes. Additionally, there is the option of creating your own packages and publishing them, but this often requires knowledge of programming languages such as Python, which integrates well with Dynamo.

Dynamo Script:

Before: After:

Moreover, at my workplace, we often model floors and spaces in Revit from an initial AutoCAD drawing, essentially tracing the CAD and duplicating work. Implementing a feature that automatically synchronizes layers from CAD to Revit views would greatly streamline our workflow.

A2. Comparing Efficiency

To compare the efficiency of using Revit alone versus using Revit along with Dynamo, I utilized a sample residential tower’s AutoCAD plan for reference from Bibliocad, a website that provides a vast database of CAD drawings and resources aimed at architects, engineers, and designers. This plan comes with wall, door, and window layouts as well as room names, some furniture, balcony, and stairs as shown in the image below

I linked the AutoCAD floor plan to Revit and fully modeled it, excluding furniture and equipment. Elevation views were created for the corridor and two typical unit types, which are mirrored on the opposite side of the floor plan.

Elevations were not automatically cropped to fit the height of the room, revealing elements such as grids, which I prefer hidden. However, this issue can be easily solved by applying View Templates. Additionally, elevations were not named according to the room name or orientation they are taken from. Graphically, setting up and organizing the elevations on sheets took the longest time. An example of the untouched elevations is shown below

I tracked the amount of time it took for me to manually complete a few specific tasks, as shown in the following table, so that I could compare the execution time of doing these tasks manually on Revit against having Dynamo scripts do them.

Layers in the AutoCAD file were reassigned and renamed to allow for successful Dynamo execution. Before starting each Dynamo script, I created a step-by-step list of procedures to follow for each task, to gain a clearer idea of how to write the script, as summarized through the following notes.

Task 1. Tracing the Floor Slab:

This task marked the initiation of my journey with Dynamo scripting, which naturally presented the greatest challenge as I familiarized myself with the interface, packages, and nodes. Some of the scripts in this study begin with the “Select Model Element” node, which selects the linked AutoCAD model and then specifies a layer to extract information from. For the floor slab, I referred to the “A-FLOOR” layer from the CAD file. I used the “CADCurvesFromCadLayers” node from a downloaded BimorphNodes package to outline the curves from the CAD floor in order to create my floor boundary, then assigned a floor type and level for the floor creation. I assigned input parameters to certain nodes to allow users to pick their options on Dynamo Player. Remarkably, the execution of these scripts typically transpires within mere seconds, almost in the blink of an eye.

Dynamo Script:

Task 2. Tracing the Interior and Exterior Walls:

Getting a script to work for both the interior and exterior walls from the unmodified AutoCAD file was especially challenging because the geometry was not simple enough for Dynamo to understand it properly I recognized the need to adjust certain elements directly in AutoCAD before attempting to automate them with Dynamo. For this example, I created the centerline of the double wall lines in AutoCAD to use as input for Dynamo. This floor plan incorporates two different wall types, so I created two layers in AutoCAD for the distinct centerlines. It took me half an hour to do this.

AutoCAD Layers:

From here, the Dynamo steps were quite simple. I referred to layers "A-WALL-115" and "A-WALL-230" from the CAD file to extract curves. The Dynamo script is based on wall centerline curves, wall type, and levels as input parameters for Dynamo Player

Wall Centerlines on AutoCAD:

This task does not seem to be the most efficient use of Dynamo since time was spent on the AutoCAD file modification. The time it took for me to trace the walls manually on Revit was around 15 minutes, whereas creating wall centerlines on AutoCAD then running the script took a bit over half an hour In this case, it took longer to go through the process with Dynamo than it did with me drawing the walls manually on Revit. While this script may not be useful, a useful tool in relation to walls could be creating a script to place families such as doors and windows in specific wall locations.

Task 3. Adding Grids:

Note that the grids and columns are additions I made to the AutoCAD file and were not previously existing. Grids are created from curves on the "A-GRID-HORIZ" and "A-GRID-VERT" layers in the AutoCAD file.

Dynamo Script:

Dynamo Player: Result:

The naming of grids is not sorted properly, so for this, I created an additional script where drawing Model Lines on Revit gives me control over the direction and order of grid naming. Users can draw two Model Lines on Revit, crossing the horizontal and vertical grids, then select each line on Dynamo Player to sort the grids for alphabetical and numerical naming. The "Character.FromNumber" node is from the Clockwork package and converts a number into a character, where 'a' = 1 and so forth. The “Selection.IntersectingGridsByModelCurve” node is from the Rhythm package, and “Grids.Renumber” is from the Prorubim package.

Task 4. Adding Columns:

The columns I used in this project are all of the same type and dimensions. I referred to the “A-COLUMN” layer from the CAD file to get the boundary curve of columns. Then, I found the centerpoint of the columns using “ToColumnGeometry,” which is a node from the KYSUDO package, to create the columns in 3D from the specified level and column family type, exactly as shown in the CAD file.

Dynamo Script: Dynamo Player:

Task 5. Creating and Naming Rooms:

This Dynamo script was executed using the layer "A-ROOMNAME" to extract room names from the CAD file. Room names were obtained through nodes from the BimorphNodes package, specifically the "CADTextData.FromLayers" node, while the location of text was determined using the "CADTextData.OriginPoint" node, which served as the placement point for rooms. It is important to note that walls were established before this stage, allowing the script to use wall faces as boundaries for the rooms.

Dynamo Script:

Dynamo Player: Result:

Dynamo Script:

The previous plan shows the result of the Dynamo script. In cases where spaces lacked walls as boundaries, room separation lines were created manually The below plan shows the result of adding room separation lines and tagging the room names to complete this task.

Dynamo Player:

Task 6. Creating Ceilings:

Ceilings were generated from room boundary curves and room names. To ensure smooth script execution, I only considered rooms that had been placed. To verify this, I created a room schedule to view all rooms and removed the ones that showed "Not Placed" under the area. The "List.FilterByBoolMask" node reviews all room names and only considers the ones matching the typed name under the “Code Block” node. The automatic ceiling height offset was set to 8 feet, so I ensured that this parameter was flexible in my Dynamo script for room height adjustment. The "Element.Set ParameterByName" node is what allows the "Height Offset From Level" parameter to be associated with an adjustable value. Ceiling types can also be selected in Dynamo Player and applied to specific rooms. This script must be run each time a new ceiling for a room type needs to be generated.

The same script can be created for floor finishes, just by replacing the final “Ceiling. ByOutlineTypeAndLevel” and “Ceiling Types” nodes with “Floor.ByOutlineType AndLevel” and “Floor Types” nodes.

Dynamo Script:

Dynamo Player:

Result:

Task 7. Creating Interior Elevations:

This script is written to require one input, which is selecting a room, and another input which is selecting a View Template to apply to the interior elevations. Interior elevations are created from room locations. The “Rooms.CenterRoom,” “ElevationMarker CreateElevationMarker” and “ElevationMarker.CreateElevationByMarkerIndex” nodes are all from the Rhythm package. The “View Templates” and “View.SetViewTemplate” nodes are from the Archilab package.

In the second part of the script, elevation titles on sheets are renamed using the room name followed by the direction, separated by a hyphen. For example, "BEDROOMNORTH." This renaming is made possible by Dynamo Dictionaries, where each room's direction is associated with a key, ensuring accurate naming for each elevation. Initially, the “String.Remove” node trims the string to only include letters a, b, c, and d, which then serve as the Dictionary keys. From here, key "a" is associated with the value "WEST," key “b” is associated with the value “NORTH” and so forth.

Dynamo Player:

Dynamo Script (Part 1):

Dynamo Script (Part 2):

Overall script and connections:

Results (Note the Title on Sheet and Added View Template):

Task 8. Introducing pyRevit:

Through this research, I discovered another tool, pyRevit, which is a free and open-source add in for Revit that can be downloaded online. It is another tool that allows users to automate time consuming and repetitive Revit tasks. Creating sheets on Dynamo is possible, but pyRevit already includes features to do so without having to develop a Dynamo script. The Sheets icon in the pyRevit tab has a Batch Sheet Maker tool.

After clicking on it, the following dialog box pops up for users to enter the sheet number, press tab and enter the sheet name. A range of sheets can be created using the “::” symbol (eg. A510::1515).

After hitting Create, the tool asks for a Title Block selection for the sheets.

Following this step, all sheets are generated within seconds. This tool proves particularly advantageous for projects requiring the production of numerous sheets.

Another feature of pyRevit is its ability to add views to sheets, allowing users to select which views to load onto a specific sheet. However, this tool does not automatically organize the placement of views on sheets, so this task must be completed manually

In Revit, activating revisions and revision dates on sheets must be done manually, without the ability to apply changes to multiple sheets simultaneously. This manual process can be time-consuming, particularly when dealing with a large set of

Step 1

Step 2

documents. However, in pyRevit, there is an option under the Revision icon called "Set Revisions On Sheet," which streamlines the process of setting revisions for sheets.

First, the revision is selected, followed by the selection of specific sheets to which the revision dates are to be added. This action results in the addition of the revision date to the selected sheets.

Step 1

Step 2

Result:

Task 9. Increasing the Lineweight of Elevation Crop Regions:

Graphically, elevations are often shown with a thick border around their crop region. To do this manually seems like an inefficient use of time. The following Dynamo script increases the lineweight of crop regions for views depending on the sheet the views are placed on. In this case, interior elevations are placed on the Interior Elevation sheets created in the previous task. Nodes from the Rhythm package are used for this script.

Dynamo Script:

Dynamo Player:

Results:

User Challenges in Dynamo Workflows

Dynamo’s visual programming interface can be overwhelming and complex for beginners. Users who struggle to understand the logic behind the visual scripts may have trouble debugging and troubleshooting more complex workflows. More complex scripts may suffer from performance issues in their slow execution times or excessive memory usage. This can be problematic when working with large datasets. As one becomes more proficient in Dynamo, one would notice the lack of documentation and support resources compared to more established software tools. Users may struggle to find comprehensive tutorials or troubleshooting resources for specific issues. Dynamo is a tool for non-programmers, however, lacking knowledge of coding makes it difficult to understand Dynamo’s script structure. Unique and complex issues often require a combination of Dynamo and coding knowledge to be effectively addressed.

In my experience, the learning curve of Dynamo wasn't as steep, given my familiarity with Grasshopper, another visual programming software sharing common principles with Dynamo. Despite occasional challenges in finding online guidance for issues, I quickly adapted to the interface's uniqueness, appreciating its capacity for installing packages and crafting custom nodes. The following tables provide a summary of the comparison between specific tasks performed on Revit alone versus Revit + Dynamo throughout this study. Overall, Dynamo helps to get tasks done faster and projects finished quicker, but only if the user knows when to automate tasks and when not to. In the case of AutoCAD links, it all depends on how much manual cleanup is required before automating with Dynamo.

References

Autodesk University (2021, March 30). Improving efficiency: Dynamo for existing buildings. Medium.

https://medium.com/autodesk-university/improving-efficiency-dynamo-for-existing -buildings-10650f3e7e9a eLogicTech. (2019, June 7). How does Dynamo help in BIM workflow?. eLogicTech Solutions.

https://www.elogictech.com/blog/how-does-dynamo-help-in-bim-workflow eLogicTech. (2019b, November 21). Powerful features that differentiate revit API and Dynamo: ELogicTech blog eLogicTech Solutions.

https://www.elogictech.com/blog/dynamo-vs-revit-api

How Revit-Dynamo Automation Improves BIM Productivity. Engineering.com. (n.d.).

https://www.engineering.com/story/how-revit-dynamo-automation-improves-bim-p roductivity

LLC, S. E. C. (2023, February 7). The Benefits of Using REVIT for Architectural Building Information Modeling (BIM) LinkedIn.

https://www.linkedin.com/pulse/benefits-using-revit-architectural-/

Ramanauskas, R. (2020, March 20). Evaluating the value of computational BIM solutions such as Dynamo for revit Invoke SHIFT

https://www.invokeshift.com/evaluating-the-value-of-computational-bim-solutionssuch-as-dynamo-for-revit/ Releases Eirannejad/pyRevit. (n.d.). https://github.com/eirannejad/pyRevit/releases

Singh, H. (2024, January 31). How Revit Dynamo improves BIM workflows. Hitech CADD Services.

https://www.hitechcaddservices.com/news/how-revit-dynamo-can-improve-bi m-workflows/

UniquesCadd. (2023, May 10). Dynamo: How does it improve BIM workflow efficiency. Medium.

https://uniquescadd.medium.com/dynamo-how-does-it-improve-bim-workflo w-efficiency-b29efa33d8bf

Voyansi. (n.d.). Dynamo - Strengths and Limitations.

https://www.voyansi.com/blog/dynamo-strengths-and-limitations

Voyansi, & Capra, A. (n.d.). Visual programming and Dynamo: A Quick Guide. Voyansi. https://www.voyansi.com/blog/visual-programming-and-dynamo

Wintour, P (2023, December 11). Improving operational effectiveness with Dynamo. Parametric Monkey

https://parametricmonkey.com/2019/02/18/improving-operational-effectiveness-wi th-dynamo/