Vous êtes sur la page 1sur 58

Session 3

The Dark Arts of Revit: Conceptual Modeling


Tools and Computational Logic in Structural
Design
Hvard Vasshaug, Dark
hvasshaug@gmail.com

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. Lets succumb to the Dark Arts of Revit
About the Speaker
Hvard 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.
Hvard 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
Hvard Vasshaug, Dark

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

Page 2 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 3 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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. Well save all the theory for another time, but before we start our
structural exercise, lets 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 lets see how this all works in a Structural Space Frame exercise.

Page 4 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 5 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 6 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Finally, lets 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.

Page 7 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 8 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 9 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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. Its important
that while placing the Reference Point, Draw on Face is active. If not, the
point wont 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

Page 10 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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 well use the Pythagorean Theorem to obtain a sphere-like
bottom frame layout.

Page 11 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Translated to Revit Formulas, we get something like this:

Page 12 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Notice that weve 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 its 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.

Page 13 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 14 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 15 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 16 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Page 17 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 18 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 19 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 20 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 21 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Page 22 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 23 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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 lets see what we can make of this in Revit.

Page 24 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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. Lets have a look at how
that works.

Surfaces
When talking about Revit, Dynamo and surfaces its 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 thats 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.

Page 25 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 26 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 27 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 28 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 29 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 30 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 31 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 32 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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 cant
be exported to analytical software. (This is actually only partly true, as
well 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.

Page 33 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 34 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 35 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Page 36 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 37 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 38 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 39 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 40 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 41 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 42 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 43 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Computational Frame Attractor Thickness


With the complete Space Frame layout and the possibilities in Dynamo,
its 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.

Page 44 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 45 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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 youre not embarrassed to show
someone.

Page 46 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Page 47 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Page 48 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

Page 49 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 50 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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

Page 51 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 52 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 53 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

The Revit Extensions can also save reaction loads back to Revit as native
Revit Internal Point Loads at supports.

Page 54 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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:

Page 55 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 56 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 57 of 58
Conceptual Modeling and Computational Logic
Hvard Vasshaug, Dark

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.

Page 58 of 58