SPACE COLONIZATION BRANCHING STRUCTURES:

SIMULATION AND STRUCTURAL ANALYSIS

Pavel Furtsev [15399078]

Hochschule Ostwestfalen-Lippe - University of applied sciences

FB1 Detmolder Schule für Architektur und Innenarchitektur

S7 Programming & Simulation

C2 Construction & Dimensioning

Prof. Dipl.-Ing. Jens-Uwe Schulz

M. Eng. Arjun Sharma

2018
INDEX

I.INTRODUCTION............................................... 2
II. SPACE COLONIZATION ALGORITHM ........................... 4
1. Logic ................................................... 4
2. Algorithm simulation .................................... 6
2.1. Input geometry ..................................... 6
2.2. SCA Python script .................................. 7
2.3. Output processing ................................. 10
3. Results ................................................ 11
4. Geometry of the case study project .................... 12
III. Structural analysis and dimensioning ................. 13
1. Test example ........................................... 14
1.1. Hand calculations .................................. 15
1.2. Karamba ........................................... 15
1.3. Conclusion ........................................ 18
2. Case study ............................................ 18
2.1. Standard Karamba analysis .......................... 22
2.2. Karamba analysis with cross section optimization ... 22
2.3. Results Comparison, Conclusion ..................... 25
Reference ................................................. 26

1
 I.INTRODUCTION

Branching structures are based on geometric systems that

expand through bifurcation without returning to form closed
cells [1]. This geometry mimics some natural systems like
trees and vascular systems. There are several examples of work
and research done in architecture that were inspired by this
geometry (Fig.1., Fig.2., Fig.3.).

Fig. 1. Stuttgart Airport

Terminal, Stuttgart, by Von
Gerkan, Marg+Partner, 1991.

Fig. 2. A ‘tree’-supported
canopy at the main entrance.
Palaice de Justice, Melun,
France, Jourda and Perraudin
Architects, 1992.

2
 Fig. 3. Frei Otto's hanging
models of branching systems.

Frei Otto used branching systems as an inspiration for form

finding methods to design lightweight structures.
The above-mentioned examples use L-systems logic. However,
there are several methods and algorithms to simulate natural
branching patterns. One of them is space colonization
algorithm.
Space colonization algorithm (Further as SCA) - is a
procedural method to create branching tree like structures.
The main distinction from other methods is that it treats
competition for space as the key factor determining the
branching structure [2].
The objective of this work is to explore the geometrical and
structural properties of free form branching structure created
with space colonization algorithm:

- Create simulation of Space Colonization Algorithm and

generate the geometry in Rhino + Grasshopper parametric
software environment

- Make structural analysis and dimensioning of the system

on a case study (generative sculpture for Innovation
Campus Lemgo) comparing two methods in Karamba
parametric structural engineering tool.

3
 II. SPACE COLONIZATION ALGORITHM

1. Logic
SCA is a loop of several logic steps, which are described
further:
A - Algorithm starts with initial input of starting point and
attraction points to which the structure will grow.

Starting point
Attraction points

B – Next, we need to find the points, which are in the

influence radius of the starting point.

Influence radius

C – Further, we find the vector from starting point to

attraction points and calculate the average of those vectors.

Attraction vector
Average vector

D – Afterwards, we move the starting point with the vector and

we get a new branch point.

4
 New branch point

E – Now, we need to find attraction points, which are in the

kill radius from the branch points and delete them.

Kill radius

F – Finally, we connect the starting parent point and new

generated point to create a branch.

New branch

Final result:

The algorithm iterates through those steps from A to

F and terminates after user specified number of
iterations or when there is no attraction points
left.

2. Algorithm simulation
To implement the algorithm and generate branching structure we
are going to use Grasshopper - visual programming plugin for
Rhino 3d modeling software. We are going to use Python
scripting inside Grasshopper as well.

5
Fig. 4. Data flow and steps of the script

This diagram shows the basic data flow of the script. The
steps are described further.

2.1 Input geometry

For SCA we need attraction points and starting point as an
input.

Fig. 5. Grasshopper script #1

1. Create rectangle on the plane.

2. Slider to set dimensions of the rectangle. We use one
slider for both X and Y dimensions to create a square.
3. Populate a 2-dimansional region with random points. As
a region, we are going to use a rectangle created
previously.
4. With this slider we set the number of random points to
populate the region.
5. Area gives a center of rectangle which we are going to
use as starting point for Space Colonization algorithm.

6
 attraction points
starting point

Fig. 6. Grasshopper script #1 result

Fig. 6. shows the result of the first step. Now we have 200
attraction points and starting point in the middle.

2.2 SCA Python script

Since the SCA is a loop, it is harder to simulate it inside
the standard Grasshopper environment. That is why we are going
to use a Python scripting inside Grasshopper and implement
Rhinoscroptsintex to manipulate the geometry.

Fig. 7. Grasshopper script #2

1. Input parameters:
L = list of attraction points
Bp = base pint
maxD = maximum influence radius
minD = minimum kill distance
G = growth rate or length of the branches
I = maximum number of iterations

7
 2. Python script:
Descriptions for each step are in green color.
………………………………………………………………………
#import the Rhinoscriptsyntax library to be able to manipulate the geometry
import rhinoscriptsyntax as rs

#function to find the average vector from attraction points

def averagevector(base_point, attraction_points):
#assign an ampty list to add vectors
Vector_list = []
#iterate through attraction points
for i in attraction_points:
#create a new vector from base point and attraction point
V = rs.VectorCreate(i,base_point)
#add new vector to the list of vectors
Vector_list.append(V)
#take first vector
v1 = Vector_list[0]
#delete first vector from the list of all vectors
del Vector_list[0]
#iterate through the vectors in the list
for i in Vector_list:
#add vectors
v1 = rs.VectorAdd(v1,i)
#create a unit vector from the sum of all vectors
aV = rs.VectorUnitize(v1)
#scale a unit vector by the G factor
aV = rs.VectorScale(aV,G)
#return the scaled average vector as the result of the function
return aV

count = 0 #iteration count

Br = [] #list of branches - pairs of points
P = [] #list of branch points

#the main logical loop

while count < I:
#count the loop iterations
count = count+1
#update branch points
Bp2 = Bp
Bp = []
#Check for input errors
#G must be less than a minimum distance
if G < minD:
G = minD
print "G is too small! It should be equal or bigger than minimum
distance"

#minimum distance must be less then maximum distance

if minD >= maxD:
print "minD should be less than maxD"
break

#take branch point as new base point

for b in Bp2:
L2 = L #copy list of attraction points to modify original
L = []

8
 IP = [] #list of interaction points
#put first base point in the list of all branch points
if len(P) == 0:
P.append(b)

#sort attraction points to find attraction points in the range

for p in L2:
#find the distance between the base point and attraction point
D = rs.Distance(p,b)
if D > minD:
#update list to eliminate too close points
L.append(p)
#add attraction point
if D < maxD:
if P[rs.PointArrayClosestPoint(P, p)] == b:
IP.append(p)

#create new branch point

if len(IP) > 0:
#find average vector AV
AV = averagevector(b, IP)
#create new branch point
newBp = b+AV
#check if point is not yet in the list
if newBp not in P:
#add points to the list
Bp.append(b)
Bp.append(newBp)
#add to the list of all branch points
P.append(newBp)
#add branch to the list of branches
Br.append(b) #parent point
Br.append(newBp) #generated point

#stop loop if no branch points left

if len(Bp)== 0:
print "break"
print count, "- iterations done"
break
#print the number of iterations after breaking the loop
if count == I:
print count, "- iterations done"

………………………………………………………………………
As a result of the script we get a flat list of point pairs
which are processed further to create each branch.

9
2.3 Output processing

Fig. 8. Grasshopper script #3

1. Output of python script:

out = error messages and number of iterations
P = list of branch points
Br = flat list of pairs of points to create branches
2. Partition list:
Partitions a flat list in to sub-lists with two points in
each.
3. Polyline:
Connect to points to create line.

10
3. Results
As a result, we get a list of lines, which create a branching
geometry.

Fig. 9. Grasshopper script #3 result

It is possible to use the same script for 3 dimansional

branching structures. In this case attraction points have to
populate a 3-D spase.

Fig. 10. Grasshopper script #3 result in 3d

11
4. Geometry of the case study project
Case study is a generative sculpture project for Innovation
Campus in Lemgo. It is located in the middle of the
roundabout. Figure 11 shows form finding of the boundary shape
of the sculpture. To reduce complexity we divide the shape in
three pieces and use only one of those for further structural
analysis.

Step - 1 Step - 2 Step - 3

Step – 4 Step – 5 Step – 6

Fig. 11. Form finding process

Settings used for Python script:

Number of attraction points = 1000
maxD = 1m
minD = 0.4m
G = 0.4m
I = 100

12
 III. Structural analysis and dimensioning

This part of the paper is dedicated to a structural analysis

and cross section dimensioning of a branching structure on the
case study of a sculpture for Innovation Campus Lemgo.
Since the structure resembles a tree like branching system, we
could have a look at the structural behavior of trees and make
a comparison. Trees are exposed to internal and external
loads. Wind load is the main external force that trees
withstand and its self-weight is internal load. Trees manage
to configure its shape and size of branches according to the
bending moments from the wind and axial compression from its
own weight. While growing, trees optimize their shape to
follow these structural demands [3].

Fig. 12. Figure 3. (a)

Schematic wind forces acting
on the initial shape of the
tree; (b) schematic gravity
forces acting on a deformed
shape; (c) basal and internal
bending moments in each
element [4]

To perform the structural analysis on our case study we, as

well, have to consider internal and external loads. Same like
the tree structures we encounter with wind loads, self-weight
loads but also utilization loads. Therefore, load case #1
would be distributed force in horizontal direction for wind
and distributed force in vertical direction for utilization.
Load case #2 is the self-weight load.
A tree structure can be approximated as a collection of
connected cantilever beams, which is a projecting beam fixed
only at one end [5]. Therefore, we are going to use same
methods as for cantilevered beams.
For branch cross section we are using circular hollow cross-
section. To decide the cross-section dimensions we will use
cross section optimization in Karamba.

13
1. Test example
To make sure that all settings and units are correct in
Karamba we will make a test example by comparing hand
calculations with Karamba results.

Fig. 13. Cantilever beam [6] (L = 0.4

m)

Loads:
1. Self-weight load (w1) = A*p = 0.000587*78.5 = 0.046
kN/m
(where V is a volume of the beam, p is a material
density)

2. Uniformly distributed load (w2) = 1 kN/m

3. Total load (W) = w1+w2 = 0.046+1 = 0.01046 kN/cm

Cross section:

Fig. 14. Circular hollow cross section [6]

(ri = 1.62 cm, ro = 2.12 cm)

A = 𝜋(ro2 – ri2) = 5.87 cm2 = 0.000587 m2

I = 𝜋(𝑟o4 – ri4)/4 = 10.45 cm4

14
Material properties of structural steel:
1. Yield strength = 35.5 kN/cm2
2. Young’s modulus (E) = 20000 kN/cm2
3. Material density (p) = 78.5 kN/m3
4. Shear modulus = 7930 kN/cm2
5. Linear thermal expansion = 0.000012 1/Co

1.1. Hand calculations

Maximum deflection:

. ∗
δ = = = 0.016015cm = 0.00016 m
∗ ∗ .

0.01046 ∗ 2560000
8 ∗ 20000 ∗ 10.45
Max shear:

𝑉 = 𝑤𝐿 = 0.01046*40 = 0.4184 kN

Max moment:

0.01046∗1600
𝑀 = − = − 2
= -8.368 kNcm = -0.0836
kNm

1.2. Karamba
Step 1: Geometry setup

Fig. 15. Grasshopper script #4

1. Amplitude or length of
the line
2. Initial point
3. Movement vector
4. Move point
5. Line from points

15
Step 2: Karamba setup

Fig. 16. Grasshopper script #5

1. Create a beam element from line

2. Create support from a point
3. Self-weight load
4. 1kN uniformly distributed load
5. Circular hollow cross section setup (Diameter = 4.24cm,
Thickness = 0.5cm)
6. Structural steel material setup (Young’s modulus =
20000kN/cm2, Shear modulus = 7930kN/cm2, Specific weight =
78.5kN/m3, Coefficient of thermal expansion = 0.000012
1/C0, Yield strength = 35.5kN/cm2)
7. Assemble model - Creates a finite element model from
given entities

16
Step 3: Karamba results

Fig. 17. Grasshopper script #6

1. Assemble model - Creates a finite element model from

given entities
2. Calculates the deflections of a given model using first
order theory for small deflections.
3. Deflection in meters
4. Model View - Lets you inspect the current state of the
model.
5. Returns reaction forces and moments at supports
6. Reaction forces in kN
7. Reaction moments in kNm
8. Beam view - Lets you set the display properties of beams
and trusses.
The results of Karamba script calculation are:
1. Maximum deflection: 0.000163 m
2. Max shear: 0.418447 kN
3. Max moment: -0.083689 kNm

1.3. Conclusion
If we compare the result of hand calculation and Karamba
analysis results are identical. Which means that units and
setting are valid to use for further calculations.

17
2. Case study
2.1. Standard Karamba analysis
Geometry and support:

Fig. 18. Grasshopper script #7

1. Input 139 branches as lines

2. Start point as support point
3. Karamba beam element
4. Karamba support
Loads:

Fig. 19. Grasshopper script #8

1. Dead load or self-weight load

2. Wind load in Y direction as uniformly distributed load -
0.3kN
3. Utilization load – 2kN

18
Cross section:

Fig. 20. Grasshopper script #9

1. Cross section diameters from catalog [7]

2. Cross section thickness from catalog [7]
3. Divide by 10 to convert units from mm to cm
4. Karamba circular hollow cross section
5. Choose cross section from the list (O-Profile:
height:35.56[cm] thick:2.5[cm] eccent:local(0/0/0)[cm])

Material:

Fig. 21. Grasshopper script #10

Material is a structural steel S355:

1. Yield strength = 36 kN/cm2
2. Young’s modulus (E) = 21000 kN/cm2 =
3. Material density (p) = 78.5 kN/m3
4. Shear modulus = 8076 kN/cm2
5. Linear thermal expansion = 0.000012 1/Co

19
Solution and results:

Fig. 22. Grasshopper script #11

1. Karamba model assemble

2. Karamba analyses to calculate deflection
3. Model View
4. Beam View
5. Reaction forces
6. Multiplication by 1000 to convert m to mm
7. Deflection result = 12.845556 mm
8. Reaction forces = {1.8755e-10, -16.68, 224.527988}
9. Reaction moments = {177.076043, -16.495754, -1.225456}

Fig. 23. Beam View – Displacement

20
Fig. 24. Beam View – Utilization

2.2. Karamba analysis with cross section optimization

Geometry, support, loads, material properties are all
identical to the previous standard Karamba analysis.
Cross sections setup:

Fig. 25. Grasshopper script #12

1. Diameters of cross section from catalog [7]

2. Thickness of cross section from catalog [7]
3. Divide by 10 to convert from mm to cm
4. Karamba circular hollow cross section

21
Model assembly:

Fig. 26. Grasshopper script #13

1. Karamba model assemble

2. Selects optimal cross section for a beam from a list of
cross sections
3. Maximum allowed displacement for reference
4. List of cross sections

Analysis and results:

Fig. 27. Grasshopper script #14

1. Karamba analyses to calculate deflection

2. Multiplication by 1000 to convert m to mm
3. Model View
4. Reaction forces
5. Beam View
6. Disassemble model to get cross section data
7. Deflection result = 6.886413 mm
8. Reaction forces = {7.7476e-12, -16.68, 144.344262}
9. Reaction moments = {131.314154, -7.726343, -1.225456}
10. List of chosen cross sections and reference to the beams
(38 cross sections chosen).

22
Fig. 28. Beam View – Displacement

Fig. 26. Beam View – Utilization

23
2.3. Results Comparison, Conclusion
Standart Karamba Karamba cross section
analysis optimization
Deflection [mm] 12.845556 6.886413
Reaction force X
[kN] 1.88E-10 7.75E-12
Reaction force Y
[kN] -16.68 -16.68
Reaction force Z
[kN] 224.527988 144.344262
Reaction moment X
[kN] 177.076043 131.314154
Reaction moment Y
[kN] -16.495754 -7.726343
Reaction moment Z
[kN] -1.225456 -1.225456
Mass [kg] 11332 3359

Table 1. Comparison of standard Karamba and Karamba cross section

optimization analysis.

After comparison we can see that cross section optimization

gives almost two times better results in all reaction forces,
moments and deflection.
In general the structure is buildable and works as a self-
standing structure, but has quite big reaction forces in z
axis and reaction moments in y axis. Considering this the
structure has to have strong fundament.

24
References
1. A GEOMETRIC COMPARISON OF BRANCHING STRUCTURES IN TENSION
AND COMPRESSION VERSUS MINIMAL PATHS, Peter VON BUELOW,
University of Michigan
2. PROCEDURAL GENERATION OF IMAGINATIVE TREES USING A SPACE
COLONIZATION ALGORITHM, Lina Juuso, Malardalen
University, Vasteras, Sweden
3. TREE-INSPIRED DENDRIFORMS AND FRACTAL-LIKE BRANCHING
STRUCTURES IN ARCHITECTURE: A BRIEF HISTORICAL OVERVIEW,
Iasef Md Riann, Mario Sassone, Department of Architecture
and Design (DAD), Politecnico di Torino, Viale Pier
Andrea Mattioli – 39, Turin 10125, Italy
4. P. Ancelin, B. Courbaud, T. Fourcaud, Development of an
individual tree-based mechanical model to predict wind
damage within forest stands, For. Ecol. Manag., 203 (1)
(2004), pp. 101-121
5. Web Link: https://en.wikipedia.org/wiki/Beam_(structure)
(April 2018)
6. Web Link: https://mechanicalc.com/reference/beam-analysis
(April 2018)
7. NATIONAL TUBE STOCKHOLDERS structural products (Web Link:
http://www.nationaltube.co.uk/wp-
content/uploads/2014/08/NTS_Structural_Brochure_Online_Ve
rsion.pdf (April 2018))

Software:
1. Rhinoceros - Version 5 SR12 64-bit(5.12.50810.13095,
08/10/2015)
2. Grasshopper – Version August-27, 2014, Build 0.9.0076
3. Karamba – 1.2.2, Build 161020

25