Tall building tools

User guide and worked example

October 2013
Anthony Buckley-Thorp
 Tall buildings tools

• Use ‘tall building tools’ to quickly generate 3D tall building

models in Rhino
- From Architectural Rhino files
- Import to Rhino from
- AutoCAD
- Sketch-up
• Generated Rhino geometry can be exported via Salamander
- Directly to GSA
- To ETABS via the ETABS writer in design link format
http://arupforge.intranet.arup.com/wiki/ETABS_writer

2
 Tall buildings tools

Architects Base lines and Generate Export to analysis

geometry rails objects package

3
 Getting started

• Open Rhino 5
• Launch Grasshopper 0.9 or later
• Drag and drop ‘Frame_tool.gha’ and ‘gHowl_r50.gha’ into the
open Grasshopper window to install
• Load ‘Main_builder_vXX_release.gh’ Grasshopper file
• Load ‘Example model.3dm’ Rhino file
• In the open Grasshopper window set the file location of the Excel
data file ‘Model_data.xlsx’ (see next slide)
• *Note* Above files can be downloaded from
http://arupforge.intranet.arup.com/wiki/TallBuildingTools

4
 Getting started

5
 Set level data

• Specify the major floor levels and names in the Excel spread sheet
• These levels will define the planes by which the building will be sliced up
• *Advanced* Inclined planes are possible – create a dummy floor in the Excel
sheet and then specify the inclined plane in the Grasshopper file
• Level data should be specified in meters above any datum

6
 Load in base geometry

• In this example the Architects

geometry has been loaded in
from an AutoCAD plan and
elevation

• Many other ways are possible –

the important thing is to be able
to trace the base ‘rail lines’

• The red labels have been

generated from the Excel
specified levels – be sure that the
imported files are positioned
accurately at the correct level

7
 Create the base ‘rails’ of the tower geometry

• Rails are the curves along which

the frame and core will be built

• Rails do not need to be straight

and can jump from position to
position by joining curves

• Rails should never cross the same

‘z’ plane more than once

• Rails are essentially

- The column centrelines
- The core wall edges/vertices

Column rails Core wall rails

8
 Create the base ‘rails’ of the tower geometry

• Rails can be constructed by

whatever means you prefer

• In this example, the core has

been traced over and vertical
lines positioned at core wall
ends, corners and intersections

• The rail lines should extend for

as long as you want to draw the
core or column elements

9
 Create the base ‘rails’ of the tower geometry

• Use cutting plans and the ‘trim’

command to have your rails
terminate at the desired levels

• Note: Here we refer to ‘vertex’ or

‘vertices’ lines or rails. Although a
vertex is a specific point, the lines
and rails represent that point when
viewed on the 2D plan across a
range of z-values (heights). Either
way it can simply be thought of as a
edge or a join in any one or more
walls.

10
 The components

• Two custom components are available in the

‘Ants Tools’ tab

• The build frame component works with just

the floor planes and column centrelines as
inputs

• The build core requires an extra Boolean list

input that tells it whether any given width of
wall should be solid or a link beam

• These components can be used ‘as is’ or in a

pre-built Grasshopper assembly that provides
some added functionality (see next slide)

11
 The assembly
• The provided assembly is provided
to assist in the data handling issues
that usually occur with large
models

• Grasshopper does not allow for

easy structuring of data arrays.
Much of this assembly is simply
forcing the data sets to be stored in
a way that the components can
handle on a large scale

• The assembly also allows for the

generation of slab elements
although it has some minor bugs
and as such has not yet been coded
and compiled into a standalone
component

12
 Generate the frame of the building

• With the column rails visible in

the Rhino window, right clink on
the Grasshopper ‘frame cols 1’
and set a number of column
curves in order

• The curves should be selected in

the order by which you want to
build the frame

• Even if you have columns shorter

than others you should still select
them in order

13
 Generate the frame of the building

• Selecting the column lines in

order is important for the logic of
1
the frame builder

• Note line 8 is shorter than lines 7

and 9. This is not a problem but it
should still be selected in order

• If building a closed frame the

first curve selected needs to be 2
10
duplicated. (Rhino does not allow
addition of the same element
twice to a manually selected list
3 4 5
of curves) 6 7 8
9

14
 Generate the frame of the building
• The table shows the computed logic
inside the grasshopper frame component

• If the given curve intersects a floor

plane it creates an intersection event (I-
E) with associated x, y and z coordinate

• If the curve stops short, as is the case 6 7 8 9 10

with curve 8, it stores a null value in the
matrix L35 I-E I-E Null I-E I-E

• By forcing this structured approach L34 I-E I-E Null I-E I-E
rather than the natural Grasshopper tree
L33 I-E I-E Null I-E I-E
structure, the component can now
extend beams across missing L32 I-E I-E I-E I-E I-E
intersection events
L31 I-E I-E I-E I-E I-E

15
 Generate the frame of the building

• The resulting beams and columns are

stored in the outputs ready for baking

• The lines generated are all linear and

node-to-node making them suitable
for export direct into structural
analysis programs

• For example, the red structure shown

right jumps floor to floor, deviating
from the true architectural kink in the
yellow rail curve

• If it is necessary to model this kink,

create a floor plane at its level and
the kink will be picked up

16
 Generate the core walls of the building

• With the core vertex rails visible in

the Rhino window, right clink on
the Grasshopper ‘core vertices 1’
and set a number of core vertices
in order

• The vertices (curves) should be

selected in the order by which you
want to build the wall

• Even if you have vertices shorter

than others you can still select
them in order

17
 Generate the core walls of the building

• Selecting the core vertex lines in 1 2

order is important for the logic of
the frame builder

• Note line 11 is shorter than lines

10. The core builder component 16
will construct to the correct
height automatically

• If building a closed section of

core the first vertex selected
needs to be duplicated. (Rhino 10
does not allow addition of the
11
same element twice to a
manually selected list of curves) 13

18
 Generate the core walls of the building

• As 16 vertices have been 16 selected

selected, there exists 15 infill
vertices
zones which are to be either a
wall element or a link beam

• In the Grasshopper assembly, the

panel below where the curve list
is stored is automatically updated
15 Boolean
to show 15 Boolean toggles
representing those infill zones
toggles generated
(note the numbering goes
from 0 to 14 = 15 total)

19
 Generate the core walls of the building

• If a toggle is set to ‘zero’,

a solid wall panel is
drawn

• If a toggle is set to ‘one’,

a link beam is generated
and the wall panel
omitted

• Note: If the graphic view does

not automatically update, simply
toggle one of the Boolean inputs
to force an update

20
 Repeat for the whole building

1 2 3 4 5 6 7 8 9
• The Grasshopper
assembly allows for up
to 9 concurrent
collections of vertices
or column centrelines
to be managed at the
same time

• Alternatively items can

just be baked one by
one

• Disable those inputs

not in use to avoid
errors
1 2 3 4 5 6 7 8 9

21
 Baking the results

• The outputs allow

for the baking of
all items or just
the beams or
columns

22
 Floor plates builder (use with care)
2 1

• Floor plates can also be automatically

generated by selecting either 3 or 4
column curves or core vertex
lines/rails 3
• They can only be built in one 4
location at a time but are generated
over all similar floors automatically

• Take care to build the floor slabs in a

way suitable for your chosen analysis
package. Here is better suited to
ETABS as ETABS will mesh along
wall lines automatically whereas
GSA will not

23
 Floor plates builder (use with care)

• The floor plate builder takes advantage of the ‘frame’

component but it still a little temperamental when
dealing with data validation

• There are also data spill over issues when processing

multiple floor panels in batch so be careful

• Depending on the order in which you select the lines

the 2D element may be orientated upside down. This
can be fixed with the ‘flip’ command but should be
checked manually

• These are all to be addressed automatically in the

future floor plate component currently under
development

24
 Floor plates builder (use with care)
• The next floor panel would be
constructed as shown:

2 1

25
 Baking the results
• Including floor plates the baked results should look like so:

• For this instance the automatically generated structure

represents over 95% of the structure

• Some localised items such as the belt trusses and outriggers

are still built manually at the end

• Model turnaround time is still dramatically reduced

• The approach is noted to be only semi-parametric due to the

one-way baking step

• However, the tool is intended to generate quick throw-away

models for comparative studies or early stage design work

• For a range of varying geometries it can greatly speed up the

time taken to build FEA friendly geometry from a range of
input sources

26
 Convert to Salamander elements for export
• The baked and manually drawn objects
are a collection of Rhino geometry
objects

• In order to export this via Design Link

to GSA or ETABS the geometry must
be converted to nodes and elements

• Simply select all the baked objects and

click ‘Generate Structure from
Objects’ button in the ‘Add Structure’
pop out menu

• Be sure to run the design doctor after

this step to check for any errors

27
 Export to chosen analysis package
• With the Salamander geometry objects selected
the model can now be exported by clicking the
save button on the Salamander toolbar

• To export to GSA, click the GSA button

(obviously…)

• To export to ETABS click the DesignLink button

• For ETABS an additional stage is required –

download and run the ETABS writer and run the
DesignLink file through it for conversion
- Download and user instructions can be found here:
http://arupforge.intranet.arup.com/wiki/ETABS_writer
- The resulting e2k file can be opened by first creating a blank
ETABS session and importing it using the inbuilt functions

28
 Finish

Architects Base lines and Generate Export to analysis

geometry rails objects package

29
 User notes
• The frame and core tools cannot deal with centreline crossovers

• However, structures such as dia-grids can still be built – simply set up the column
centrelines as shown below

Red and blue lines Red and blue lines do

cross – not OK not cross – OK
30
 User notes

• Core vertex lines that stop short are

detected and wall heights built
accordingly (blue lines)

• However, lone vertex lines will not

result in wall elements being
constructed (red lines)

31
 User notes
• The components allow for column and
core rails to start and stop over any
chosen range of floors

• The image below shows where lines stop

and nodes are created – this is a key
feature of these components making the
outputs useful for structural analysis
programs

32
 User notes
• It is common in tall buildings for sections of the core to drop off at high levels

• The floor plate builder can still deal with these cases by having a sudden kink in the
particular core rail as shown dotted in orange:

33
 Future development
• Future items for development:
- Formalise the floor plate builder, add in data validation checks and compile
into a standalone component
- Internalise the data management component assemblies so that the user can
feed in an unlimited set of input sets and speed up the Rhino interface
response
- Allocate element sizes through building in Salamander functions to the
component assemblies
- Automatically run the Salamander design doctor and delete zero length
elements and coincident nodes

• Suggestions and bug reporting:

- Please send an e-mail to: anthony.buckley-thorp@arup.com
- Any other feedback welcome (including project applications!)

34