Håvard Vasshaug, Dark hvasshaug@gmail€¦ · Håvard Vasshaug, Dark Page 9 of 75 Finally, let’s...

Sessions 10 & 11

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 lab will

teach participants how to play with Surfaces, Adaptive Components,

Math and Structural Framing elements in both Conceptual Modeling and

Dynamo, to design structures that challenge the generic modeling and

analyzing capabilities of Revit. Different Space Frames driven by double-

curved Surfaces, Trigonometry and visual programming algorithms will be

covered in a wonderful symbiosis of fantasy exercises and real-world

project problems.

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.



of 75

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:

Revit 2014 (Build: 20131024_2115(x64) Update Release 2)

Dynamo 0.6.3.7993

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

check on the versions you are using.



of 75

Table of Contents

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

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

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

2. Adaptive Components ............................................................................ 10

3. Math ............................................................................................................ 23

4. Space Frame.............................................................................................. 26

Dynamo ................................................................................................................ 32

1. Building a Grid System .............................................................................. 32

2. Integration with Revit Elements ............................................................... 39

3. Computational Frame Attractor Thickness ........................................... 60

4. Analytical Model and Structural Analysis .............................................. 67

Material for Further Research and Development .......................................... 74

5. Dynamic Relaxation ................................................................................. 74

6. Working with Adaptive Components and Structural Framing ........... 75

7. Working with Load Data inside Dynamo ............................................... 75



of 75

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 75

1. Building a Grid System

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

Divide Surface command. This can be modeled in several different ways.

Here, we start by making a new Mass family.

It’s worth noting that we can create a surface fast by using the tick mark

“Make surface from closed loops” when drawing Model or Reference

Lines.

1. Create a new Conceptual Mass and open Floor Plan – Level 1. (I

often prefer to deal with parameters and constraints in 2D plans

even in CME.)

2. Click Reference Line, choose Rectangle.

3. Place the Reference Line Rectangle approximately symmetrically

around the Reference Plane intersection and constrain the

Rectangle as follows:



of 75

4. Label the width and length dimensions with Width and Length

parameters. Use Instance Parameters.



of 75

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

we can create a grid with the Divide Surface command.

5. Select the rectangular 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.



of 75

6. Change the U and V Grid Layout to Fixed Distance, and associate

the Distance parameters with a new Instance Length parameter

“Distance”. Parameter values are irrelevant.

Here we use Layout Fixed Distance and associate the Distance parameter

with a new custom Distance Label.

7. We can then proceed by revealing the Divided Surface Node

Points by changing the Surface Representation to “Nodes”.



of 75

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

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

8. Click Reference and select Point Element.

9. Place the Reference Point anywhere as long as it does not snap to

other point geometry.



of 75

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

Component Frame family. We need to proceed by making the

component.

2. Adaptive Components

1. Create a new Generic Model Adaptive family.

2. Place 5 Reference Points, select them and click Make Adaptive.



of 75

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

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 (like above).

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

It’s important that we use the Draw on Face and 3D Snapping

settings, or else the Reference Lines won’t be properly hosted on

the Reference Points.



of 75

4. 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.



of 75

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

Reference Lines between each midpoint of the 4 nodal Reference

Lines.

Now we have the basic rig we need to start applying dependencies

between hosting elements, math and geometry.

6. 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.

It’s also important to click on the actual points in the Adaptive Points, and

not one of the Adaptive Point Reference Planes.



of 75

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

and use a custom Reporting Instance Length Parameter. It’s very

important that these parameters are Reporting. Also, you might benefit

from using a logical and short naming convention when using these

parameters in formulas later on. Here I use L2 for the reported length

between Adaptive Point 1 and 2, L3 between Adaptive Point 1 and 3,

and so on.



of 75

7. 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.



of 75

When we’ve placed the point, select it and pull it vertically to make it

more visible and easy to select in the future.

Notice that this will change a parameter called Offset in the Properties

Palette. Let’s associate this parameter with a family parameter.



of 75

8. Click the Associate Parameter button, and create a new

parameter (Add parameter) called Vertical Offset 4 (Instance).



of 75

9. Repeat this procedure for the other 3 nodal corner points (Adaptive

Point 2, 3 and 5 in this example).

This can be a bit tricky, but once we have the 4 Reference Points in place,

we can start working out space frame geometry.

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

Reference Lines, select it and click Host Point By Intersection.



of 75

This will force the Reference Point to always be in the center of the panel.

Again, 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.

11. We finalize the geometric rig of the component by connecting the

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

Reference Point.



of 75

12. Create geometry by adding a hosted Reference Point on one of

the connecting Reference Lines and one Reference Circle hosted

on the point.

13. Repeat this procedure for two of the vertical Reference Lines. Tip:

When you’ve created one set of hosted Reference Point and radial



of 75

Reference Circle, copy it (Ctrl + Drag) and rehost it to another

Reference Line.



of 75

14. Last we create the actual geometry with sweeps using the Create

Form tool (appears after selection of valid geometric rig).

Now comes the interesting part; adding mathematical relationships

between the parameters.



of 75

3. Math

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

bottom frame layout. We simulate a sphere with an origin and a radius,

and that it has a minimal distance to the top frame layer.

1. We call the corresponding Revit parameters Radius and Hmin, and

introduce a parameter H:

H = Radius + Hmin

All parameters should be Instance Length parameters.

2. With the Pythagorean Theorem translated to Revit Formulas, with

our parameter naming, we get something like this for the parameter

Vertical Offset 2:

Vertical Offset 2 = H - (sqrt((Radius ^ 2) - (L2 ^ 2)))



of 75

3. Apply the same formula to the other 3 Vertical Offset parameters.

After applying this to the other 3 Vertical Offset parameters, 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.



of 75



of 75

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

Surface using the Load into Project button.

4. Space Frame

1. 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.



of 75

Before proceeding we need to associate the parameters of the

component with corresponding new Mass parameters.

2. Select the Adaptive Component, click the Associate Parameter

button and create a new parameter with the same name and

properties (Instance)



of 75

Finishing the space frame is now easily by using the excellent Repeat

feature.

3. 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, some 2509 years after his death.



of 75

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

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

the slow side, and it can often 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,

making a new Adaptive Component, or using a custom Curtain Panel

pattern-based family.



of 75

We can also 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 75



of 75

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.

1. 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 opening a definition, or starting 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. For example, we can’t

interact with Window families in a Massing environment, and we can’t

place Surfaces or Reference Points in a Revit Project.

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.

1. Open the Revit Project file Dynamo.rvt. If this is not available for

some reason, start a new project using any template.

2. Start Dynamo from the Add-Ins tab.

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

component and a Watch node, wiring them like below. We use the

Search field to find the nodes, and press Enter or click on the nodes

to add them to the definition.



of 75

4. 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.

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.

5. We can add another XYZ node;



of 75

6. One Number node;

7. 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.

8. Now we add an XYZ Distance node to calculate the distances

between each point in the grid and the single point.



of 75

9. 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.

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

Sliders will control different aspects of the offset and amplitude of

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.

11. Now we can connect everything again by introducing another XYZ

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

Use Ctrl+G on the keyboard to navigate in the Background Preview.



of 75



of 75

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

Lines Through Points node from the XYZ output.

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.

13. Let’s do this by pulling out a Transpose List node and wire it to the

XYZ output.

14. We finalize the grid by adding another Lines Through Points node to

the transposed list of points.



of 75

The Lines Through Points nodes generate linear line segments between

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

connecting the Hermite or Nurbs 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 75

2. 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.

1. Make sure you have the surface in the sample file Dynamo.rvt. In

case not, model a new surface using Conceptual Modeling.

2. 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 75

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.

3. We can do this by adding the Get Surface Domain, UV Grid and

Evaluate Surface nodes, in addition a Number node for U and V

direction counts.



of 75

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.

4. 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 75

5. We continue by adding the partitioned list to the Transpose Lists

node that creates one set of the grid lines and directly into another

Lines Through Points or Hermite Spline node.

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.

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

midpoint between a set of XYZs.

7. Second we need a custom node called LunchBox Quad Grid by

Face by Nathan Miller. This node is a custom node that we

download through the Package Manager. Search for Lunchbox,

and install.



of 75

8. When installation is done, search for Lunchbox in Dynamo and pull

out the Quad Grid by Face, connecting it to our Select Face and

UV Number node.

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 75

9. 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.

10. We can use this vector by adding a Scale XYZ node, a Translate

Transform node and a Transform XYZ node.



of 75

11. 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.

12. 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.

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

XYZ coordinates of all quads and their respective offset points.



of 75

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 75

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

to 2, and so on.

14. 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 like below.



of 75

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 75

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

impression that the Structural Framing families works best with Dynamo if

they are defined without the automatic cutback feature in 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.

1. Add a Structural Framing and a Select Structural Framing Type node

to our definition, and wire the Type node to the type input of the

Structural Framing node.

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

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

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

what list data we have.

2. Add a Flatten Completely node between the Lines Through Points

output and the curves input of the Structural Framing node.



of 75

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.

3. Add a Z Axis, List Length and Repeat node.

4. Wire the flattened list of curves to List Length, Z Axis into the thing

input of Repeat and the List Length to the length input of the

Repeat node.

5. Finalize by connecting the list output of Repeat to the up input of

the Structural Framing node and, hey presto, beams!



of 75

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

Structural Framing Type and up vector.

6. 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 75

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



of 75

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 of quads, extracting its list

length and repeating the center offset points by that quantity.

7. Add a Get from List node, input the XYZ output from Nate’s Lunxbox

Quad Grid by Face node and use a Number with random value (0

below) for index.

8. Add a List Length to the Get from List output.

9. Add a Repeat node and use Transform XYZ for thing input, and List

Length for length input.

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).

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.



of 75

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.

10. Add a Line by Endpoints node, and wire it to the Transpose List node

that comes from Lunchbox and the repeated Transform XYZ points.



of 75

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.

11. Click + in the List node, and wire the Line by Endpoints (vertical

framing) to the third list input – index2.

The Structural Framing node does not always update already modeled

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

lines to the generation of beams sometimes result in this unwanted



of 75

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.

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



of 75

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.

12. Add a Partition List node, and wire the n input directly from the

original Number (UV Count) node.

13. Then get the list input from the Transform XYZ output.

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.

14. Add two Lines Through Points nodes, and wire them both to the

partitioned list – only one through a Transpose Lists node.



of 75

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

complete.

15. Click twice on + in the List node, and wire both Lines Through Points

to index3 and index4.



of 75

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

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

vertical grid offset.



of 75

3. 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 Dynamo section: Building a Grid System.

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.

16. Add (or copy) a UV Grid node along with a Number node and

Evaluate Surface node.

17. Set value 2 to the Number node, and wire it to the U- and V-count

of the UV Grid node (if it’s not already wired).

18. Wire the face output of the Select Face node to the face input of

the new Evaluate Surface node, and UVs to uv.



of 75

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

19. Add a Formula node and apply the syntax ((a+1)*(a+1))/2.

This will force all even number inputs to produce a center point.

20. Use a Get from List node and wire it to the Formula node and the

XYZs of the evaluated surface.



of 75

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

created in the first sections.

21. We delete the two Number Sliders to the left, the Number and XYZ

components, and wire the XYZ Distance to the Best Fit Plane origin.

22. 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.



of 75

23. 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 75



of 75

4. 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.

1. 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



of 75

Hosted Area Loads sadly, as that require planar Structural Floor

elements, something we do not have here.

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 delete loads will update.

2. Boundary Conditions can also be added quick and easy.



of 75

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 75

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 75

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

Revit Internal Point Loads at supports.



of 75

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 75

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 75

Material for Further Research and Development

5. 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 75

6. 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.

7. 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 hvasshaug@gmail€¦ · Håvard Vasshaug, Dark Page 9 of 75 Finally, let’s...

Documents

Transcript of Håvard Vasshaug, Dark hvasshaug@gmail€¦ · Håvard Vasshaug, Dark Page 9 of 75 Finally, let’s...