Håvard Vasshaug, Dark [email protected] Class · PDF file ·...

Session 3

The Dark Arts of Revit: Conceptual Modeling

Tools and Computational Logic in Structural

Design

Håvard Vasshaug, Dark

[email protected]

Class Description

Revit software provides tools for using conceptual modeling and

computational logic in an advanced Building Information Modeling

environment. Can these tools be used in Structural Design? This

presentation will show how to play with Adaptive Components, patterns,

repeaters, math and Dynamo to create structures and components that

challenge the generic modeling capabilities of Revit. Complex concrete

forms, post-tension concrete reinforcement and trigonometry-driven steel

frameworks will be covered in a wonderful symbiosis of fantasy exercises

and real-world project problems. Let’s succumb to the Dark Arts of Revit…

About the Speaker

Håvard Vasshaug is a structural engineer, Revit power user and Digital

Design Manager at Dark, one of Norway's largest planning, architecture

and interior design practices. He has vast experience providing Revit

training, solutions and seminars for architects and engineers the past 8

years, and now uses this background to share knowledge of Revit

solutions at Dark and to whoever else that enjoys it.

Håvard is a regular presenter at Autodesk University and Revit Technology

Conferences around the world. He is an enthusiastic blogger and national

Revit forum administrator. Collaborating with Autodesk, he is a part of the

Autodesk BIM Open Source Project Steering Committee, a dedicated

Revit development contributor and a very proud Revit Gunslinger.

Conceptual Modeling and Computational Logic


of 58

Introduction

As I see it, there are two main reasons for learning conceptual modeling

and computational logic in structural design.

First, and most obvious, this way of operating allows us to design more

complex, organic and optimized structural shapes faster than with

traditional modeling tools. We can evaluate multiple structural options

with great ease, and build beautiful structures based on natural and

mathematical principles rather than clicking and dragging.

Second, and perhaps less obvious, visual programming in Revit through

Dynamo offers us a way of expanding the boundaries of what actually

can be accomplished in a BIM tool. We can access and edit Revit

projects and families at a completely different level of effectiveness and

availability than traditional hardcoded tools allow. We can establish

relationships between objects that Revit normally can’t, and create

elements using external data normally reserved for the software code

knowledgeable. In short, we can create, and obtain deep understanding

of, our own design tools; a glimpse into the future.

In this class, and handout document, we will focus almost exclusively on

the first part, but in doing so also touch aspects of the second.

I am passionate about empowering young engineers and architects with

knowledge of exceptional digital design tools, and firmly believe this to be

the next generation for many of them.

Note

All information in this class handout is based on the following software

versions:

1. Conceptual Modeling; Revit 2015 Build 20140322_1515(x64)

2. Dynamo; Revit 2014 20131024_2115(x64) Update Release 2 and

Dynamo 0.6.3.7993

If any of my examples deviate from your experience, please run a check

on the versions you are using.



of 58

Table of Contents

Table of Contents .................................................................................................. 3

Conceptual Modeling .......................................................................................... 4

Modeling a Space Frame using Massing, Adaptive Components and

math..................................................................................................................... 4

Building a Grid System....................................................................................... 5

Dynamo ................................................................................................................ 18

Modeling a Space Frame using a graphical algorithm editor ................. 18

Building a Grid System..................................................................................... 18

Integration with Revit Elements ..................................................................... 25

Computational Frame Attractor Thickness .................................................. 44

Analytical Model and Structural Analysis ..................................................... 50

Material for Further Research and Development .......................................... 57

Dynamic Relaxation ........................................................................................ 57

Working with Adaptive Components and Structural Framing ................. 58

Working with Load Data inside Dynamo ..................................................... 58



of 58

Conceptual Modeling

Modeling a Space Frame using Massing, Adaptive Components

and math

The use of mathematical logic in formulas in Revit Families to automate

behavior is well known. But the power of math really comes to play when

we use it with Adaptive Components and the different ways these families

can be used.

There is a whole lot that can be said about different behaviors, settings

and use within the Conceptual Modeling Environment (CME) in Revit and

Vasari. We’ll save all the theory for another time, but before we start our

structural exercise, let’s get the key concepts and relationships in place.

Playing with Adaptive Components and Masses is really about points, lines

and planes, and generic geometry. Both Masses and Adaptive

Components are Revit Families. Masses have their own Revit Category,

and normally host Adaptive Components, although Adaptive

Components are perfectly capable of existing independent in the Revit

Project environment.

Adaptive Components are recognized by Adaptive Points, and this is

unique for these elements in Revit, as no other family have these.

Adaptive Points are placement points that can be hosted by other

geometry or moved freely in 3 dimensions. Typical geometry for hosting

Adaptive Points is Surfaces, Divided Surfaces, Nodes and Divided Paths.

When we host Adaptive Components on Divided Surfaces (using nodes)

and Divided Paths, we can utilize the Repeat command that Revit offers

in the CME. This offers a host of automatic behavior, especially when

combined with mathematical formulas.

Now let’s see how this all works in a Structural Space Frame exercise.



of 58

Building a Grid System

We can lay out a parametric grid system by using a Surface and the

Divide Surface. This can be modeled in several different ways. Here, we

start by making a new Mass family, placing a Reference Point in the

intersection of the two default Reference Planes, drawing a Model

Rectangle around it, and constraining the Rectangle dimensions with

Equals and Labels.

Please note that we can create a surface fast by using the tick mark

“Make surface from closed loops” when drawing the Model Rectangle.



of 58

When we’ve checked that the geometry reacts to parameter changes,

we can select the Surface and click the Divide Surface command. This

creates a rectangular grid on our surface, and we can control the

number or size of divisions by applying a Label to the Divided Surface U

and V parameters. Here we use Layout Fixed Distance and associate the

Distance parameter with a new custom Distance Label.

We can then proceed with revealing the Divided Surface Node Points by

changing the Surface Representation to “Nodes”.



of 58

Finally, let’s model an independent Reference Point somewhere on the

Surface (or outside). This will be the attractor focus of our computation.

Now we have access to the points we need to distribute the Adaptive

Component Frame family. We need to proceed by making the

component.

We create a new Generic Model Adaptive family, and place 5 Adaptive

Points, 4 of which will serve as Divided Surface node points, and the fifth

on the attractor Reference Point. The 5 points can really be anywhere, but

our preview of the family will benefit from a layout similar to the final

product.



of 58

We can continue by connecting the 4 node points with Reference Lines.

In addition we connect Adaptive Point 1 (the attractor point) and all the

other Adaptive Points using Reference Lines. This is to report the length

between the attractor point and each node point. Remember to use 3D

snapping when drawing the Reference Lines, or else they will be

constrained by the Reference Level.

Last we can model the center point of the panel by adding two

Reference Lines between each midpoint of the 4 nodal Reference Lines.

Next we add 4 Aligned Dimensions between Adaptive Point 1 and all the

other points. We want these Dimensions to always report the shortest

distance between these points, as opposed to the orthogonal distance,

and to obtain this we need to host the Dimensions on each corresponding

Reference Line by clicking Set Work Plane and selecting the Reference

Line before placing the Dimension.

When the Dimensions are in place and working, we add a Label to each

and use a custom Reporting Instance Length Parameter.



of 58

To work out the vertical and diagonal frames we add hosted Reference

Points to the 4 nodal Reference Points. Using the same procedure as with

the Dimensions, we click Set Work Plane and select each Adaptive Point’s

horizontal work plane, before placing a Reference Point on the

corresponding Adaptive Point. This can be a bit tricky, but once we have

the 4 Reference Points in place, we can select them one at the time and

associate their respective Offset parameters with a new custom Length

Instance Parameter.



of 58

Next up we add a new Reference Point to one of the center Reference

Lines, select it and click Host Point By Intersection. This will force the

Reference Point to always be in the center of the panel. It’s important

that while placing the Reference Point, Draw on Face is active. If not, the

point won’t be hosted by the line.

We finalize the geometric rig of the component by connecting the 4

nodal offset points with Reference Lines, and also the center Reference

Point. Finalize the geometry by adding hosted Reference Points, radial



of 58

Reference Lines and sweeps using the Create Form tool (appears after

selection of valid geometric rig).

Now comes the interesting part; adding mathematical relationships

between the parameters.

In this example we’ll use the Pythagorean Theorem to obtain a sphere-like

bottom frame layout.



of 58

Translated to Revit Formulas, we get something like this:



of 58

Notice that we’ve added a constant to the equation to be able to scale

the entire frame. This is just a simple Instance Number Parameter.

Now we can try moving the Adaptive Point 1 (attractor point) around,

and observe the 4 different nodal Reference Points changing their offset

values, all based on their linear distance to the attractor point.

Next up we load this family into our Mass family that contains the Divided

Surface. We place the Adaptive Component, first on our attractor

Reference Point, and then in turn on the 4 nodal points of a given

quadrant. When we are doing this it’s important that we place points in

the same sequence as the number of our Adaptive Points.

Before proceeding we need to associate the parameters of the

component with the ones of the Mass.



of 58

Finishing the space frame is now easy by using the Repeat command.

We select the Adaptive Component, and by pressing Repeat it fills out the

remaining quadrants of the Divided Surface. The rest is done by

Pythagoras.



of 58

We can change the Mass parameters or try moving the Reference Point

around. Updating repeated Adaptive Components can be a bit on the

slow side, and often it can help on performance to load a simple family

with only Model Lines and not solid geometry first.

We can also build out a top frame layer with glass ceiling if we want. This

can be done by either adding geometry to the Adaptive Component,

make a new Adaptive Component or using a custom Curtain Panel

pattern-based.



of 58

And we can add a solid sphere to the underside of the Mass to visually

compare the placement of the straight bottom spherical layout to a real

sphere.



of 58



of 58

Dynamo

Modeling a Space Frame using a graphical algorithm editor

Using computational logic in structural design with the visual programming

interface of Dynamo opens new possibilities after becoming familiar with

the Conceptual Modeling Environment.

Within Dynamo we can interact with, and automate processes in Revit,

and build complex and logic structures with minimal energy. All it takes is

a new way of thinking.

Let’s first see how we can get up and running.

Building a Grid System

In this section we will build a computational 3-dimensional attractor grid

system that we will use later.

Dynamo automatically associates itself with the Revit document that is

open when open a definition or start a new one. A dynamo definition can

run on top of a Revit project or family file, but what you can do with

Dynamo depends on where you are. We’ll touch on that later.

We can build a basic computational grid system in Dynamo using any

type of Revit document, but if we want to generate actual Revit Structural

Framing elements we need to be in a RVT-file.

We start by pulling out 3 Number nodes, a Number Range, an XYZ

component and a Watch node, wiring them like below. Then, we can

right-click on the XYZ node and change Lacing to Cross-Product. For more

information on how Lacing works I suggest the Dynamo Learning video

tutorials.



of 58

Figure 1 A square grid system

Figure 2 Lacing explained by David Wood at bimwood.blogspot.com

We now have a square grid system of 9 by 9 points. Note that these points

are Dynamo arbitrary geometry, and has nothing to do with Revit yet. Also

note that making a grid this way makes a list of lists, with each value of X

in each sublist. This will help us when working out a set of lines.

We can add another XYZ node, one more Number node and two

Number Slider nodes, to add a new point in our preview background

canvas. We can use this point as the attractor in our 3D grid.



of 58

Now we add an XYZ Distance node to calculate the distances between

each point in the grid and the single point.

We continue by adding XYZ X and XYZ Y components to pull out the X, Y

and Z coordinates. We will use this to manipulate the Z values with some

computation. We also add two Number Sliders and a Formula node. The

Number Sliders will control different aspects of the offset and amplitude of



of 58

our 3D grid. The Formula nodes have a text field, and in this field write the

syntax “a-(d/c)”. This will let us control the vertical offset with one Number

Slider and the amplitude (or scale) with the other.

Now we can connect everything again by introducing another XYZ

component and wiring it to the XYZ X, XYZ Y and Formula nodes.



of 58



of 58

We can add lines between the points in the grid now by adding a Lines

Through Points node.

We can add transversal lines by transposing the lists of XYZ coordinates

produced by the last XYZ component, and wiring the transposed lists to a

new Lines Through Points node.



of 58

The Lines Through Points nodes generate linear line segments between

each point in a list. We can use continuous splines if we wish by using the

Hermite Spline nodes similarly.

Now we can change the different Number input values using the sliders,

and see our model update accordingly.

Now let’s see what we can make of this in Revit.



of 58

Integration with Revit Elements

One major experienced difference between dealing with Dynamo

geometry and Revit Elements is that viewing, changing and interacting

with Dynamo geometry is superfast. The same cannot always be said

about Revit geometry. Still, one of the great advantages with Dynamo is

that it actually can interact with Revit Elements. Let’s have a look at how

that works.

Surfaces

When talking about Revit, Dynamo and surfaces it’s important to

differentiate between modeling a Revit Surface with Dynamo and using a

Revit surface in Dynamo.

Creating a Revit Surface within Dynamo limits us to only work in the

Conceptual Modeling Environment, as that’s the only place a Revit

Surface can be modeled and edited.

Using an already modeled surface with Dynamo on the other hand,

creates many possibilities. In fact, selecting Revit surfaces in Dynamo

includes every surface in Revit, not only Masses created in the CME. We

can use Walls, Floors and Roofs, anything that has a face really.

In the Revit project we used in the previous section, model (in-place) or

load a Mass surface.

We can pull this surface into our Dynamo definition by adding the Select

Face node, click Select Instance and click on the surface in Revit.



of 58

Now we can divide this face in a similar grid system like we used in the

previous section. In order to do so we have to generate a UV grid, and

convert it to XYZ points. We can do this by adding the Get Surface

Domain, UV Grid and Evaluate Surface nodes, in addition to a Number

node for U and V direction counts.



of 58

Using the line grids from the previous section, we can wire the surface XYZ

coordinate list into the Lines Through Points and Hermite Spline nodes, but

in order to make these work together we have to manually make sublists

of each gridline. We can do this by using a Partition List node together

with the Number Node that controls the U and V count. This way our

partition lists will always correspond to the number of surface divisions.

There is one slight detail we must not forget while doing this, and that is

the number of divisions (8 here) is 1 less that the number of points along

one gridline. Hence we must use a Formula node with the syntax “a+1”

between the Number node and the n input in the Partition List node. This

way the number of partitions will always be one more than the UV count.

PS We do not want to delete the XYZ Distance and Formula nodes used

previously, as they will come in handy later.



of 58

We can further develop this grid by finding the center points of each

panel and offsetting these normally to the surface. To do this we need

two nodes. First we need to use the Best Fit Plane node. This will find the

midpoint between a set of XYZs. Second we need a custom node called

LunchBox Quad Grid by Face by Nathan Miller. This will, with the help of a

little Python programming, get the quadrant points as lists of lists. We need

this to get the best fit plane per quadrant. These quad points can also be

obtained manually without the help of custom nodes and Python

programming, but that requires much more list manipulation, and we will

not cover that here.



of 58

We can visualize the center points easier by right clicking on the Select

Face node and disabling Preview. This will turn off the surface in the

background preview.

Finishing this section we can offset the center points by using the Normal

output from the Best Fit Plane node. This output is a list of XYZs that

represent the normalized vectors for the axis of the best fit plane. We can

use this vector by adding a Scale XYZ node, a Translate Transform node

and a Transform XYZ node.



of 58

Next we wire the Number Slider used as the vertical offset parameter for

the grid in the previous example as the n input in the Scale XYZ node, and

the rest as follows.

The Transform XYZ node now generates vectorized offset points for each

quadrant, and we can control the offset value using a single Number

Slider.

The last thing we need to do is combine the quad points with the

respective offset points into lists of 5 XYZ coordinates. We can do this by

using a Transpose List node on the LunchBox Quad Grid by Face node

and adding that list to the Transform XYZ output by using an Add to List

node.

Following that with another Transpose List node gives us a list of the XYZ

coordinates of all quads and their respective offset points.



of 58

This provides a nice platform to start modeling Revit Elements, and first off

are Adaptive Components.

Adaptive Components

There are a couple of different Adaptive Component nodes in Dynamo,

but the most commonly used is the Adaptive Component by XYZs node.

This node requires a list of XYZ coordinates that define the location of the

Adaptive Points in the family. The number of XYZ coordinates must equal

the number of Adaptive Points.

Also, we need to keep in mind the number sequence of the Dynamo

points when building our Adaptive Component. Dynamo always counts



of 58

from 0, while Adaptive Components start at 1; hence 0 correspond to 1, 1

to 2, and so on.

We introduce the Adaptive Component by XYZs and the Select Family

Type nodes, make sure our 5-point Adaptive Component is loaded into

our Revit document, and wire the nodes.



of 58

This offers many possibilities when it comes to complex, organic and

effective modeling, and also lets us evaluate many different options with

minimal energy. For instance, we can turn on Run Automatically in

Dynamo and change the Revit Surface. The entire component layout

updates instantly.

One thing we cannot do with Adaptive Components however is use them

for structural analysis purposes. These Revit families have no corresponding

Analytical model, cannot host loads or Boundary Conditions, and can’t

be exported to analytical software. (This is actually only partly true, as

we’ll discuss later.)

One Revit element that can do all these things is Structural Framing, and

guess what; there is a Structural Framing node in dynamo!

Structural Framing

The Structural Framing node in Dynamo populates a Revit project

document with beams that we can use for analytical purposes. The node

requires three inputs; Structural Framing Type, Model Curves and an Up

Vector. The Select Structural Framing Type node in turn needs at least one

loaded Structural Framing family in the active project.



of 58

Without having too much detailed knowledge of why, it is a general

impression that the Structural Framing families work best with Dynamo if

they are defined without the automatic cutback feature of Revit. This

feature has a tendency to over-scale the cutback, and although this does

not (normally) effect the Analytical Beams our models look much better.

The curves input require a flat list of Dynamo Model Curves. Normally Line

by Endpoints, Lines Through Points or Hermite Spline does the trick,

depending on what our beams look like (is it a spline or linear line?) and

what list data we have.



of 58

The Up Vector is a tricky one. It gives us the ability to control the

orientation of every beam generated by Dynamo. But to make it work

properly we have to provide the exact same number of up vectors as

there are beams, regardless of how many different up vectors we need.

For instance, if all beams generated from a node are going to be vertical

we still have to define a list of vertical vectors and not one single value.

Last, we really only need one Structural Framing node for each different

Structural Framing Type and up vector. Combining all lists of model curves

with a List node, and making sure we flatten the resulting list, as the

Structural Framing node only works with a single list of curves, we acquire

the desired outcome; a complete set of Structural Framing elements in

Revit.



of 58



of 58

Now with the bottom space frame in place we can continue by adding a

top layer and a vertical grid. We already have all the points, but need

some list manipulation.

Starting with the vertical grid structure we need to combine each bottom

point with the corresponding top point. Each quadrant will have 4 beams

meeting at the center offset point. We can work out this by developing a

list where a corresponding offset point is added to each quadrant point.

Now we can add one center offset point (output of the Transform XYZ

node) to each point by repeating the center offset points equal to the

number of quad points. We do this by pulling out one of the sublists,

extracting its list length and repeating the center offset points by that

quantity. Alternatively we could just add a Number node with value 4, as

our grid is a quad grid, but in case we want to develop a different form

(diamond, staggered, etc.) later this may provide flexibility.

Adding a Get from List with index 0 will pull out the first sublist. Using a List

Length node on Element output will return the number of each quadrant

point, and we can use this number to repeat the center offset points (the

Transform XYZ output).



of 58

Now we have all the start and end points for our lines, and all that is left is

adding a Line by Endpoints node and using the transposed quad grid and

the repeated center offset points as input.



of 58

Adding these lines to the combined list of lines we can start adding a

vertical grid of Structural Framing elements to the Structural Framing node

in our definition.



of 58

The Structural Framing node does not always update already modeled

Structural Framing correctly, and rather model new. Adding a new list of

lines to the generation of beams sometimes result in this unwanted

behavior. We can avoid this problem by either deleting the beams from

Revit, or deleting and replacing the Structural Framing node in Dynamo.

Either solution will result in new beams, and no duplicate elements.



of 58

Working out the top grid should be fairly simple now, connecting all the

quad center offset points. As mentioned previously, these points are

outputs from the Transform XYZ node deriving from the Best Fit Plane. This

list of points is flat, and like for the bottom grid we need to partition the list

with the number of grid lines. Since the number of center points equal the

number of quads (and U and V divisions) we can pull this number from the

defining Number parameter that generates our grid count.



of 58

Wiring the partitioned list into two Lines Through Points, one of them via a

Transpose List node that provides for the transversal direction, generates

the model curves we need.

Finishing by including these curves in the List node, our Space Frame is

complete.



of 58

Again, we can turn on Run Automatically in Dynamo and make

geometrical changes to the Mass Surface, or change the UV count or

vertical grid offset.



of 58

Computational Frame Attractor Thickness

With the complete Space Frame layout and the possibilities in Dynamo,

it’s quite tempting to work out some more advanced geometric

manipulations. One that is quite easy to implement uses the attractor

concept of our first sections.

The center point normal offset distance does not have to be equal for all

quadrants. We can give the entire frame a different form by computing

separate offsets for each quad. One way to do this, and one we used in

the first Dynamo section, is calculating the distance from one given XYZ

coordinate to each grid or quad point. The XYZ coordinate can be

anything from a Dynamo XYZ, a UV coordinate or a Revit Reference Point.

If we want the point to always be in the center of the surface, we can

copy the UV Grid definitions, and make a single 2 by 2 grid, from where

the center point of the grid will serve as the center point of the surface.



of 58

We can get the center point from the UV Grid by using a Get from List

node with either a Number or Formula node. It doesn’t really matter as the

division will always be 2 by 2, but by following the principle of flexibility we

continue with a Formula node and the syntax “((a+1)*(a+1))/2”. This will

force all even number inputs to produce a center point.

Now we can continue to use the XYZ Distance and Formula node we

created in the first sections.



of 58

We delete the Number Sliders, Number and XYZ components, and wire

the XYZ Distance to our new center point and the Best Fit Plane origin.

The Number Slider that previously parameterized the XYZ Scale node can

now be wired out of the Scale XYZ n input, and just remain in the Formula

a input.

Finally, we change the formula to the syntax “a+(d/c)” where a is a

constant offset and c is amplitude, and wire the output to the n input of

the Scale XYZ node.

We should remember to de-wire the Structural Framing node before

executing the definition now, because updating will be much slower

when Revit beams are generated or updated. Mess around with the

different parameters and then wire the Structural Framing node when the

Background Preview looks like something you’re not embarrassed to show

someone.



of 58



of 58

Analytical Model and Structural Analysis

With the introduction of Structural Framing and subsequent Analytical

Beams we can start to explore the possibilities of structural analysis.

First, we can start adding vertical Hosted Line Loads for Live Load. If the

Steel Sections we have used in Dynamo are somewhere what we want to

design we can use them for Dead Load. Otherwise we provide dead load

too as Hosted Line Loads. There is no way to use Area Loads sadly, as that

require planar Structural Floor elements, something we do not have here.



of 58

It’s interesting to note that the Hosted Line Loads will update with the

Analytical Beams when we change certain parameters in Dynamo. Of

course adding new beams will require manually modeling new loads, but

most updates that either move or deletes load will update.

Boundary Conditions can also be added quick and easy.



of 58

When all this is in place we have some options to proceed.

First, we can use Autodesk 360 Structural Analysis to perform simple

calculations and analyze and visualize the results in Revit.



of 58

We can even bring in and visualize deformation in a Revit View.

We can also use Revit Extensions to get quick and easy Load data at

supports and different members.



of 58

The Revit Extensions can also save reaction loads back to Revit as native

Revit Internal Point Loads at supports.



of 58

We can export our analytical model to Robot Structural Analysis

Professional and perform detailed and complete automated load

combinations, calculations and steel section dimensioning. After

optimizing the steel sections in Robot, the updated members can be

brought back to Revit.

Last we can export node and line data directly from Dynamo to Excel or

CSV, and bring this into whatever analysis software we use. We can easily

differentiate between different sets of points and lines in a dynamo

definition, and extracting that information is done by simply wiring the

following sets of nodes:



of 58

Similarly we can export the same data to CSV.

Many structural analysis programs can import analytical data from Revit,

but in case that for some reason fails, nothing can go wrong with

numerical Excel data.



of 58

Material for Further Research and Development

Dynamic Relaxation

In the sample library of Dynamo there is an exercise called Dynamic

Relaxation. This definition creates a Particle System from any given points

and curves, in addition to a host of numerical data (including gravity),

and loops this data in a set of iterations that “freezes” in a position where

all members have ideal stress.

In our example, we should be able to apply this concept on our double-

curved surface, and generate a pressure-optimized space frame in

Dynamo, rather than the one we made from guessing and analyzing.

However, in the current versions of Dynamo these nodes does not work

properly, and either crashes or never returns from the loop.

When these nodes start working properly I see a lot of potential for great

use when working with structural optimization.



of 58

Working with Adaptive Components and Structural Framing

As engineers a very likely scenario on AEC projects includes us receiving

an already modeled structural system from an architect, using Adaptive

Components rather than Structural Framing. As we discussed earlier, this is

great for modeling flexibility, but provides no analytical data.

Rather than modeling a structure over again, or modifying an

architectural definition, we could extract point and line data from the

Adaptive Components using Dynamo, and use these to work with

structural analysis. Whether passing them on directly to analytical software

or generating Revit Analytical Elements, this provides us with the

opportunity to work fast with correct data. The time saved on not

remodeling could be used on analyzing many more options instead.

This would also work with updated models, say, if we receive a new set of

Adaptive Components from the architectural design team.

Working with Load Data inside Dynamo

One problem described earlier, and a major workflow issue is the fact that

we have to model loads manually and separately, either in Revit as Line

Loads or in Robot using Cladding and Area Loads. This presents us with

ineffective labor and design change problems, for instance when

changing the UV Grid. Working only with Line Loads in Revit, as opposed

to Area Loads, is also fairly time consuming, as it presents conversion

operations when all available load data is described by areas, and lots of

clicking.

A solution for this could either be some kind of Load Nodes or Load input

for Structural Framing that lets us apply load data to elements, or maybe

even areal load data to surfaces.

Håvard Vasshaug, Dark [email protected] Class · PDF file ·...

Documents

Transcript of Håvard Vasshaug, Dark [email protected] Class · PDF file ·...