Mastering the Dynamo Revit Automation Tutorial: Bridging Analysis and BIM for Structural Supports

TL;DR: This Dynamo Revit automation tutorial guides structural engineers on how to save 40% time by automating the transfer of analytical support conditions (boundary conditions) into the BIM environment. The process uses Dynamo and the Clockwork package to read specific XYZ coordinates and restraint types - such as fixed, pinned, or roller - from an external Supports.csv file. This robust script automatically identifies the corresponding analytical nodes in Revit and applies the correct support conditions, eliminating manual data entry errors.

---

Structural engineers spend significant time translating analytical results - like support conditions derived from ETABS or SAP2000 - back into the detailed BIM environment of Revit. This manual transfer is not only tedious but highly susceptible to error. Did you know that engineers can save 40% time with automation by eliminating these repetitive data entry tasks?

This comprehensive Dynamo Revit automation tutorial will guide structural engineers, especially those new to visual programming, on how to automate one of the most critical steps in the analysis-to-BIM workflow: applying analytical boundary conditions (supports) directly from an external data source (like a spreadsheet export from your analysis model) to your Revit Analytical Model.

By the end of this tutorial, you will have a robust Dynamo script capable of reading coordinates and restraint types, identifying the corresponding analytical nodes in Revit, and automatically applying the correct fixed, pinned, or roller supports.

Prerequisites and Setting Up Your Dynamo Environment

Before diving into the script, ensure you have the necessary tools and data ready. This tutorial is designed to be beginner-friendly, requiring only standard Revit and Dynamo installations, plus one essential package.

Required Software and Data:

1. Revit (2020 or newer, with an existing structural model containing analytical elements).
2. Dynamo for Revit (installed with Revit).
3. Dynamo Package: Install the Clockwork package. This package provides essential utility nodes, particularly for list management and data handling.
4. Input Data (CSV): Prepare a simple comma-separated value (CSV) file named Supports.csv. This file must contain the XYZ coordinates of the support locations and the corresponding restraint type.

Setup Steps:

1. Open your Revit project containing the analytical model.
2. Launch Dynamo (Manage Tab > Visual Programming > Dynamo).
3. Create a new Dynamo graph. Ensure the Run mode is set to Manual while building the script.

Part 1: Importing Boundary Condition Data for Dynamo Revit Automation

The first crucial step in this Dynamo Revit automation tutorial is reliably reading and preparing the external data. We need to convert raw text and numbers from the CSV into usable geometry and properties within Dynamo.

Reading and Cleaning the CSV Data

We will use standard Dynamo nodes to import the data.

1. File Path Node: Search for the File Path node. Browse and select your Supports.csv file.
2. File.FromPath Node: Connect the File Path output to a File.FromPath node.
3. Data.ImportCSV Node: Connect the file output to the Data.ImportCSV node. This node reads the spreadsheet content, typically returning a list of lists (rows of data).

The imported data will be structured as rows. For easier processing, especially when mapping coordinates, we need to transpose the list so that all X values are in one sublist, all Y values in another, and so on.

1. List.Transpose Node: Connect the output of Data.ImportCSV to List.Transpose. Now, your data is organized:
   • List [0]: All X coordinates (Strings)
   • List [1]: All Y coordinates (Strings)
   • List [2]: All Z coordinates (Strings)
   • List [3]: All Restraint Types (Strings)

Converting Strings to Coordinates

Revit geometry works in specific units (usually feet in US template, meters elsewhere). Dynamo handles unit conversion internally, but the input data must be converted from strings to numbers.

1. List.GetItemAtIndex Node: Use four instances of this node to extract the four columns (indices 0, 1, 2, and 3).
2. String to Number Node: Connect the output of indices 0, 1, and 2 (X, Y, Z coordinates) to separate String to Number nodes.
3. Point.ByCoordinates Node: Connect the numerical outputs (X, Y, Z) to a Point.ByCoordinates node. This creates a list of Dynamo Point objects representing the exact location of every required support.

Part 2: Locating Analytical Nodes and Matching Coordinates

To apply a support condition, we must first tell Revit which analytical model node corresponds to the coordinates we read from the CSV. Since floating-point arithmetic can be tricky, we must use a tolerance check rather than a direct equality check.

Retrieving All Analytical Nodes

1. Categories Node: Select the category Structural Analytical Nodes.
2. All Elements of Category Node: Retrieve all analytical nodes currently in the Revit model.

Matching Points Using Proximity

We now have two lists of points: the Required Support Points (CSV) and the Available Analytical Model Nodes (Revit). We need to match them.

1. Element.GetLocation Node: Feed the list of Revit analytical nodes into this node to extract their geometric locations (Revit Points).

2. Geometry.DistanceTo Node: This is the core matching step.

   • Connect the Required Support Points (CSV) (from Part 1) to the geometry input.
   • Connect the Available Analytical Model Node Locations to the other input.
   • Set the Lacing to Cross Product. This calculates the distance from every required point to every available Revit node, creating a complex matrix of distances.

3. List.MinimumItem and List.MinimumItem.Index Nodes:

   • Feed the distance matrix into List.MinimumItem. This finds the smallest distance in each sublist (i.e., the closest Revit node for each required support point).
   • Feed the distance matrix into List.MinimumItem.Index. This returns the index of the closest Revit node.

4. Filtering for Tolerance: To ensure we only select nodes that are truly supports (not just near misses), we must enforce a tolerance.

   • < (Less Than) Node: Check if the minimum distance found (from step 3) is less than a tolerance value (e.g., 0.001 ft or 3 mm).
   • List.FilterByBoolMask: Use this Boolean list to filter the list of analytical nodes, leaving only the nodes that match our required support locations within tolerance.

This process ensures high accuracy, which is paramount when linking analysis results. Automation reduces errors by 60%, largely by eliminating manual selection mistakes.

Part 3: Applying Boundary Conditions Using Structural Link Supports

With the correct analytical nodes isolated, the final step in the Dynamo Revit automation tutorial is creating the specialized structural elements known as Analytical Link Supports. This requires mapping the text restraint types (Fixed, Pinned, Roller) back into specific properties Revit understands.

Mapping Restraint Types

Revit uses Boolean properties (True/False) to define restraints in the X, Y, Z, Rotation X, Rotation Y, and Rotation Z directions.

We can use a Python script within Dynamo to manage this complex mapping efficiently, especially if your analysis software (like ETABS or SAP2000) exports complex partial restraints.

# Python Script Node for Restraint Mapping

import clr
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB.Structure import AnalyticalSupportType

# Input: restraint_data (List of strings: "Fixed", "Pinned", "Roller")

restraint_data = IN[0]
support_types = []

for restraint in restraint_data:
    if restraint == "Fixed":
        # Fixed = All translational and rotational restraints True
        support_types.append([True, True, True, True, True, True])
    elif restraint == "Pinned":
        # Pinned = Translational restraints True, Rotational False
        support_types.append([True, True, True, False, False, False])
    elif restraint == "Roller":
        # Roller = Z translation True, others False
        support_types.append([False, False, True, False, False, False])
    else:
        # Default to Fixed or raise error for unsupported types
        support_types.append([True, True, True, True, True, True])

OUT = support_types

Creating the Analytical Link Supports

1. AnalyticalLinkSupport.ByAnalyticalModelNodes: This is the key node for structural automation.
   • Connect the filtered list of Analytical Model Nodes (from Part 2) to the analyticalModelNodes input.
   • Connect the list of Boolean restraint settings (from the Python script) to the six restraint inputs (isTxRestrained, isTyRestrained, etc.). Ensure you use List.Chop or similar list management to feed the correct list of Booleans into the correct input port.

This node instantly creates and places the necessary support elements in Revit, completing the automation cycle.

---

For structural engineers dealing with complex analysis outputs from platforms like ETABS and SAP2000, managing these translations can still be challenging. Tools designed specifically for this integration, such as Structures AI, offer AI-Powered Automation for Structural Engineering, handling the complex data mapping and boundary condition translation seamlessly, often using AI-Powered Recommendations to interpret analytical results and update the Revit model instantly.

Testing and Validation

Once the Dynamo script is complete, click Run.

1. Check the Dynamo Console: Look for successful creation messages or any null values indicating a mismatch in coordinates.
2. Validate in Revit:
   • Switch to a 3D Analytical View.
   • Select one of the newly created analytical nodes.
   • In the Properties palette, verify that the Boundary Conditions parameter is correctly set (Fixed, Pinned, or Roller) according to your CSV file.
   • Verify the existence of the newly created Analytical Link Supports elements.

If all supports are placed correctly, you have successfully automated a critical structural modeling task. This automation can increase productivity 2-3x compared to manual selection and property assignment.

Next Steps and Resources

This tutorial focused on simple support conditions. To expand your skills, consider these advanced steps:

• Custom Restraint Types: Modify the Python script to handle custom spring supports or partial fixity (e.g., using specific spring stiffness values instead of simple Boolean restraints).
• Analysis Linkage: Explore using Dynamo to read output files (MDB, JSON) directly from your structural analysis software, eliminating the need for manual CSV creation.
• Error Handling: Implement robust checks using If nodes to catch scenarios where a required support point does not have a matching analytical node within tolerance.

To deepen your understanding of the Revit API elements used in structural automation, refer to the official Autodesk documentation on Structural Analytical Model Elements.

Conclusion

Automating the application of analytical boundary conditions is a game-changer for structural efficiency. By following this detailed Dynamo Revit automation tutorial, you have learned how to leverage visual programming to create a seamless, error-free bridge between your analysis results and your BIM model. This foundational script can be adapted to automate countless other structural workflows, freeing up valuable engineering time for complex design challenges.

Ready to streamline your entire structural workflow, from analysis to documentation?

Download Structures AI for free today and experience AI-Powered Automation for Structural Engineering, including seamless ETABS Integration and SAP2000 Automation.