Grammatical Design with Graphic Statics:
Rule-based Generation of Diverse Equilibrium Structures
by
RCHIVES JET
Juney Lee
MASSACH USETTS INSTITUJTE
OFT[ ECHNOLOLGY
JUL
B.A. in Architecture, DepartmentofArchitecture
University of California,Berkeley, 2007
02 2015
LI B RARIES
Master of Architecture, DepartmentofArchitecture
MassachusettsInstitute of Technology, 2014
Submitted to the Department of Civil and Environmental Engineering
in Partial Fulfillment of the Requirements for the Degree of
Master of Engineering in Civil and Environmental Engineering
at the
Massachusetts Institute of Technology
June 2015
C 2015 Juney Lee. All rights reserved.
The author hereby grants to MITpermission to reproduceand to distributepublicly paperand electronic
copies of this thesis document in whole or in part in any medium now known or hereafter created.
Signature of Author:
Signature redacted
De
Certified by:
vironmental Engineering
May 21st, 2015
Signature redacted
Caitlin T. Mueller
Assistant Professor of Architecture
Thesis Supervisor
Accepted by:
_________Signature redacted
_
r1
I
Hidi Nepf
Donald and Martha Harleman Professor of Civil and Environmental En'neering
Chair, Departmental Committee for Graduate Students
S~tT
M ITUibra.es
77 Massachusetts Avenue
Cambridge, MA 02139
http://Ilibraries.mit.edu/ask
DISCLAIMER NOTICE
Due to the condition of the original material, there are unavoidable
flaws in this reproduction. We have made every effort possible to
provide you with the best copy available.
Thank you.
The images contained in this document are of the
best quality available.
Thesis contains faint color & grayscale images that
are illegible.
c4
Thesis Committee
Caitlin T. Muetler
Assistant Professor of Architecture
Department of Architecture
Massachusetts Institute of Technology
Thesis Supervisor
Corentin Fivet
Post-doctoral Fellow
Department of Architecture
Massachusetts Institute of Technology
Thesis Reader
3
4
Grammatical Design with Graphic Statics:
Rule-based Generation of Diverse Equilibrium Structures
by
Juney Lee
Submitted to the Department of Civil and Environmental Engineering
on May 21, 2015 in Partial Fulfillment of the Requirements
for the Degree of Master of Engineering in Civil and Environmental Engineering
Abstract
During early stages of design, an architect tries to control space by "finding a form" among countless possible forms,
while an engineer tries to control forces by "form-finding" an optimized solution of that particular form. Most
commonly used parametric tools in architectural design provide the user with extensive geometric freedom in absence
of performance, while engineering analysis software mandates pre-determined forms before it can perform any
numerical analysis. This trial-and-error process is not only time intensive, but it also prohibits exploration beyond the
design space filled with already known, conventional solutions. There is a need for new design methods that combine
form generation with structural performance.
This thesis addresses this need, by proposing a grammar-based structural design methodology using graphic statics.
By combining shape grammars with graphic statics, the generative (architectural) and the analytical (engineering)
procedures are seamlessly integrated into a simultaneous design process. Instead of manipulating forms with multiple
variables as one would in the conventional parametric design paradigm, this approach defines rules of allowable
geometric generations and transformations. Computationally automated random generator is used to iteratively apply
various rules to generate unexpected, interesting and yet structural feasible designs. Because graphic statics is used to
embed structural logic and behavior into the rules, the resulting structures are always guaranteed to be in equilibrium,
and do not need any further numerical analysis. The effectiveness of this new methodology will be demonstrated
through design tests of a variety of discrete, planar structures.
Grammatical Design with Graphic Statics (GDGS) contributes new ways of controlling both form and forces during
early stages of design, by enabling the designer to: 1) rapidly generate unique, yet functional structures that fall outside
of the expected solution space, 2) explore various design spaces unbiasedly, and 3) customize the combination of
grammar rules or design objectives for unique formulation of the problem. Design tests presented in this thesis will
show the powerful new potential of combining computational graphic statics with shape grammars, and demonstrate
the possibility for richer and broader design spaces with much more trial, and less error.
Key words: grammaticaldesign, graphicstatics, shape grammars, structuralgrammars, conceptualstructuraldesign,
structuraloptimization
Thesis supervisor: Caitlin T. Mueller
Title: Assistant Professor of Building Technology
5
6
Acknowledgements
This thesis would not have been possible without the guidance, enthusiasm and brilliance of my thesis advisor,
Assistant Professor Caitlin Mueller. Our similar background and interests allowed our weekly meetings to become not
just insightful and productive, but fun. Her feedback, open-mindedness and technical expertise were all essential for
completing this research. It was truly an honor and a privilege to have been one of her students. I look forward to
many more collaborations in the future.
I am grateful to have crossed paths with my thesis reader, Corentin Fivet at MIT this year. He introduced me to the
world of graphic statics, and inspired me to believe in the incredible potential of combining graphic statics with
contemporary computational design tools. His enthusiasm, passion and most importantly, his availability, have been
an invaluable asset. I hope to keep our friendship growing, and continue to expand the graphic statics revival
movement together.
I would like to thank Professor John Ochsendorf, who has been a constant source of guidance and inspiration for the
past five years. I met Professor Ochsendorf at the Department of Architecture open house in 2010, and he has always
been the biggest supporter of my dual architectural design and structural engineering aspirations ever since. My sincere
thanks to Professor Ochsendorf for guiding me as a mentor and a thesis reader through my Master of Architecture
phase in Course 4, and eventually encouraging me to pursue Master of Engineering degree in Course 1.
I am deeply indebted to both MIT's Department of Architecture and Department of Civil and Environmental
Engineering, for all the amazing opportunities and challenges over the past five years. It has been a truly humbling
experience that has helped me grow as a student, designer and a person. I am honored to have received the Marvin E.
Goody Award from the Department of Architecture in December, 2014, for which the potential of the research
presented in this thesis was recognized. Because of this award, I will have the opportunity to present this thesis at the
2015 Annual Conference of International Association for Shell and Spatial Structures (IASS) in Amsterdam,
Netherlands (Lee, et al., 2015).
Last, but certainly not least, I would like to thank my parents, my sister, Dahmi Lee, and my wife, Seung-Jin Ham,
for their unconditional love and support for me and my academic endeavors.
7
8
Table of Contents
I - Introduction
11
1 Problem Statem ent ......................................................................................................................... 13
1. 1 D isparity in Design Tools: Architecture vs Engineering ........................................................................................... 13
1.2
Lack of D iversity in Structural Form s ....................................................................................................................... 14
1.3
Research Objective ................................................................................................................................................... 14
2 Literature Review ............................................................................................................................ 15
2.1 Current tools in Structural Design ............................................................................................................................. 15
2. 1.1 Analytical: One input, One output ............................................................................................................................................ 15
2.1.2 Optimization: Parameter-based Design Space ......................................................................................................................... 15
2.2 Gram m atical Design ................................................................................................................................................. 16
2 .2 .1 S h ap e G ram mars ....................................................................................................................................................................... 16
2.2.2 Functional Grammars ............................................................................................................................................................... 18
2.2.3 Structural Grammars ................................................................................................................................................................. 18
2.3
Graphic Statics .......................................................................................................................................................... 19
2 .3 .1 Back g rou n d ............................................................................................................................................................................... 19
2.3.2 Computational Graphic Statics ................................................................................................................................................. 20
2.4 Sum m ary ................................................................................................................................................................... 23
11
Grammatical Design with Graphic Statics (GDGS)
25
3 M ethodology .................................................................................................................................... 27
3.1
Introduction ............................................................................................................................................................... 27
3 .1.1 D e fin itio n s ................................................................................................................................................................................. 2 7
3 .1.2 A ssu mptio n s .............................................................................................................................................................................. 2 8
3.1.3 Basic Conventions .................................................................................................................................................................... 28
3.1.4 Concept 1: TempForces ............................................................................................................................................................ 29
3.1.5 Concept 2: Graphic Statics based Rules ................................................................................................................................... 30
3.1.6 Concept 3: Randomness ............................................................................................................................................................ 31
3 .1 .7 C o n stra in ts ................................................................................................................................................................................ 3 1
3.2 Overview ................................................................................................................................................................... 32
3.2.1 Conceptual Overview ............................................................................................................................................................... 32
3.2.2 Computational Setup and W orkflow ........................................................................................................................................ 32
3 .2 .3 U ser Interface ............................................................................................................................................................................ 3 3
3.3
GDG S M odel ............................................................................................................................................................ 35
3 .3 .1 S etu p .......................................................................................................................................................................................... 3 5
3 .3 .2 M ain E lem ents .......................................................................................................................................................................... 35
3 .3 .3 Ru les .......................................................................................................................................................................................... 3 6
3.3.4 Grammar: Automatic Random Generation .............................................................................................................................. 40
3.3.5 Design Generation .................................................................................................................................................................... 42
4 Results ............................................................................................................................................. 44
4.1 Im plem entation ......................................................................................................................................................... 44
4 .1.1 E v aluatio n M etric ...................................................................................................................................................................... 4 4
4 .1.2 S o rtin g Resu lts .......................................................................................................................................................................... 44
4.2 Design Tests .............................................................................................................................................................. 45
4 .2 .1 P ro b lem 1: S pan ........................................................................................................................................................................ 4 5
4.2.2 Problem 2: Cantilever ............................................................................................................................................................... 46
4.2.3 Problem 3: Radial Compression Structure... ............................................................................................................................ 47
4.2.4 Problem 4: Wall-like Structure ................................................................................................................................................. 48
9
4 .3
Discu ssio n . ................................................... .......................................................................................................... 49
4 .3 .1 E x p lo rin g Param eters................................................................................................................................................................4
9
4 .3 .2 P ractical Ap plication s..........................................................................................................................................................
. . 49
III - GDGS & Optimization
51
5 M ethodology....................................................................................................................................53
5 .1
G en eral......................................................................................................................................................................
5.1.1 Concept (Force Polygon Construction Problem).....................................................................................................................53
5 .1.2 O bjectiv e ... ................................................................................................................................................................................
5.1.3 Similarities to Combinatorial Optimization .............................................................................................................................
53
54
56
5 .2 O verv iew ...................................................................................................................................................................
5 .2 .1 Conceptual O verview ...............................................................................................................................................................
5 .2 .2 S tra teg y .....................................................................................................................................................................................
58
58
59
5 .3
59
59
62
62
Setu p .........................................................................................................................................................................
5 .3 .1 P arameter 1: O rdering ...............................................................................................................................................................
5.3.2 Param eter 2 : R eaction A ngle ....................................................................................................................................................
5.3.3 Formulation of the Problem using GOAT (Optimization)..................................................................................................
6 Results.............................................................................................................................................
6.1
Implementation .........................................................................................................................................................
6.2 Case
6.2.1
6.2.2
6.2.3
6.2.4
6.2.5
6.2.6
6 .3
Studies..............................................................................................................................................................
Problem 1: Symmetric Span (Variable Reactions)..................................................................................................................64
Problem 2: Asymmetric Span I (Variable Reactions...............................................................................................................66
Problem 3: Asymmetric Span 2 (Variable Reactions)........................................................................................................
Problem 4: Asymmetric Radial (Variable Reactions)..............................................................................................................70
Closing Structures 1 (Pre-determined Reactions)...................................................................................................................72
Closing Structures 2 (Pre-determined Reactions)...................................................................,...........................................
Discu ssio n .................................................................................................................................................................
IV - Conclusions
63
64
68
74
76
77
7 Conclusions .....................................................................................................................................
7.1
63
79
Contributions......................................................................................................................................
.. .....
7.1.1 More Trial, Less Error ............................................................................................................................
7.1.2 Unbiased Exploration of Diverse Design Alternatives ...............................................................
......
7.1.3 Generative Graphic Statics: Beyond Reciprocity...........................................................................................
79
79
79
80
7.2 Future W ork .....................................................................
. .....................................................
7.2.1 Controlling Local Mechanisms.........................................................................................................80
7.2.2 Force Diagram based Rules........................................................................................80
7.2.3 Limiting Overlapping members........................................................................................................81
7.2.4 Improved Constraints ........... ...............................................................................
.......................................
7.2.5 Generative Structural Grammars in 3D............................................................................................81
7.2.6 Grammar-based, Interactive Evolutionary Explorations..................................................................81
80
7.3
82
Concluding Remarks..................................
......................
...
...............................................
V - Appendices
A Scripts
81
83
...............................................................
B Additional Design Exam ples ............................................................................................................
C References ...................................
-........--.......................................................................
10
84
90
129
I *
Introduction
11
12
Problem Statement
1
1.1
Disparity in Design Tools: Architecture vs Engineering
The institutionalized separation of form (architecture), forces (structure), and material (fabrication/construction) has
resulted in a geometric-driven contemporary design culture (Oxman, 2010). During early stages of design, an architect
tries to control space by "finding a form" among countless possible forms, while an engineer tries to control forces by
"form-finding" an optimized solution of that particular form. This modem prioritization of expressive form over
material and performance is the platform upon which architecture and structural engineering remain divided as schools
in academia and as professions in practice today. The development and logic of Computer-Aided Design (CAD)
software used in academia and practice today are also based on this separation of form and forces.
Architect
Engineer
S
S
S
0
0
0
0
0
0
0
0
0
0
0
0
Figure 1.1 - The disparities in software type and usage between architects and engineers, based on the author's 10 years of
academic and professional experiences.
While the tools used by architects and engineers have made significant advancements to suit the needs of each
discipline, they have failed to address the needs of the other (Figure 1.1). In practice, digital models generated by
architects typically have to be re-modelled by an engineer in a file format that is appropriate for finite element method
(FEM) software. The disparity in digital tools inevitably result in unproductive back-and-forth exchanges between the
architect and the engineer during all phases of design. The constant, trial-and-error process is inefficient, resource
intensive and makes it difficult to inspire any truly collaborative workflow between the two disciplines which are
already divided both academically and professionally. For architects, introducing real-time performance feedback
during the modeling process can help in exploring structurally feasible and diverse designs much more efficiently,
and improve the general structural intuition of designers. For engineers, adding generative ability to tools that are
traditionally meant to only analyze an already defined structure, can potentially expand the creative capacity of the
designer and lead to undiscovered structural possibilities. In addition, the rising awareness of the environmental
liabilities of the current design paradigm, makes it necessary for the design tools to start incorporating performance.
13
1.2
Lack of Diversity in Structural Forms
The inability of architectural modeling software to process forces, and the limited generative ability of engineering
analysis software has made the discovery of new structural forms and typologies extremely difficult. The process
during early stages of conceptual structural design typically involves choosing of a typology-as opposed to
generating new one, among already known, conventional solutions. Ultimately, conventional shapes, methods and
materials are chosen over unusual solutions because they are less risky, more economical and are already established
in the industry. Most resources in structural design and engineering are invested in finding the optimum solution,
optimum in the sense that it is the fastest and the cheapest way to achieve the desired form or aesthetic. Subsequently,
the profession has limited itself from expanding the creative diversity of structural forms that can be imagined,
designed and engineered.
To illustrate the limited range of an average designer's creative repertoire of structural forms, an informal survey was
conducted (Figure 1.2) during earlier phase of the research. A diverse group of architects and engineers from both
academia and practice with varying degrees of experiences-ranging from students, professors and even practicing
architects and engineers, were asked to sketch a design for a short-span bridge that is simply supported at both ends.
All of the submitted designs could be grouped into four main categories. Not surprisingly, most sketches were
variations of typologies that are already well studied and established in the engineering community for hundreds of
years.
Arch
(5 Architects, 2 Engineers)
Truss
(4 Architects, 8 Engineers)
Tensile
(11 Architects, 6 Engineers)
Other
(4 Architects, 0 Engineers)
Figure 1.2 - Informal survey result of design of a simple spanning structure.
This informal survey shows that while the rapidly advancing capabilities of CAD and FEM have enabled architects to
generate almost any form, and engineers to analyze any structure, it has not stimulated the creative capacity of
designers to use the powerful computational tools to explore new structural forms. More appropriate and meaningful
investment of the computational power that is available to designers today, may be in investigating new structural
possibilities, rather than developing faster ways of finding optimal solutions to what may be inherently bad forms.
1.3
Research Objective
During conceptual design, designers are in need of a computational design tool that can not only generate forms, but
simultaneously process structural logic and rules, so that the outcome does not need to be constantly remodeled and
checked with FEM. In order to prevent the human designers from prematurely rejecting unconventional solutions
solely due to unfamiliarity, computational power along with controlled randomness and intelligent optimization can
be used to help the designer in unbiasedly exploring alternative solutions that are unexpected, visually interesting and
yet performatively adequate. Faster exploration of designs that are guaranteed to be statically feasible, will enable the
designers to explore a wide range of diverse and unconventional possibilities with more trial, and less error.
14
2 Literature Review
2.1
Current tools in Structural Design
2.1.1
Analytical: One input, One output
Structural engineering tools used in practice today have one of the following two primary functions: analyze a structure,
FEM is a numerical
or optimize one. Most commonly used method in digital structural analysis is powered by FEM.
"finite element,"
called
subdomains
small
many
over
equations
element
technique for connecting a series of simple
tools ultimately
FEM
2006).
Bathe,
2005;
(Reddy,
to approximate a more complex equation over a larger domain
is to inform
objective
primary
its
Because
perform one task of analyzing an input geometry provided by the designer.
tool that is
verification
a
the user how the structure is performing through numerical feedback, it is ultimately
cumbersome for modeling and exploring designs quickly.
2.1.2
Optimization: Parameter-based Design Space
algorithms
Optimization tools in structural design formulate objective functions mathematically. Optimization
That
2013).
Lewinski,
&
minimize or maximize the given objective functions to find optimal solutions (Rozvany
in
parameters
as
objective function is a product of one or multiple variables, which are more commonly known
This
numerical.
contemporary parametric design paradigm. In engineering context, these parameters are typically
problem.
given
a
to
solutions
means that the design space contains all possible
Continuum topology optimization (Bendsoe, 1995) and ground structure method-based optimization (Dom, et al.,
problem by
1964) are deterministic methods among many, used for finding a single optimal solution to a specific
tend to
always
solutions
either minimizing or maximizing the objective function. Generally, topology optimization
which
2.1,
Figure
converge to a form that resemble a Michell truss (Michell, 1904) as shown in an example in
explore
technically achieves singular optimality at the expense of diversity of possible solutions, and it is difficult to
single
a
on
converge
and
search
to
tendency
inherent
Its
any tradeoffs between multiple design objectives and criteria.
designer.
the
to
solutions
possible
solution is not only resource intensive, but also offers little diversity of
Figure 2.1 - a) Conceptual drawing of a Michell Truss geometry (Michell, 1904);
b) Continuum topology optimization with Grasshopper and Millipede. (Image source: Michalatos Panagiotis,
to Michell trusses, which
http://www.sawapan.eu). Continuum topology optimization software produces geometries similar
Michell was able to find over a hundred years ago without a computer.
15
Shape optimization and evolutionary algorithms in engineering have made significant advancements, thanks to
improvement of optimization algorithms and computational power. However, the result of these methods are highly
dependent on the initial geometry that was conceived and input to the computer by the human user. Optimization of
an inferior topology is an inefficient use of resources and not very rewarding in the long run.
Ultimately, any designs found in a parameter-based design space is a variation of one another with different values
for the same parameters. While a sophisticated optimization algorithm or technique may help the user in finding the
optimal solution within that design space, the result is still limited by the design space itself. Because of its boundedness, parameter-based design spaces are appropriate for narrowing down designs to one optimal solution during later
stages of design. However, during earlier stages of design, a parameter-based design space does not contain the wide
range of design possibilities that the designer may want to consider (Mueller, 2014).
2.2
GrammaticaL Design
2.2.1
Shape Grammars
In order to broaden the design space, and discover new and unexpected design possibilities, rule or grammar based
approach can be used in place of conventional parameter-based design paradigm. Rule-based design, or more
commonly known as shape grammars, defines a set of allowable shape transformations that can be used to generate a
language of spatial designs. Once the rules are formulated, the generation and transformation of shapes can be
automated to explore a wide range of diverse designs. The advantage of a grammar-based design space is that it
contains both known designs, from which the grammar rules were derived, and new designs with similar style (Stiny
& Gips, 1972). Since its introduction, shape grammars have been used in a variety of architectural applications to
define languages of architectural form and style (Stiny & Mitchell, 1978). Because shapes are defined by rules rather
than parameters, a grammar for shapes can result in an infinite number solutions. Stiny explores diverse design
possibilities by defining just a few rules, through many examples in his book "Shape: Talking about Seeing and Doing"
(Stiny, 2006) as shown in Figure 2.2.
Lr~"~r
Figure 2.2
-
Lattice pattern grammar (Stiny, 2006, pp. 335-336). From a set ofjust four simple rules, an infinite number of
unique solutions (as opposed to variations of a particular solution) can be generated.
16
In addition to purely geometric design problems, shape grammars have been used in a variety of architectural
applications to analyze historic design styles and types, as well as generating entirely new ones. For example, Stiny
and Mitchell (1978) demonstrated how an architectural shape grammar can be formulated, from studying a variety of
existing Palladian Villas (Figure 2.3). The grammar can then be used to generate a wide of range of plans that abide
by all design principles and spatial traits that can be found in P alladian Villas. The grammar was able to generate exact
plans of existing Palladian Villas.
d
111
L
L
77F
ee :,Cd=dl
H3iWLL
LiEE + i + iLi
I
b)
a)
Figure 2.3 - Grammar studies on plans of Palladian Villas: a) "Palladian Villa Grammars" (Stiny & Mitchell, 1978);
and b) "A New Palladian Shape Grammar" (Benr6s, et al., 2012)
Similarly, Koning and Eizenberg developed grammars for Frank Lloyd Wright prairie houses (1981). By studying
existing examples, thorough grammar rules were formulated, which could generate designs that could convincingly
have been designed by Frank Lloyd Wright himself. Shape grammar application in studies of historic architecture,
have shown how grammar rules can be integrated with information and design attributes in addition to simple
geometric transformations to generate diverse and sophisticated designs.
40
Ii
60
~ ~ 10 Il 9
## #0
Nr\
NO
12/ 12
12.32
13312
12;12
1)112
32.'2
13'-12
13211t
;-2d
J!r
b
a)
Figure 2.4 - Frank Lloyd Wright Prairie house grammar (Koning & Eizenberg, 1981): a) one possible design generation
process; and b) a new prairie house designs generated using the grammar.
17
2.2.2
Functional Grammars
William Mitchell demonstrated the applicability of rule-based design to the field of structural design, by incorporating
functional attributes and criteria to grammar rules in the form of Functional Grammars (1991). Mitchell showed that
by formulating rules that can substitute various structural elements of a hut based on its structural capacities and
performances, a variety of hut designs can be generated.
ORL
fia
/
0~
NOWsS
$mp
RubM
ncva
O-'--O-
P111487 kX
ftdaviul
re
5drI
CNN bin.
9.
awe V
V
1 w~
SNsI
-im
Showas
bay~
Auk
IF1
te
=00
*
DYA
a)
b)
Figure 2.5 - a) "Primitive Hut Grammar" rules (Mitchell, 1991), where each structural element can be substituted by another
based on its structural capacity; b) one possible solution of a hut using the functional grammar rules.
2.2.3
Structural Grammars
Shape grammar has been applied in engineering by incorporating structural knowledge and performance goals into
the transformation process (Cagan & Reddy, 1995; Shea & Cagan, 1999). Shape annealing approach was introduced,
which is a technique that iteratively generates and transforms grammar-based structures while guiding them through
a stochastic optimization algorithm. This method demonstrated how unconventional topologies can be generated,
while performing as well or better than conventional alternatives, such as Pratt, Warren or Bowstring trusses, just to
name a few. Because the grammar rules were entirely geometric and randomized, this method requires FEM analysis
after every iteration to ensure stability and equilibrium which is resource-intensive. The rules are also based on
triangulation and triangle-based transformations, which limits the design results to truss-like typologies. Most
importantly, shape annealing method controls transformations based on an objective function, which means that unless
the transformation improves the overall structural performance, it will keep iterating until one is found. While
successful in generating unexpected solutions with adequate performance, shape annealing is an optimization driven
method that always seeks to converge on a single optimal solution. Ultimately, shape annealing method is an
optimization oriented methodology that is appropriate for later stages of design when the global structural typology
has already been decided.
hf~4
we
4
Figure 2.6 - Truss design options generated by shape annealing method (Shea & Cagan, 1999).
Results are different from one another, but not necessarily diverse in terms of global structural behavior or visual attributes.
18
Alternatively, grammar-based design can be used to explore trans-typology structures, by randomly mix-and-matching
elements of different typologies (Mueller, 2014). A wide range of unexpected yet structurally feasible solutions can
be found using a small set of grammar rules. However, this research was limited to typologies that are specific mainly
to bridge structures only, and the grammar rules cannot be applied to explore other structural problems.
/
Ae_2
I
Figure 2.7
-
A wide range of trans-typology bridge designs produced using the same structural grammar (Mueller, 2014).
2.3
Graphic Statics
2.3.1
Background
French mathematician named Pierre Varignon first introduced the concept of graphically representing forces through
construction of force polygons in his book Nouvelle "Mecanique ou Statique" (1725). Mathematicians, scientists and
engineers of the 181 and 19* centuries have used this graphical method of visualizing, calculating and understanding
forces. Some of the first pioneers of graphical methods include: Poleni (1748), Lame and Clapeyron (1826), Poncelet
(1840), Rankine (1858) and Maxwell (1864) (Zastavni, 2008).
0
a
Z
A
Ft
-.
/
/
/
9--N-
Figure 2.8 - Varignon's diagrams: a) the form of a rope with hanging weights; and b) the force polygon representing the
weights graphically (Varignon, 1725).
19
Graphical method was first introduced to structural engineering community with the development of a technique called
graphic statics, most notably by Rankine (1858) and Culmann (1864). Further contributions from Mawell (1864),
Mohr (1866), Bow (1873) and Cremona (1890) broadened the use of graphic statics in Europe (Malcolm , 1907).
Some of the most prominent structural engineers at the turn of the 19t century such as Robert Maillart, Gustave Eiffel,
and the Guastavinos used graphic statics to design and engineer some of most notable structures during that time.
Fundamentally, graphic statics is a graphical method of calculating forces for discrete structures under axial loads
Z
~
1
8
Figure 2.9 - Reciprocal figures in graphic statics: 1) the form diagram of a truss; and b) the force diagram representing the
internal forces of the truss members (Cremona, 1890)
(Culmann, 1864; Cremona, 1890; Allen & Zalewski, 2009). The concept of graphic statics is based on construction
of two reciprocal diagrams (Maxwell, 1864; Cremona, 1890) : the form diagram representing the actual geometry of
the structure, and the force diagram that represents the internal forces through vectors (Figure 2.9). Reciprocal
relationship between the form and the force diagram, means that the form diagram can be used to construct the force
diagram, or inversely, a set of forces can be used to derive the form diagram (Cremona, 1890). Because forces are
graphically represented using vectors, no numerical analysis is required to calculate the forces. After its initial
development, graphic statics was a widely used technique for both design and analysis by engineers. With increasing
computational power of computers and development of FEM during the late 20* century, this method was considered
slow, archaic and eventually became obsolete in moderm engineering practice.
2.3.2
Computational Graphic Statics
However, there has been a revival of graphic statics because of its amplified potential when combined with moderm
computational tools. When drawn by hand, constructing form and force diagrams can be a tedious process, and freely
manipulating the diagrams after it has been drawn is not possible. With computers, this process can be automated, and
users can manipulate the structure in real time by modifying the force diagrams, or vice versa. Power of computational
graphic statics have been explored through development of tools such as Active Statics (Greenwold & Allen, 2003),
eQuilibriumn (Van Mele, et al., 2009-2012), RhinoStatics (Shearer, 2010) and Constraint-based Graphic Statics (Fivet
& Zastavni, 2013). Tools like RhinoVAULT (Rippmann, et al., 2012), an interactive too] for form finding of shel
structures through reciprocal force diagrams, have even extended computational graphics into projected 3D design
space. These tools have shown the promising potential of computational graphic statics, by not just automating the
construction process of form and force diagrams, but also enabling exploration of new structural forms.
20
1.np
T
~
wrug
h
f*b
Figure 2.11 - eQUILIBRIUM
(Van Mele, et al., 2009-2012).
Figure 2.10 - Active Statics
(Greenwold & Allen, 2003).
ScaI.~ I
25
S
25
B
V-
ow
41
-W,
-W,
fim diu
r~cc dmu~
Figure 2.13 - Constraint-based Graphic Statics
(Fivet & Zastavni, 2013).
Figure 2.12 - RhinoStatics
(Shearer, 2010).
A,
/
~
17~
I-.
Figure 2.14 - RhinoVault
(Rippmann, et al., 2012).
In addition to the interactive form finding and explorations, the parameterization of the reciprocal relationship between
from and force diagrams have improved the formulation of optimum structures. As opposed to conventional structural
optimization techniques which typically manipulates the geometry of the structure (the form diagram), using graphic
statics instead allows optimization to be conducted using forces (the force diagram). Because of the reciprocal
relationship between form and forces, optimization using graphic statics does not require any calculations and
subsequently makes the optimization process much faster. Additionally, all solutions are guaranteed to be in
equilibrium in its final state and no additional analysis is required, and there is no need to introduce additional braces
or triangulating members to stabilize the structure (Beghini, et al., 2013). Two examples of structures designed and
optimized through the use of graphic statics are shown in Figure 2.15 and Figure 2.16.
21
d I
_7j
W!'
Figure 2.15 - Structural optimization of a roof truss using graphic statics
(Beghini, et al., 2013).
While these examples of graphic statics tools have made a significant step forward in adding the element of user
interactivity, they have some key limitations when it comes to conceptual design. First, most currently available
computational graphic statics tools function mainly as an interactive analysis and visualization tool on pre-built
examples. Optimization using graphic statics also requires careful set-up of the reciprocal diagrams of a specific
typology pre-determine by the user. Computational graphic statics tools have yet to be realized as a flexible design
tool that can be applied to a variety of design problems. Secondly, with the exception of RhinoStatics and RhinoVault,
graphic statics based tools are not able to generate forms despite its exceptional capabilities of form-finding and formmanipulating using the force diagrams.
7~TK
42
/ \
NDNE
-I \
Figure 2.16 - Optimization using graphic statics for design of a roof on MIT campus
(Lee, et al., 2014)
22
I \
2.4
Summary
Previous grammatical design works have primarily focused on defining language and styles of designs. Generative
grammars in engineering not only define design languages through formulation or rules, but also use a controlled,
computational generator to search this language for structurally diverse and feasible solutions. Unlike other structural
topology optimization tools which are mainly subtractive, using grammatical approach can allow introduction of new
members into the structure, and transform existing members. Shape grammars and graphic statics are two
computational methodologies that may have limited applications in engineering context if applied independently, but
have tremendous potential when combined and applied together. When infused with the form-finding capabilities of
graphic statics, grammatical transformations can be guaranteed to create a statically equilibrated structure without the
need of a numerical analysis at every step. By hamessing the intelligent, generative power of shape grammar, and the
computational graphic statics that can transform forces into physical forms, structural form generation and design
could see unprecedented opportunities. Given the age and the proven applicability of the two techniques, the main
objective of developing a new computational methodology is not to simply automate the method or reinvent it in a
digital platform, but to find newer ways of implementing that method in an easy-to-use format that can enable
designers to explore new, and unconventional solutions.
Based on existing work reviewed in this chapter, the specific objectives of this thesis are:
I.
Integrate shape grammars with graphic statics to enable generative structural grammar.
2.
Develop a computational design methodology to rapidly generate new structural forms. This methodology is
presented in Chapter 3 in Part 2.
3.
Increase the flexibility of the methodology to be applicable to a wide range of design problems and boundary
conditions. The methodology will be tested on a variety of problems in Chapters 4 in Part II.
4.
Use optimization techniques to sort results in an intelligent and meaningful way, to inform better design
decisions more efficiently. Work in this area is presented in Chapters 5 and 6 in Part III.
23
.jJ
~
-
CN
II - GrammaticaL Design
with Graphic Statics
(GDGS)
25
26
3 Methodology
Graphic statics and shape grammars are powerful methods that have never been applied together in the field of
structural design. This chapter presents a new, grammatical structural design methodology that not only introduces
the designers to more diverse design spaces, but enables fast explorations of the new design possibilities.
Note: Underlined words refer to an object class in the programming environment of the proposed methodology. For
example: the word "force" simply refers to its literal definition. A Force refers to a custom programming object that
is a digital representation of an actual force, with several layers of parameters and information such as amplitude,
direction, type, and location.
3.1
Introduction
3.1.1
Definitions
For clear discussion of the methodology, key basic elements are defined. More in-depth, technical details of these
class objects are explained in section 3.3.2.
Assembly
a-
Member
Force
1%
Figure 3.1 - Four basic elements of the methodology.
Force: An object that is digital representation of a force. This object carries important information about each force
instance: 1) amplitude, 2) type (i.e. applied, reaction, temporary or member), 3) direction (compression or tension)
Member: An object that represents a physical member of a structure. It contains:
location and length of the member, and 2) the Force the member is carrying.
1) two coordinates that define the
Node: An object that represents a joint or a pin. It contains: 1) a coordinate that defines its location, 2) type (pinned
support, roller support, applied, end, multi-member joint, etc.), and 3) a list of Forces acting on the Node.
Assembly: A grouped object that contains all Forces, Members and Nodes.
27
3.1.2
Assumptions
To develop this methodology, some key assumptions are made:
1. All structures begin with reactions that are in global equilibriumwith appliedforces.
2. Only axialforces (compression and tension) are considered
Because graphic statics is a method that addresses only axial loads, all structures presented consist of
straight members under axial loads only. All connections are hinges, or pins.
3. All structures are discretizedand areplanar in 2 dimensions.
4. Overlappingof members is allowed
5. Buckling is not implemented as a major constraint
All structures considered in this research are dimensionally small (10' to 30' in width or height), and the
loads are relatively small. In order to keep the geometric diversity as broad as possible, buckling constraint
was not implemented. However, it can easily be incorporated as bounds within the rule parameters.
6. All geometric operations are basedon equilibrationof Forces of a Node.
3.1.3
Basic Conventions
A Force, is constructed with two coordinates: Force Head, and Force Tail. These two coordinates define the magnitude
of the force vector which is the distance between the two coordinates, and the direction of the force vector (Figure
3.2a). If a Force is in compression, it is given a "Direction" attribute of - 1. If in tension, "Direction" attribute is + 1.
A Force in compression will have its Force Head on the coordinate of the Node (Figure 3.2b). Conversely, a Force in
tension will have its Force tail on the coordinate of the Node (Figure 3.2c).
/0
0
a)
b)
Figure 3.2 - Basic elements of a Force.
28
c)
This research will use a simplified version of the conventional Bow's notation in graphic statics (Bow, 1873). In
Bow's notation, every force vector and areas in between force vectors are labeled. Careful labeling is important for
truss like structure that Bow was interested in. However, such rigorous labeling is not required, because global and
local equilibrium are always guaranteed. Therefore, simple notation that applies to only the individual Node is
in a
adequate for this research. For any number of Forces present at a Node (Figure 3.3a), the Forces are rearranged
is
Node
each
for
polygon
force
the
Then,
3.3b).
clockwise order, starting at the 0' line, or the positive x-axis (Figure
constructed with the corresponding order.
3
I
I
2
2
c)
b)
a)
Figure 3.3 - Convention used for rearranging the Forces of a Node.
3.1.4
Concept 1: TempForces
equal
For a Node to be in a state of static and rotational equilibrium, the sum of the force vectors applied to it must
1864;
(Culmann,
polygon
closed
a
form
vectors
force
the
zero. In graphic statics, equilibrium is verified when
the
3.4a),
(Figure
known
already
is
structure
the
Cremona, 1890; Allen & Zalewski, 2009). When the geometry of
when
However,
verified.
easily
be
force polygon construction for a Node is relatively simple, and the equilibrium can
in dotted red
the structure is not yet known, the Node must always be equilibrated with a temporary Force, shown
arrow (Figure 3.4b). This temporary Force will be referred to as TempForce.
1 I
P
P
P
P
M
M
M
*.
I,
b)
a)
Figure 3.4 - The use of a TempForce to temporarily equilibrate a Node.
(applied loads
Similarly, if a structure is assumed to be in global equilibrium, the sum of the external force vectors
of
geometry the structure
and reactions) and the moments must equal zero (Figure 3.5a). This means that whatever the
in Figure 3.5b.
ends up being, the sum of all internal force vectors and the moments must also equal zero, as shown
29
B
B
C
b
I
I
I FB
B
C
B
C
C
a)
a
b
b)
Figure 3.5 - a) Equilibrium of external forces (applied loads shown in blue, reactions in yellow) mandates: b) equilibrium of
internal TempForces (shown in red).
3.1.5
Concept 2: Graphic Statics based Rules
Because TempForces are used to enforce equilibrium both globally and locally, the TempForces can then be used to
generate the geometry of the structure that always satisfy equilibrium. Specific geometric generations or
transformations can be formulated as a rule that acts on TempForces. Figure 3.6 shows three examples of simple rules
that can generate Members at Node I using the TempForces.
2
2
3
3
10
iTk
I
11
1
1
I'
I'
'S
'I
I
2
3
2
a)
2
3
b)
Figure 3.6 - a) a free Node in equilibrium, and b) three simple rules showing how equilibrated structure can
be generated using
the TempForce.
30
3.1.6
Concept 3: Randomness
GDGS introduces randomness to explore diversity in three different ways: 1) the sequence of force polygon
construction (Figure 3.7); 2) randomness of rule and the location to apply the rule (Figure 3.8), and 3) variance of rule
parameters (Figure 3.14). Given n number of external loads and reactions that are in global equilibrium, there are n!
different ways in which the global equilibrium force polygon can be constructed (Uspensky, 1937). Figure 3.7 shows
three possible ways of constructing the global equilibrium force polygon, and the resulting form. In Figure 3.8, same
rule is applied at different Nodes, which result in completely different forms.
a)
a)
V
\_
V
/0
/0
b)
b)
iV
\A/
No
/0
03
c)
c)
Figure 3.8 - Location at which rule is applied changes the
form diagram: a) split rule applied at A only; b) split rule
applied at C only; and c) split rule applied at A and D.
Figure 3.7 - Altering the order in which the force vectors are
assembled to construct the equilibrium force polygon,
drastically changes the resulting form:
a) A-B-C-D-E; b) B-A-C-D-E; and c) A-C-E-D-B.
3.1.7
N
Constraints
While the generative grammars can be a powerful tool in discovering new structural forms, the grammar rules need
to be controlled with intelligent constraints. Without constraints, the rules may be too broad and generate forms that
have limited practical feasibility. In addition, because grammar rules can be applied recursively, or repeated without
an end, termination conditions need to be carefully defined. The following strategies are used to set constraints.
1. Setting reasonablelocal bounds, such as minimum and maximum angles or lengths.
2. Global termination conditions, such as loop count and recursioncontrol mechanisms.
31
3.2
Overview
3.2.1
Conceptual Overview
The proposed methodology automatically and randomly generates designs through series of rule applications. The
conceptual overview of the computational setup is illustrated in Figure 3.9. Generally, the Grammar Engine is
responsible for choosing rules, deciding where to apply them and updating the geometry. Graphical Computation
Engine functions as the structural blueprint behind all procedures to be performed by the grammar engine.
Grammar
--
Gaoph Ic
S t rcsEn ne -
-
-
...--
...................................-.
Graphical Computation
Figure 3.9
3.2.2
-
Conceptual overview of integrating shape grammar and graphic statics.
Computational Setup and Workflow
Proposed methodology was implanted as an interactive tool, using IronPython, Rhinoceros and Grasshopper. The
Grammar Engine, which consists of grammar and rules, and the Graphic Statics Engine were written in
IronPython, a
Python language scripting plug-in for Rhino. The two Engines can be directly modified by the user. The two Engines
are accessed by components in Grasshopper, which then generates and modifies the initial shape input by the user in
Rhino. The Grasshopper components generate designs, which can later be visualized, exported and manually revised
by the user.
".'
I
Cont roller
Geometry
Generator
Figure 3.10 - Computational setup and workflow.
32
Grammar
Rules
Graphic
Statics
Engine
3.2.3
User Interface
Each iteration instantaneously generates: 1) corresponding force diagrams for every Node (Figure 3.11 a), 2) a form
diagram with clear labels (Figure 3.1 lb), and 3) rule history, information and evaluation metrics for the current design
how
(Figure 3.11 c). Visual representation of the Forces, the evaluation metric, and the rule history which summarizes
more
decisions
design
better
inform
and
the structure was derived, enables clearer understanding of the structure
quickly. Rule history, which records all the parameters that were used to generate the current design, is an important
the
feature that enables reproducibility of the same design during later stages of design, when more information about
boundary conditions and the project in general, may be available. This blueprint can also be used to develop more
detailed versions of the design, and allow creative breeding using evolutionary algorithms.
XFL = 956.3
IL = 172.88
7#= 19
I-
b)
a)
Figure 3.11
-
Screenshot of the tool, with a sample design in Rhinoceros.
33
c)
A
I
34
3.3
GDGS Model
3.3.1
Setup
Unlike most conventional engineering tools described in Chapter 2, this methodology begins without a starting
geometry. First, the user sets up the problem by defining the applied loads, reactions and the locations of those loads.
User then chooses which rules to apply, and weights for each rule which defines how likely a rule can be picked and
applied. Finally, the user defines how many design iterations to generate. In addition to rule combination, probability
for each rule, and rule-specific parameters, results can be further diversified by modifying the following global
parameters: 1) minimum number of rule applications for each generation; 2) rule sensitivity towards the beginning,
the middle or the end of the generation cycle; 3) termination conditions; and 4) random seed.
Kin
O
a)
b)
c)
Step 1: Setup problem, and create
initial Assembly.
Step 2: Pick rules to apply, and formulate
grammar by setting weights.
Step 3: Generate iterations, and sort based on a
desired performance metric.
Figure 3.12 - User workflow of GDGS.
3.3.2
Main ELements
Design generation operates on three main types of computational classes: 1) a Force class that includes 2D vector,
with a type parameter, direction and amplitude; 2) a Node class that includes a coordinate, state parameter (active or
not-active), type parameter, and a list of Forces; and 3) an Assembly class that includes a list of Node classes, list of
Members, the overall system state, and other information about the entire structure. The detailed structures of the three
classes are graphically summarized in Figure 3.13.
mb( Nodes, Members, Boundary)
Force (Line, Type, Direction)
Node (Coordinate, Type, Forces)
A
1. Line
1. Coordinate
1. Nodes (List of)
2. Members
(List of)
3. Boundary
2. Type
State
3. Direction
t
3. Forces (List of)
State
Figure 3.13 - Detailed structure and organization of the three main class objects.
35
3.3.3
Rules
The 8 rules used for generating designs in this paper, are summarized in Figure 3.14. All parameters incorporate
structural logic and knowledge, and equilibrium is always verified by construction of force diagrams. While the
parameters are randomly determined, it is constrained by user-defined, lower and upper bounds to control that
randomness. Weights can be set for each rule, which determines how likely a rule can be picked.
Rule 0
Rule 1
Rule 2
Rule 3
START generation.
Create a Node.
Extend a Node.
Split a Node.
* Assembly State: Start
- Assembly State: Go
- Assembly State: Go
* Assembly State: Go
* Input Node type: Any
- Input Node type: Any
- Input Node type: 3, 4, 5
- Input Node type: 1, 2, 4, 5
' Length range: [Lmin, Lmax]
' Angle range 1: [Omin, OmaI
- Length range: [Lmin,
' Length range 1:
- Angle range
--
[Lmin, Lmax]
I: [0..r,
Omax]
-
No geometric operations.
Lma4]
Rule 4
Rule 5
Rule 6
Rule 7
Connect two Nodes.
Extend & connect two Nodes.
Close structure.
END generation.
* Assembly State: Go
- Assembly State: Go
- Assembly State: Go or Close
- Assembly State: Go or Close
* Input Node type: Any
- Input Node type: Any
- Input Node type: Any
- Input Node type: Any
' Search range: [Rmin, Rmax]
o Search radius:
[Rm.., Rmax]
' Force Factor: F
A
k
No geometric operations.
Figure 3.14
-
Summary of all rules and its parameters (-
fixed parameters,
o=
modifiable parameters).
Detailed diagrams of Rules I through 6, are shown in Figure 3.15 through Figure 3.20.
36
o Parameters
-
I
0
4
0 Input (Attowabte Node Typel
-4-V'~..
W Output
L
a
A
4;
1'
I
+
II
Figure 3.15 - Rule 1: Create a floating Node
N Parameters
Wo
Input (Attowable Node Typel
0 Output
L.
I
U
'I
II
Iy
V
Figure 3.16 - Rule 2: Extend a Node.
37
....
..
....
..
......
W Parameters
0 Input (AlLowable Node Typel
moM6
b Output
U
U
U
U
I
(I
'VI
+
L
Figure 3.17 - Rule 3: Split a Node.
w Parameters
1 Input (Attowabte Node Typel
I!
0 Output
F
.
I
|I
V
+tI
V
Figure 3.18 - Rule 4 : Connect two Nodes.
38
w
Parameters
w
Input
(Allowable
I
Node Typel
4i~
7/
0 Output
R
+
Figure 3.19
w
Parameters
N
Input (Atlowable Node Type)
-
V1A.
II
II
El
*
Rule 5: Extend & connect two Nodes.
b Output
/
7
c4%9
Dig
'49
44
4,
zK.
Figure 3.20 - Rule 6: Close structure.
39
zcLl
3.3.4
Grammar: Automatic Random Generation
Figure 3.21 is a detailed framework of the automatic random generation grammar.
Step 1 a
User sets up the design problem, and defines the general boundary conditions such as applied loads and
locations, and location and type of supports.
Step lb
User defines parameters for all rules, and select which rules to apply.
Step
1c
User defines the parameters related to the automatic random generation grammar, such as termination
conditions, and minimum loop count.
Step 2
All information input by the user is converted into instances of Forces and Nodes, then assembled into
an Assembly. The initial state of the Assembly is "Start."
Step 3
Apply Rule 0, which changes the Assembly state to "Go." This step acts as the global switch that starts
the automatic random generation loop. If the application of Rule 0 fails, the user initial setup needs to
be revised.
Step 4
Of all the Nodes in the Assembly that are in "Go" state, a random one is picked.
Step 5
According to the rule selection criteria defined by the user in Steps
be applied to the picked Node from step 4, is collected.
Step 6
With the rule weights set by the user in Step I b, a random rule is picked and applied.
Step 7
Upon successful application of the rule, Rule History is updated with all the detailed information about
the rule that was just applied, including the specific parameters that were used, and the Node that it was
applied at.
Step 8
Entire Assembly instance is updated, with any new Members, Forces and Nodes. Steps 4 through 8 is
repeated until the state of the Assembly changes to "Close" once Rule 6 is picked.
Step 9
Rule 6 is repeatedly applied until there is no more TempForces left. When there is no more TempForces
left, the Assembly state changes to "End," which terminates the automatic generation loop.
Step 10
Using the graphic statics engine, any desired metric from the Assembly can be extracted for further
evaluation.
lb and lc, all possible rules that can
Steps I through 10 are a summary of one particular automatic random generation. This generation can be automated
to run multiple times, which can output multiple results at once.
Note: The properties or conditions such as positions and magnitudes, of any new object resulting from the application
of a rule, do not change at all after that particular operation, throughout the rest of the generation process.
40
START
la
Formulate Problem
Parameters
Set Grammar Parameters
b
1c
- --
-
Set Rule
Generate Initial Assembly
2
Apply Rule 0
3
7I
AssAssnmby
Sttat
i
Pick Random Node
4
Get Possible Rules
5
Apply Random Rule
6
Record History
7
Update Assembly
8
Assemr'bly.State==
-f
AssernbLy
StateIfAsemb
C
tatc
ose
Resolve Remaining Forces
& Close System
Atsembly State?-
fA
sembt,yStai
Extract Evaluation Metrics
nd
10
END
Figure 3.21
-
Framework of the automatic random generation grammar algorithm.
41
3.3.5
Design Generation
Figure 3.22 shows an example problem, and the full generation sequence. Step-by-step explanation of the generation
is described here.
1
In Rhino, user sets up the design problem. Location of supports are determined as Rhino point objects.
Location and amplitudes of applied loads are defined, using two Rhino points (one for Force Head and
one for Force Tail). In this particular example, there is one applied load, P. Every object is in Rhino,
non-parametric environment.
Step 2
The information input in Step 1, is transferred to Grasshopper as Grasshopper objects. Using an arbitrary
reaction angle B (please refer to Section 5.3.2 for further explanation of this parameter), global
equilibrium is achieved with reactions R1 and R2. With the global equilibrium established, each Node is
equilibrated locally with TempForces. The Assembly state is now "Start."
Step 3
When Assembly state is "Start," the only rule that can be applied is Rule 0, which is the "on switch" that
changes the Assembly state from "Start" to "Go." Rule 1 (Create Node) is applied at Nodes I and 3, and
two new Nodes are created, 4 and 5. Then, Rule 3 (Split Node) is applied at Nodes I and 3.
Step 4
Rule 5 (Extend and Connect Two Nodes) is applied at Node 1, which connects Nodes 1 and 4, creating
Node 6. Rule 2 (Extend Node) is applied at Node 5, creating Node 7. Rule 4 is applied at Node 3,
connecting Nodes 3 and 4. Rule 4 is applied at Node 7, connecting Nodes 7 and 3.
Step 5
Rule 4 (Connect Two Nodes) is applied at Node 2, which connects Nodes 2 and 5.
Step 6
Rule 5 is applied at Node 4, which connects Nodes 4 and 1, creating a new Node 8. Rule 5 is applied at
Node 2, which connects Nodes 2 and 5, creating a new Node 9. Nodes 4 and 5 are now in "Pass" state,
and no more rules can be applied at Nodes 4 and 5.
Step 7
Rule 5 is applied at Node 8, which connects Nodes 8 and 6, creating a new Node 10. Nodes 6 and 8 are
now in "Pass" state.
Step 8
Rule 6 is applied at Node 10, connecting with Nodes 7 and 9 by creation of Node 11. When Rule 6 is
selected, the state of Assembly changes to "Close," meaning that only Rule 6 can be applied from this
point. Because the generation began with a structure that was in global equilibrium and every Node was
generated ensuring local equilibrium, the last three remaining TempForces always should be concurrent.
One Rule 6 is complete, the state of Assembly is now "End," which terminates the loop.
Step
42
1)
2)
0~
B
B-
B
B
4)
3)
0'
*L
6)
5)
I4
8)
7)
Figure 3.22 - An example of an automatic random generation sequence.
43
4 Results
In this section, GDGS is tested on several example problems to demonstrate how this method can be used to generate
a diverse range of statically feasible, discrete planar structures.
4.1
Implementation
4.1.1
Evaluation Metric
While the automatic random generation can produce unlimited number of interesting results, there needs to be a
method that can sort the results in an intelligent way in order for the designers to make meaningful decisions. The
evaluation metric used for the design tests will be based on sum of total strain energy or total load path, which is
equivalent approximation of total volume of the structure (Baker, et al., 2013). Assuming constant internal stress at
its optimal or final iteration state, the total volume or load path can be calculated by the simple formula: I1FI-L
(Stromberg, et al., 2012), where F is the internal force of a member, and L is the length of that member. For each
design test, simplest funicular design is shown at the top of the page. The iFj -L value for this funicular design is the
benchmark, and the X1F -L of all the other designs are normalized relative to this benchmark score. The normalized
score is shown below each design, as well as the actual EIFI -L value. Sum of total length of all the members, 2L, is
also given as a reference.
For each design test, 90 designs were generated, and nine designs (top 10%) with the best scores were selected, and
presented.
4.1.2
Sorting Results
The following Python script can be used to automate the generation process, and sort them based on the performance
metric, I1F -L, which is called referred to as the "Score" in the script. "StartShape" is the initial Assembly.
TotalIterations = x # sampling size
SortedIterations = y # of designs to pick
bestDesigns =
[]
# list of output Assemblies
for i in range(TotalIterations):
a = b.GenerateRandomAssembly(StartShape)
# automatic
random generator
bestDesigns.append(a)
if len(bestDesigns) < SortedIterations:
bestDesigns.append(a)
else:
bestDesigns.append(a)
sorted(bestDesigns, key=lambda a: a.Score,
bestDesigns.remove(bestDesigns [-1])
reverse=False)
Figure 4.1 - Python script for automating random generation, and then sorting it based on a desired number of designs to be
selected from those generations.
44
4.2
Design Tests
4.2.1
Problem 1: Span
C.
.0
1.0
658.61
TL
109 81
818 0'1
!FL
673 61
ZLU 126.38
EFL - 712 2
9
L = 14 4a
2.36
YFL = 956 30
Z, =
172.88
FL = 1035 ,94
IL = 247,26
Figure 4.2 - Results for Problem 1.
45
L z 192.86
2.44
2.43
FFL = 1128.89
145 00
FL
2.23
2.06
1.80
ZFL
1.53
1.45
1.42
F
YFL
1130,16
L
19825
4.2.2
Problem 2: Cantilever
p -o
1.0
1.08
1.09
1.15
1.17
1.37
1.38
1.62
1.88
2.26
Figure 4.3 - Results for Problem 2.
46
4.2.3
Problem 3: Radial Compression Structure
P
P ---
0--
+0
/0
P
0
P
0
I
1.0
P
IFL = 800.00
IL
*60 00
1.04
1.02
1.01
1F L 817."7
ZL
227
4'
YFL
1, - 22y Ot
'600"
L = 212.Y"
1.24
1.19
1.05
FL = 832 ,5 Q
EIT
=
88.58
Li
221
7i
7
1.47
1.43
1.41
PFL, = 1
140
77
EL = 21 5 8 3
Figure 4.4 - Results for Problem 3.
47
FL
1178 53
ZL
281 61
4.2.4
Problem 4: WaLL-Like Structure
P
P
P
P
I- IO I
1.0
F
1.09
0L b4
6
P26
'i
70
.;
1
1.15
1.16
1.29
1.37
7
1.38
F
b U1
ZL
1.23
F
L
1.39
IF
58
6
1.52
116
Figure 4.5 - Results for Problem 4.
48
4.3
Discussion
4.3.1
Exploring Parameters
All designs shown in Section 4.2, were generated using the same rule parameters. However, the rule parameters can
be modified by user to achieve drastically different results. Figure 4.6 show three designs with different parameter
values for Rule 3. Similarly, modifying the parameters for other rules will result in drastically different designs.
Rule 3 angle range:
10-20'o
Rule 3 angle range: 20'-40'
Rule 3 angle range:40'-60'
Figure 4.6 - Various results with modified parameters for Rule 3.
4.3.2
Practical Applications
While the proposed methodology allows fast exploration of design possibilities during conceptual design, the results
will need to be interpreted by the architect and the engineer in order to develop the design with more detail and rigor
during later stages in design. Figure 4.7 illustrates how three results selected by the designer can be developed into a
realistic roof structure by using a symmetry constraint.
p
P
Figure 4.7 - Sample designs with symmetry enforced, resulting in more practically applicable designs.
49
50
III
- GDGS &Optimization
51
52
5 MethodoLogy
In this chapter, Force Polygon Construction Problem (FPCP) is presented as a type of combinatorial optimization
problem. While it has similarities with traditional combinatorial optimization problems commonly found in the fields
of mathematics and computer science, there are key differences that makes most existing optimization algorithms
inapplicable for this particular problem.
A strategy for formulating FPCP and how it can be used in conjunction with Rule 6 described in Chapters 3 and 4, is
presented. Although the optimization strategy investigated in this chapter is directly related to Rule 6 in particular, it
can also be incorporated with the automatic random generation presented in Chapters 3 and 4. In automatic random
generation, Rule 6 is the very last step that completes the structure, so the methods and strategies are directly
translatable.
5.1
GeneraL
5.1.1
Concept (Force PoLygon Construction ProbLem)
By definition, static equilibrium of a structure means that all forces and moments acting upon it are balanced. In
graphic statics, where forces are represented by Euclidean vectors, equilibrium requires the summation of vectors to
equal zero, which is verified when force vectors in succession form a closed polygon (Culmann, 1864; Cremona, 1890;
Allen & Zalewski, 2009). Commutative Property of Addition from algebra also states that equilibrium vectors can be
summed in any order and still equal zero.
b
C
b
C
C
b
S
S b
b
C
Form Diagram
Force Polygon 1
a+b+c+d+e=0
Force Polygon 2
a+c+b+e+d=0
Force Polygon 3
a+d+b+c+e=O
Force Polygon 4
b+a+e+c+d=0
Figure 5.1 - Four possible ways of drawing force polygons of a structural joint that is in equilibrium.
For a joint or a Node where force vectors are concurrent (all intersecting at a single point) as illustrated in Figure 5.1,
ordering of force vectors do not have any direct implications on the form or its performance. However, when the
equilibrium force vectors are not concurrent, the ordering of force vectors have a significant effect on the resulting
funicular form. For any structure, if the external forces are in equilibrium as in Figure 3.5a, the sum of internal
TempForces (shown in dotted red lines) must also be in equilibrium, as illustrated in Figure 3.5b.
53
Ordering of internal forces to construct the internal equilibrium force polygon directly affects the resulting funicular
shape as illustrated in Figure 5.2. The angle the reactions, is another parameter than can affect the funicular shape.
This angle parameter will be addressed in detail, in section 5.3.2.
k
tK
IS
-- -~
a) Force vector order: a-b-c-d
.1
..........
Z,_
1:~
1:I
b) Force vector order: a-c-d-b
Figure 5.2 - Without changing the external forces, simply changing order of internal force vectors to construct the internal force
polygon results in different funicular shapes.
Accordingly, funicular shapes have different structural performances. "Performance" discussed in this paper will be
based on sum of total strain energy or total load path, L1F -L (Please see Section 4.1). The ordering of the internal
force vectors, its impact on the resulting funicular shape and its performance, is illustrated through examples in Figure
5.3.
5.1.2
Objective
If a set of force vectors are assumed to be in equilibrium, the order in which the force vectors are summed to construct
the closed force polygon is similar to combinatorial optimization problem that has direct influence on the form of the
structure and its performance. For simple problems with 3 or 4 force vectors, optimal solution is often obvious. Even
if the optimal solution may not be obvious, a brute-force search can be used to find the best performing solution for
small scale problems. However, with 5 or more force vectors, a brute-force search is simply not feasible. A faster and
more efficient method is necessary for finding or approximating optimal solutions. This paper will present strategies
to formulate this problem, set intelligent constraints to expedite the search for the optimal funicular shape, and
introduce a method to perform combinatorial optimization in Grasshopper using GOAT (Flry, 2015).
54
/
'V
a) If the external forces are in static equilibrium, so must the internal forces.
jcz
z'
(XL
b) Force vector order: a-b-c-d-e
=
61.07, EFL = 881.09)
A
(1L
c) Force vector order: a-c-e-b-d
84.05, IFL = 1023.52)
4,.
I
A
d) Force vector order: a-b-d-c-e (1L = 69.09,
IFL = 1096.12)
changing the external loads and
Figure 5.3 - Four possible ways of constructing the equilibrium force polygon. Without
(shown in dotted red), can
polygon
force
internal
the
construct
to
vectors
force
of
ordering
reactions, simply changing the
of the structure as well.
performance
the
on
drastically change the form of the structure. Accordingly, it has direct influence
55
5.1.3
SimiLarities to Combinatorial Optimization
If a set of force vectors are assumed to be in equilibrium, the order in which the force vectors are summed to construct
the closed force polygon is similar to combinatorial optimization problems in mathematics and computer science. The
most notable example is the traveling salesman problem (TSP). TSP asks the question: given a list of cities and the
distances between each pair of cities, what is the shortest possible route that visits each city exactly once and returns
to the origin city? TSP is considered to be NP-hard (Non-deterministic Polynomial-time hard), which simply means
that the problem is very difficult to solve and the solution may not be verifiable (Orponen & Mannila, 1987-28).
wwbw
aw
uon
m C.1r6,
FRANC
nn
-unhe
0
AWSTUA
AUSrO
Figure 5.4 - Example of a traveling salesman problem with 15 city trip around Germany.
(Image source: http://www.gizmag.com/)
A TSP problem that requires a round trip (returning to the origin city), can be modelled as an undirected weighted
graph, where the cities are the graph's vertices, paths are the graph's edges, and a path's distance is the edge's length
(or labeled on the edge) (Applegate, et al., 2006). Below is an example of a TSP problem with 5 cities (A, B, C, D and
E) in a graph form. The numbers on each edge represents the cost, or in most TSP problems, distance between the two
cities.
A
2
E
8
1
6
3
2
3
B
4
1
C
D
Figure 5.5 - Example of a TSP problem.
(Image source: http://algoviz.org/OpenDSA/dev/OpenDSA/Modules/NPComplete.odsa)
56
In a roundtrip TSP problem, the ordering of cities matters. This means, that for a TSP problem with n number of cities,
there are n! possible routes (Uspensky, 1937). For small problems, exhaustive search and evaluation may suffice.
However, as the number of cities increases, the number of possible routes or permutations increases exponentially.
n
U1
0
1
2
3
4
5
6
7
8
1
1
2
6
24
120
720
5040
40320
_Ul
9
10
11
12
13
14
15
16
17
6402373705728000
121645100408832000
2432902008176640000
1.551121004x1021
3.041409320x106
1.197857167x1010
9.332621544x10157
1.733368733x101000
4.023872601 x102567
18
19
20
25
50
70
100
450
1000
362880
3628800
39916800
479001600
6227020800
87178291200
1307674368000
20922789888000
355687428096000
Table 5.1 - Possible routes (permutations) for n number of cities.
For the FPCP, formulation and evaluation of the cost function is not as straight forward as summing up the cost or
distances, because intersections of force vectors are what creates the routes, not the actual Nodes themselves.
Depending on the intersection of the previous two force vectors, the next intersection point changes and therefore the
cost changes. Force polygon construction problem is combinatorial, as well as sequential. The cost is always changing,
and dependent on the previous combination offorce vector intersections. Figure 5.6 shows a comparison of the TSP
in a traditional, undirected graph format, and a flow graph diagram that is more representative of FPCP.
C
B
A
A
E
D
I
F,. L
Fit- L,,,
LAB
OAB
B
E
F,-,,.
0
A1I-
002-DOJ'(I
1 4h, L-----r)
Dr
LL
o
R(Aa-DD,
-E
IJ
Order
Cost
(EL)
LAs + LBD+Loc+LcD+LEA
Order
A-+B-D-+C-E
Cost
(2]F1 L)
FALAB+ FBLBA
+ RABLAB-.D + FLc-(AB-D)
+ R(AB-.D)L(AB-D)-c + FcLD-.AB
+ R(AB-D)-.c)L((ABD)-C)-+E
+ FELE-(AB-+D)-+C)
b) FPCP with five forces in fixed positions. The cost function is
a) A traditional TSP problem with five cities (n=5). Cost
function is typically the sum of distances, EL.
IFI-L.
Figure 5.6 - Comparison of: a) TSP, and b) FPCP of the same size (n=5).
57
Figure 5.7 shows how FPCP of a simple design scenario can be represented by the flow graph diagram, which is
different for every arrangement of the force vectors.
B
A
C
D
E
0
O9
.01
41 -C)--E
ORlAD
a) Force vector order: a-d-b-c-e
A
B
C
D
E
D
E
-- I
OU
0.9
0
C-A
E
OAC~-MH
b) Force vector order: a-c-e-b-d
A
Q
B
C
0
i
OAR -0
0
09--
EA-9.9--
c) Force vector order: a-b-d-e-c
Figure 5.7 - Illustrations of how force polygon construction problem can be represented with the sequential, flow diagram.
5.2
Overview
5.2.1
Conceptual Overview
While similar to traditional TSP in concept and theory, FPCP introduces slightly different challenges. First, the
ordering of force vectors changes the subsequent cost value, orXiFI L for all remaining forces and members. Therefore,
a method has to be established that can iteratively calculate the resultant force vectors, the corresponding intersection
points in the form diagram and eventually calculate ZIFI L for evaluation. Second, an intelligent way of reducing the
number of possible arrangements is necessary. Reducing the possible number of arrangements is not just important
for any combinatorial optimization problem, but especially for FPCP. Each iteration requires Rule 6 to calculate forces
and draw corresponding form diagram, which is computationally more intensive than simple summation of distances
between cities.
58
Strategy
5.2.2
The FPCP involves two main parameters: 1) arrangement or order of the force vectors; and 2) the reaction angle.
Procedural methodology used involves three main steps. First, a strategy to reduce the possible number of
arrangements is presented. The second step is to write a script that can enumerate the reduced number of specific, nonredundant arrangements in Python. Third, each arrangement will be assigned an index, with which GOAT can use to
perform the optimization.
5.3
Setup
5.3.1
Parameter 1: Ordering
For a set containing n number of distinct force vectors that are in equilibrium, there are n! number of possible, ordered
arrangements to complete the closed force polygon. This can be expressed as k-permutations of n (Uspensky, 1937):
n!
(5.1)
Pl(n, k) = (n -k)!
When n=k, (n-k)! = 0! = 1, so P(n,n)-n!.
When drawing the force polygon of internal forces, the order of the first two force vectors does not matter, as shown
in Figure 5.8.
B
a)
I
B
C
C
b)
c
'C
L
force vectors
Figure 5.8 - For this problem where there are 4 internal force vectors (n=4), changing the order of the first two
B-+A--+...
as
same
results in the same form. A-+B-+... is the
The combination of the first two force vectors, can be expressed as a 2-element (k=2) subset of a n-elements set using
the expression:
n!
C(n, k) =
(5.2)
The new expression for the possible permutations is:
Remaining force vectors
(order matters) :
Total:
(5.3)
C2 (n, 2) =
P2 (n - 2,n - 2) = (n - 2)!
C2 (n, 2) -P2 (n - 2,n - 2) =
59
!
First two force vectors
(order does not matter) :
(5.4)
(5.5)
If the location of the supports are known and not moving, there is a method of finding the reactions through graphic
statics such that the resulting funicular form is guaranteed to terminate at those supports.
/
I
A
a) If B, C and D (shown in blue) are applied loads on the structure, a resultant force vector can be found (shown in green), which is the
summation of force vectors B, C, and D.
I
\
/b
b) So long as the two reaction force vectors and resultant force vector are concurrent, the last three remaining internal force vectors are
guaranteed to be concurrent.
Figure 5.9 - Process of finding reactions using graphic statics (Cremona, 1890).
This means that the last two remaining force vectors are 2-element (k=2) subset of a (n-2)-elements, which excludes
the first two elements. The updated expression is:
First two force vectors
(order does not matter):
Last two vectors
(order does not matter) :
Remaining force vectors:
(order matters)
Total:
C (n,
C3(n
2) = 2(n
- 2,2) =
3 (n
2)
(n 2!
2!( (n - 2) - 2)!
- 4,n - 4) = (n - 4)!
C2(n, 2) - P2 (n - 2,n - 2) - C2 (n, 2)
n!
(n - 2)!_
2! (n - 2)! 2! ((n - 2) - 2)!
n!
4
60
(5.6)
(5.7)
(5.8)
(5.9)
In Python, itertools.permutations("some list") function can be used to enumerate all possible permutations of "some
list." However, a function that can sift the total permutations, and extract specific arrangements is needed. The
following script is used to enumerate the n!/4 (Equation (5.9)) number of unique arrangements:
permutations = []
for subsetl in itertools.combinations(data,
tempdatal = data[:]
2):
tempdatal.remove(subsetl)
2):
for subset2 in itertools.combinations(tempdata,
tempdata2 = tempdata[:]
tempdata2.remove (subset2)
for combo in permutations(tempdata2,
set = []
set.append (subsetl)
set .append(combo)
set.append(subset2)
permutations.append(set)
len(tempdata2)):
Figure 5.10 - Python script for enumerating n!/4 unique arrangements, where the first two elements make up subseti of 2
distinct elements of set S, and last two elements make up subset2 of 2 distinct elements of set (S-subsetl).
As an example: for a set S with n distinct elements (n = 5), the following 5!/4=30 number of unique, ordered
permutations can be generated using the above script:
1
Arrangements
C
B E
B D C
D
B C
B
E
C
D B
C
D
B
C
B
D E
C B
D
C
D B
D
E
E
D
E
E
C
E
E
2
3
4
5
6
7
8
9
A
A
A
A
A
A
A
A
A
10
11
A
A
E
E
D
C
B
B
C
D
12
13
14
15
16
17
18
19
20
A
B
B
B
B
B
B
B
B
B
C
C
C
C
C
C
D
D
D
E
C
C
C
D
D
D
E
E
E
D
D
D
E
E
E
E
E
E
B
E
D
A
E
C
A
D
C
A
E
B
A
D
B
A
C
B
A
C
A
A
D
A
A
C
A
A
C
A
A
B
A
A
B
A
A
B
D
D
E
E
C
E
E
C
D
D
B
E
E
B
D
D
B
C
C
21
22
23
24
25
26
27
28
29
30
Figure 5.11 - Unique, ordered arrangements of a set S with n=5 distinct elements.
61
5.3.2
Parameter 2: Reaction Angle
In addition to the arrangement of the force vectors, another parameter that can drastically change the results is the
angle of the reactions. In the reaction finding method described in Figure 5.9, the angle of the reaction is variable
which changes the resulting funicular shape. By setting a reasonable bound for this angle parameter, a variety of
possible solutions with varying shapes and performances can be explored.
300
539.71
IFL =
450
XFL = 375.0
600
1FL = 499.52.0
Figure 5.12 - Changing the angle of the reactions not only changes the shape of the structure, but also its performance.
5.3.3
Formulation of the Problem using GOAT (Optimization)
The "Index" column from Figure 5.11 can be used as an integer slider in Grasshopper for performing optimization. It
is important to note that combinatorial design space is discontinuous, with discrete values. For example, combination
with Index value of 1 may perform much better than a combination with Index value of 2. There is no relationship
between the Index value of I and 2, other than that they represent different combinations. Therefore, an optimization
component like GOAT will have not be able to find solutions that are globally optimal.
While GOAT may not be able to find the solutions that are optimal, the fast sampling mechanism of GOAT can be
used to sample the entire design space. The results can be sorted afterwards, according to the performance metric.
Most importantly, the user will be provided with a plot which can give a clear overview of the design space, and look
for any apparent sweet spots for further investigations.
Another need for sampling multiple solutions, is that the designer may want to consider other alternatives with fairly
good performances during early stages of design, in addition to the optimal solution. This method will allow the user
to explore design alternatives that may not necessarily have the globally optimal performances, but provide some other
benefits such as interesting aesthetic qualities. Sampling the design space and producing several well-performing
options will help the user get a better feel for the tradeoffs, and make informed design decisions more efficiently.
62
6 ResuLts
problems.
Using the optimization strategies presented in Chapter 0, Rule 6 was implemented on a variety of example
6.1
ImpLementation
1through
Results for each problem is summarized with a plot of the design space, and notable solutions. For Problems
1-the
Parameter
4, the x-axis represents Parameter 2-the reaction angle. For all problems, the y-axis represents
arrangement index, starting with 1 from the top. It is important to reiterate that the y-axis does not represent any
numerical quantities. Each row of plots simply represents different arrangements. While one row may perform well,
design space to
the very next row may perform poorly. These plots are meant to give the user a quick overview of the
to represent
used
are
colors
The
patterns.
or
trends
locate the sweet spots, and not necessarily inform any mathematical
highlighted
are
solutions
the performance of each solution, based on the gradient shown in Figure 6.1. Global optimum
with a box.
Optimum(s)
Worst
Best
Figure 6.1 - Gradient for representing the value of EIFI-L for each problem.
63
6.2
Case Studies
6.2.1
Problem 1: Symmetric Span (Variable Reactions)
0
"
"
Number of force vectors (n)= 4.
Both reaction angles are variable. Left reaction angle is parameterized: lower bound set at 300, upper bound at 600.
Figure 6.2 - Setup for Problem I
Because this is a completely symmetric problem, the results too, are indeed symmetric. 0-2-1-3, and 1-3-0-2, which
are identical because of symmetry, perform much better than other four arrangements. 450 produced the global
optimum, which intuitively makes sense as it is exactly the funicular, arch-like shape that is expected. Overall, the
symmetry makes the results very clear, easy to understand and interpret. However, the diversity of solutions is limited.
Results are shown in Figure 6.3.
64
***
e*
000"0 **so
0-2-1-3
45.0'
*
m
- E e*
1 -3-0-2
*
ZFL = 390.0
45.0'
06e*0**
Figure 6.3 - Results for Problem 1.
65
6*00000 0
*"
6.2.2
Problem 2: Asymmetric Span 1 (Variable Reactions
o
*
*
....
......
.....
-
...
1~
Number of force vectors (n)= 5.
Both reaction angles are variable. Left reaction angle is parameterized: lower bound set at 300, upper bound at 600.
Figure 6.4 - Setup for Problem 2.
Similar to Problem 1, the results are somewhat expected. Force vector arrangements that minimized the length of
members that are direct extension of the initial force vectors, seemed to produce the best performing results. Once
again, these are what most closely resembles the funicular, arch-like shape. Approximately 500 for the left reaction
angle was the sweet spot for arrangements that produced the best performing results.
Results are summarized in Figure 6.5.
66
I
doe
~~.
00*
090
00
50.0
#**
~
~
. 000
0..
1 -3-02-4
0e
48V0e
@0
4
Om we 6
2-4-1
0-3
48.0
Figure 6.5 - Results for Problem 2.
67
*
..
.0
. .00
..
0
OS
S.
Problem 3: Asymmetric Span 2 (Variable Reactions)
6.2.3
10P
*
*
Number of force vectors (n)= 6.
Both reaction angles are variable. Left reaction angle is parameterized: lower bound set at 300, upper bound at 60'.
Figure 6.6 - Setup for Problem 3.
With number of forces increasing to 6, number of possible arrangements is now six times the number of arrangements
for Problem 2. While the diversity of solutions certainly increased, the optimal results are still what we expect to see:
Funicular arch shapes, with local variations. 60' produced the best results. The pattern of consistent colors for each
row of dots, indicates that for each arrangement, changing of the reaction angle does not have a very significant effect
on the performance, for this particular range of allowed angles. Choice of arrangement is much more critical than the
reaction angle.
Results are summarized in Figure 6.7.
68
50
1.003*0
0
0
58.0
I
*IIS
I
.*&0
0
0-4-1-2-3-5
57.5
-
n
z iLE.JqJa
53.o'
00
-
04
0
e**
..........
.....
*
*
0
8
S.
3 5 2- 1- 0- 4
.
*0
0
.0
*
0
*.a
fit 0
I
.
*~
*
6
00...
83
Figure 6.7 - Results for Problem 3.
69
0a0
.
9
6.2.4
Problem 4: Asymmetric Radial (Variable Reactions)
/X,
Z
*
*
Number of force vectors (n) = 6
Both reaction angles are variable. Left reaction is parameterized: lower bound set at 450, upper bound at 1350
Figure 6.8 - Setup for Problem 4.
With 180 possible arrangements, and with the force vectors distributed radially, slight changes in the angle of the
reactions produce drastically different results. This is evident in the plot, where each row of dots have a wide range of
performances. Almost all optimal solutions have reaction angles that are smaller than 900, which makes sense since
any angle greater than 90' drastically increase the "radius" of the structure exponentially. Reaction angle is just as
critical as the arrangement.
Results are summarized in Figure 6.9.
70
0-2-3-5-1-4
.
45.0'
-
0.
*
A
FL = ,81 I
S
*
9
00
0
0
54.0'
0
0
0
0
0
9
0
0,00
0 0 0*
9.
0
0
S0
'FL
649
8
0
0
*,-,60
5
0***0
0
0
4"v
2-3-5 -1.- 0 -*4
0
83.3'0
+
%
Ve
FL I806 32
~
....
*
00
-- 0.4
3-5-2
98.5'
.. 9 .4
~
~2&c
Figure 6.9 - Results for Problem 4.
71
1-.**
T -s
. ..
....
..
..
......
.... .. ..
Closing Structures 1 (Pre-determined Reactions)
6.2.5
/A\
5
A
0
S
S
-44
Number of force vectors (n) = 6
Reaction angles are not variable.
The direction and force type (compression or tension) of the initial members are allowed toflip its direction and
orientation, in order to close the polygon.
Figure 6.10 - Setup for Problem 5.
Because this problem seeks to apply the methodology to a problem where there are pre-existing members, the diversity
of the results are much more interesting due to the added constraint. Of the 180 possible arrangements, there were
quite a few well-performing results that were also visually distinct. The designs selected and shown in Figure 6.12 are
not necessarily the best ones in terms of performance, but they were selected only from the results that were close to
the optimal solution. If the initial members are not allowed to flip directions or orientation, the number of possible
designs are significantly reduced, and are not necessarily optimal. Some of them are shown in Figure 6.11.
1-2-0-5-3-4
IFL = 830.1 (Global Optimum)
2-4-5-0-1-3
IFL = 1437.2
0-4-2-1-5
XFL = 1285.9
Figure 6.11 - Solutions to Problem 5, if the initial members are not allowed to flip directions or orientation.
Results are summarized in Figure 6.12.
72
S
0-3-2-4-1-5
0
1.2-0-5-3-4
1-3-5-2-0-4
r1-4-2-5-0-3
0
S
0
S
do-
0
5
40
Figure 6.12 - Results for Problem 5.
73
0
0
0
Closing Structures 2 (Pre-determined Reactions)
6.2.6
*
Number of force vectors (n)= 8
*
Reaction angles are not variable.
*
The direction and force type (compression or tension) of the initial members are allowed toflip its direction and
orientation, in order to close the polygon.
Figure 6.13 - Setup for Problem 6.
With 8 force vectors, there are now 10,080 possible arrangements. There are quite a few designs that have optimum
or nearly optimum performances, and all of them have completely different topologies. Among the best performing
designs, the ones that the author considered were interesting and offered the most variety, were chosen and shown in
Figure 6.15. Similar to Problem 5, solutions are very limited when the initial members are not allowed to flip in its
original direction or orientation. One of the very few designs that can satisfy this constraint, and perform reasonably
well, is shown in Figure 6.14.
1-7-5-3-2-4-0-6
XFL = 1636.13
Figure 6.14
-
Solution to Problem 6 that does not allow flipping of the initial force vector direction.
Results are summarized in Figure 6.15.
74
0
0-1-2-7-4-5-3-6
0
@0
S
1. 2-3-0-57-4.6
0
0
1-4.0-32-5-6-7
0
to
4-5.6-1-7-0-2.3
a
6- 7.1-4-2-5-0-3
Figure 6.15 - Results for Problem 6.
75
00
6.3
Discussion
This chpater presented a method that can automate the construction of force polygons, and complete the form diagram
using graphic statics. This automation enables generation of a wider range of possible structural solutions to simple
problems, and fast exploration of those results. The effects of how the ordering of the force vectors can be varied to
modify the form diagram was thoroughly addressed, investigated and explored. Combined with built-in optimization
components in Grasshopper, large amounts of solutions and possibilities can be sampled and sorted based on a
preferred performance criteria by the designer. The optimization example problems presented in this chapter are
simple problems with only one or two objective functions. However, with more carefully formulated constraints and
improved algorithms, this method could be much more powerful in tackling complex problems and consistently
produce designs that are unexpected, interesting and yet performatively adequate. Overall, this method is flexible
enough to be applicable to any design problem with varying degrees of constraints during early stages of design, and
enables the designer to explore viable alternatives to conventional solutions more efficiently and intelligently.
76
IV e ConcLusions
77
78
7 Conclusions
This thesis presented Grammatical Design with Graphic Statics (GDGS), as an alternative design method to the
conventional parametric design paradigm, which is limited in variety and often lead to expected solutions. Part 1I
demonstrated how shape grammar and graphic statics can be combined to rapidly generate unexpected and interesting
designs that are guaranteed to be in equilibrium. Design examples explored in this thesis illustrate the applicability of
this new method in the generation of a wide range of diverse and structurally feasible designs to relatively simple and
standard problems. This final chapter summarizes the key contributions of the thesis, potential future work, and final
closing remarks.
7.1
Contributions
7.1.1
More Trial, Less Error
By incorporating forces during the form generation process, this new methodology always produces designs that are
structurally feasible. Because of this, there is no need to run FEM analysis to check the structure's stability or
equilibrium. In current practice, the conventional workflow of architects generating forms in a modeling software and
engineers checking the form with an analysis software, results in an iterative trial-and-error process that requires more
time for coordination than brainstorming quality ideas quickly during conceptual design. The ultimate hope of this
thesis is not to develop a structural design tool that can replace the human engineer, but to find ways to take advantage
of the powerful computational tools available today to explore better and more interesting ideas faster.
Each and every design iteration shown in this thesis was generated in a second or less. By using a graphical method
of calculating forces, GDGS showed how structurally viable solutions can be generated rapidly to provide the designer
with more time to make informed design decisions, instead of spending the same amount of time analyzing forms that
may be inherently flawed to begin with.
While most FEM analysis tools that engineers use today provide quick feedback on performance, it does not at all
inform the designer with any guidance or direction for improving the design. On the other hand, graphic statics
instantly generates clear visualization of forces which conventional structural design tools cannot. This enables the
designers to get a clearer and better understanding of the structure's internal forces. As a result, the designer's intuition
of the relationship between form and forces is improved, and better decisions will be made more quickly as the project
progresses.
7.1.2
Unbiased Exploration of Diverse Design Alternatives
Design decisions in the field of structural engineering are typically made based on risk. That risk may be related to
issues regarding general safety, constructability, or cost, just to name a few. When combined with the trial-and-error
design process, the human designer must rely on insight, intuition and experience gained from previous projects to
generate new ideas. Even for designers and engineers with years of experience, reliance on known methods and proven
solutions in the industry greatly limits innovation.
In order to expand the creative ability of designers, the power and speed of modern computational tools can be used
to enable unbiased exploration of viable solutions. With automated generation by the computer, which is guided by
the design goals input by the human designer, diverse solutions can be generated that simply would not be conceivable
by the human designer with inherent design biases and prejudices. Allowing the computer to make unexpected and
yet structurally logical decisions results in new and interesting designs that is difficult to generate manually with a
79
pencil or a mouse. In addition, the automated generation of multiple design at once not only increases the creative
capacity of the designer, but it also leads to new insights and better understanding of the design problem itself.
The design possibilities presented in Chapter 4 and Appendix B, demonstrate the tremendous potential of how
automatic computational generation can be guided by human designer to explore a wide variety of diverse and
interesting solutions, freed from any previous biases or knowledge about the problem.
7.1.3
Generative Graphic Statics: Beyond Reciprocity
Graphic statics is a powerful method for enabling the designer to graphically control form through forces, or forces
through form. This reciprocal relationship has inspired the revival of the century old method in combination with
modem parametric design tools. However, the reciprocal relationship between the form diagram and the force diagram,
also means that one of the two has to be created before the other can be drawn. Therefore, most computational graphic
statics tools only work with pre-set problems or examples, functioning mostly as an interactive analysis or
visualization tool.
By combining graphic statics with generative grammar, the form finding capabilities of graphic statics was used to
generate equilibrium structures. Most previous work done on shape grammars have been formulated with geometry
based rules. Because of this, it required a shape to preexist before any rule could be applied. In engineering context,
this means some initial structural typology has to be selected or defined before any grammatical operations could be
performed.
In GDGS, all rules are based on the coordinate-essentially a point, of a Node. Because of this, the rules are not
dependent on any preceding shapes or conditions. Therefore, the generative structural grammar backed by
computational graphic statics presented in this thesis, is flexible enough to be applied to any design problem, and is
able to generate structures without any prescribed typology or preferences.
7.2
Future Work
Although this thesis was a novel first attempt of implementing this new methodology, there are several important
directions for future work.
7.2.1
Controlling Local Mechanisms
I
7.2.2
While all designs generated with GDGS are in static and rotational equilibrium
under the given loads, there currently is no method that checks for collapse
mechanisms that would occur under any other load cases. It will be important to
develop a method to check for these potential local instabilities, and prevent them
from happening through additional layers of constraints to individual rules, or the
grammar algorithm. Also, designs that are able to address multiple loading
scenarios will result in designs that are more robust.
Force Diagram based Rules
Although this thesis focused on rules which are based on geometric transformations of the form diagram, rules can
also be developed for modifying the force diagram as well, which will further broaden the design possibilities. Force
diagram based rules may also enable more intelligent method of controlling the general magnitudes of forces in the
structure, as well optimizing its overall performance, as Beghini et al. demonstrated in "Structural optimization using
graphic statics" (2013).
80
7.2.3
Limiting Overlapping members
Currently, GDGS allows members to overlap. Overlapping members
enables a great diversity in design possibilities, but members that are
traversing across the entire structure should be avoided, especially if that
member is in compression. A method that can control the frequency of
overlapping members without over-constraining the automatic generation,
will result in designs that are not just diverse in its appearance and
adequate in performance, but also practically feasible.
7.2.4
Improved Constraints
----
---
Another important constraint that was not implemented in order to
maximize the diversity of designs, was buckling and slenderness ratio.
While this constraint could be implemented locally by setting bounds on
lengths for Rule 2 and Rule 3, and setting a controlled search radius
parameter for Rule 4 and Rule 5, the closing sequence involving Rule 6
often requires members that may well exceed its buckling capacity. In
the future, Buckling lengths could be addressed through improvement of
constraints and parameters for Rule 6.
Additionally, all designs produced by GDGS are not contained by any boundary constraints. Developing a method to
implement boundary constraints will be a more accurate representation of realistic design scenarios in practice, where
contextual and boundary conditions are usually known before the conceptual design process begins.
7.2.5
Generative Structural Grammars in 3D
This thesis focused on discretized 2D structures. Same principles of problem formulation, rule application and
controlled generation could be applied to 3D structures. Although graphic statics is a well understood and established
method for only 2D structures, recent work by Jasienski et al. (2014) and Akbarzadeh et al. (2015) have shown that
graphical methods of representing and controlling forces could be extended into 3D.
However, potential application of GDGS in 3D does not require any complicated methods such as polyhedral force
diagrams. Because GDGS demonstrated a method of applying graphic statics based grammars based on local
conditions of individual Nodes,,global connectivity and behavior do not constantly need to be computed. In addition,
any new object created in the GDGS method is ensured to be equilibrated, and is not allowed to be modified once
created. Therefore, only the active Nodes need to be considered in each step, which greatly reduces the scale and
complexity of 3D problems.
With unprecedented computational power and rapidly increasing capabilities of digital design tools, synthesizing
generative grammar, form and forces in three dimensions is more than possible, and its potential is very promising.
7.2.6
Grammar-based, Interactive Evolutionary Explorations
GDGS demonstrated how a wide range of designs could be generated. However, this diversity in designs could be
developed further in detail using evolutionary explorations. Similar to the methodology implemented in structureFIT
(Figure 7.1 a), an interactive evolutionary exploration of designs by investigating parametric variations, could be an
effective way of developing particular designs later on in the design process.
Additionally, by observing the level of diversity a particular set of rules can produce, the user can then pick and choose
interesting designs to generate crossover and offspring designs that incorporate attributes from the initial, parent
designs (Figure 7. 1b). Such method could be a powerful way of mix-and-matching positive traits from multiple "good"
designs and deriving even better ones.
81
structureFIT
.-
~
I
P-
Z
0
-7
2
3
4
5
a)
b)
Figure 7.1 - a) structureFIT, an effective method and interface for interactive evolutionary exploration of designs, and b)
genetic exploration of design crossover and breeding; using contributions from each parent design's rule derivations, offspring
designs can be produced which has traits from both parent designs combined in different ways (Mueller, 2014).
7.3
Concluding Remarks
Overall, the new design methodology presented in this thesis demonstrates the validity in combining and applying
shape grammars and graphic statics together to various engineering design problems. The general versatility and
customizability of the methodology, and the speed at which it can generate unconventional and yet structurally feasible
solutions, greatly improves the diversity and quality of design explorations during early stages of conceptual design.
82
V * Appendices
83
A
Scripts
This appendix includes simplified structure and organization of the main Python scripts.
Assembly.py
class Force:
(self, line,
init
def
self.Line
self.Type
self.Direction
type, direction):
class Node:
(self, coordinate, type,
init
def
self.Coordinate
self.Type
self.Forces
self.NodeState
forces):
class Assembly:
(self, nodes, members):
init
def
self.Nodes
self.MyState
self.History
self.Members
self.Score
self.Length
self.MCount
def RandomNodePicker(self):
def RearrangeNodes(self):
def GetScore(self):
def GetLength(self):
class RuleHistory:
Rules.py
class BaseRule:
def CanApply(self, currentshape):
def CanApplyNode(self, node):
def Apply(self,
currentshape, params,
def UpdateHistory(self, currentshape,
node)
params,
class RuleParam:
def GetRandomValue(self):
84
node)
#
class RuleO(BaseRule):
(self):
init
def
self.Name = "Rule 0: 'START'"
self.Params
self.Weight = 1
def CanApply(self, assembly):
if assembly.MyState == State.Start:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState == 1:
return True
else:
return False
def Apply(self, currentshape, params, node)
# Geometric transformation here
currentshape.MyState = State.Go
return currentshape
#
class Rulel(BaseRule):
(self):
init
def
self.Name = "Rule 1: 'Create Node'"
self.Params
self.Type
self.Weight
def CanApply(self, assembly):
if assembly.MyState == State.Go:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState == 1:
return True
else:
return False
def Apply(self, currentshape, params, node)
# Geometric transformation here
currentshape.MyState = State.Go
return currentshape
class Rule2(BaseRule):
(self):
init
def
self.Name = "Rule 2:
self.Params
'Extend
Node'"
self.Type
node)
#
self.Weight
def CanApply(self, assembly):
if assembly.MyState == State.Go:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState == 1:
if node.Type == 3 or 4 or 5:
return True
else:
return False
currentshape, params,
def Apply(self,
# Geometric transformation here
currentshape.MyState = State.Go
return currentshape
85
#
class Rule3(BaseRule):
(self):
init
def
self.Name = "Rule 3: 'Split Node'"
self.Params
self.Type
self.Weight
def CanApply(self, assembly):
if assembly.MyState == State.Go:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState
1:
if node.Type == 1 or 2 or 4 or 5:
return True
else:
return False
def Apply(self, currentshape, params, node):
# Geometric transformation here
currentshape.MyState = State.Go
return currentshape
#
class Rule4(BaseRule):
(self):
def
init
self.Name = "Rule 4: 'Connect with Element'"
self.Params
self.Weight
def CanApply(self, assembly):
if assembly.MyState == State.Go:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState == 1:
if node.Type == 3 or 4:
return True
else:
return False
def Apply(self,
currentshape, params, nodel):
# Geometric transformation here
currentshape.MyState = State.Go
return currentshape
#
class Rule5(BaseRule):
def
init
(self):
self.Name = "Rule 5: 'Connect via Projection'"
self.Params
self.Weight
def CanApply(self, assembly):
if assembly.MyState == State.Go:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState == 1:
return True
else:
return False
def Apply(self,
currentshape, params, nodel):
# Geometric transformation here
currentshape.MyState = State.Go
return currentshape
86
#
class Rule6(BaseRule):
(self):
init
def
self.Name = "Rule 6: 'System Close'"
self.Params
self.Weight
def CanApply(self, assembly):
if assembly.MyState == State.Go:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState == 1:
return True
else:
return False
currentshape, params, node)
def Apply(self,
# Geometric transformation here
currentshape.MyState = State.Close
return currentshape
node)
#
class Rule7(BaseRule):
(self):
def _init
self.Name = "Rule 7: 'END'"
self.Params
self.Weight
def CanApply(self, assembly):
if assembly.MyState == State.Go:
return True
else:
return False
def CanApplyNode(self, node):
if node.NodeState == 1:
return True
else:
return False
currentshape, params,
def Apply(self,
here
transformation
# Geometric
currentshape.MyState = State.End
return currentshape
Grammar.py
class Grammar:
(self):
init
def
self.MyRules = [I
self.LoadRules()
self.SetRuleGrammar ()
def LoadRules(self):
self.MyRules.append(rules.RuleO())
self.MyRules.append(rules.Rulel())
2
self.MyRules.append(rules.Rule ())
self.MyRules.append(rules.Rule3())
4
self.MyRules.append(rules.Rule ())
self.MyRules.append(rules.Rule5())
self.MyRules.append(rules.Rule6())
7
self.MyRules.append(rules.Rule ())
87
def SetRuleGrammar(self):
for r in self.MyRules:
r.MyGrammar = self
def GetAllRules(self):
weightedRules = []
for r in self.MyRules:
if r.Weight > 0:
for i in range(r.Weight):
weightedRules.append(r)
return weightedRules
def GetPossibleNodeRules(self, thisAssembly, thisNode):
possibleNodeRules = []
allNodeRules = self.GetAllRules()
for r in allNodeRules:
if r.CanApply(thisAssembly) and r.CanApplyNode(thisNode):
possibleNodeRules.append(r)
return possibleNodeRules
class RandomComputation:
grammar)
(self,
init
def
self.MyGrammar = grammar
def GenerateRandomAssembly(self, currentshape):
while currentshape.MyState != rules.State.End:
currentshape = self.ApplyRandomRule(currentshape)
currentshape.Score = currentshape.GetScore()
currentshape.Length = currentshape.GetLength()
return currentshape
def ApplyRandomRule (self, currentshape):
node = currentshape.RandomNodePicker()
if len(currentshape.History.Rules) > 20:
else:
rules = self.MyGrammar.GetPossibleNodeRules(currentshape, node)
rulecount = len(rules)
if rulecount > 0:
index = ru.MyRandom.Btwn(0, rulecount - 1)
rule = rules[index]
params = self.GenerateRandomParams(rule)
currentshape = rule.Apply(currentshape, params, node)
return currentshape
else:
return currentshape
88
GraphicStatics.py
def
def
def
def
def
def
def
def
def
def
def
def
TranslateForce (force, coordinate):
ReverseForce (force):
GetTempForce (node):
FlipTempForceDir (node):
GetLineOfAction (node):
LineToVector (line):
TransferMemberForce (force, nodecoordinate):
GetPosWayRay (node):
GetNegWayRay (node):
GetTwoWayRay (node):
UniDirVectorIntersection (pointi, vectori, point2, vector2):
BiDirVectorIntersection (pointl, vectorl, point2, vector2):
def
def
def
def
def
def
def
def
def
def
def
GetActiveNodes (assembly):
RearrangeForces (node):
TempNodeEquilibrium (floatnode):
EquilibrateNode (node):
DrawNodeForcePolygon (node, drawlocation):
GetNodeIndex (node, currentshape):
SearchArea (node, assembly, searchradius):
SearchConnection (node, assembly, searchradius):
FindClosestNodes (node, assembly, count):
FindClosestProjection (node, assembly, count):
ConnectTwoForces (nodel, node2, currentshape):
def GetMemberNodes
def GetMemberForce
(member, assembly):
(member, assembly):
89
... ......
..
B
Additional Design Examples
This appendix includes additional designs examples for the design tests presented in Section 4.2
XFL = 901.51
IL= 148.29
#= 14
A
RULE HISTORY
4
7
1."Cone"
20Pk I Ne
"" &so Cw Wun
ECm.nt
0ieJate
IFL = 673.61
IL = 126.38
X# = 13
AI
A
'#
---
~<J
,
RULE HISTOR'
-
\'1
ID 0WAA
IFL =
1458.28
IL = 274.85
X#- 18
-~
~
A
,,
RULE HISTORY
C-rer
w mr
90
ate aNd
Scowe
XFL = 1132.17
EL = 200.2
X#= 17
~4
I,
<7
4'
,3
-% a S~
Cre
N
"w
.
RULE HISTORY
XFL = 1143.88
XL = 201.47
X# 17
"I
~,
I,
RULE HISTORY
-t6 %
C3.5
o0w11ol
LA
%e:ytnclbw W: N.de
I%
IFL = 497.19
IL = 87.49
I# = 14
V
->
RULE HISTORY
'**.o..
~
-
V
-lool
Z
'R a sv
"R
cww Now m
$I &gM
w.91 W
Pplm N-11eda so~
lo"G@- CnnC* wC.
91
w
.:
IFL = 605.77
IL =
115.98
Z# = 17
A
I,
I'v
$
9
--
=9
RULE HISTORY
.
1%" 0 Sso-es~ns cbw od MAWw
1
I=
Dg ytmO- W~so : N."e
lko
clww fto"ea'asede lae
141 Aa0 syna-es- 00-dtean
'
t
IFL = 1619.72
EL = 232.63
*
R#L 18
RULE HISTORY
!4%0 -6 cyimwe ipnw al~s 4
XFL =819.14
IL = 142.82
-# 14
/
f
;~
RULE HISTORY
as-
92
-~
-}m
.
-
-
4
XFL = 773.13
EL = 155.58
F#= 18
I,
~
//
44
,
4
RULE HISTORY
%ftn
I"
Alec
4
hm
tNd
mnceaw
ID00DCA
[FL = 818.96
1L = 148.88
#=
14
R--e
251
RULE HISTORY
N-
A'
WONIrlPdc a
*
XFL = 844.03
XL = 145.9
T# z 14
Z-00
RULE HISTORY
'ft",
onue
0we
oletwr
apld Nw e 6
1.to ul6:,y WM cww"Wdea 0 " 10
93
XFL = 666.18
IL = 112.45
= 13
i
1RULE HISTORY
-
4/
9
IFL = 1130.16
IL = 198.25
X# = 19
A
~~0
'~-
~
RulW 4
26
A
4
RULE HISTORY
0 womm:,'.FoE
.'
'
XFL = 1096.22
IL = 179.95
1# 19
9
'<A
RULE HISTORY
:,
94
sp
CAM
"Plme
mf.f
XFL = 764.2
IL = 130.19
X# =13
RUE4 2T
RULE HISTORY
IFL = 838.52
IL= 122.63
#= 15
2s
Rgiuw
e
RULE HISTORY
R
4
Conec
4
ud E
'lrpp
ea
Mee
I%
"n a *I - o ll, " " " 0m a sa ilo ft
II
o~ ."wolfgt
Ik 8% ce-ylam
IFL = 956.3
7L = 172.88
1# - 19
RULE HISTORY
w
4 C*
,$ wfte 0
95
nt**
p
Iis:r sp!rdMM
s
ovo"iwM
"Wei:
ondwhmnet psoe ae
lods
EFL = 1255.47
IL = 237.12
X# =18
--- j
/,.
/1
RUE4 2ST
RiULE HISTORY
A
IFL = 752.02
IL = 127.46
F# = 15
fl
IL ;
RULE HISTORY
4
7.
i1
/
/
XFL = 2001.95
IL = 298.75
# - 19
I
V
i
i
RULE HISTORY
2*~
4 RA
4
96
Rl6
: sv
CanCtw
olmwn
Wyste C-* .00. .
p
Ide
N
a
1
i
10
ooi7C
FFL = 837.93
IL 131.01
#= 16
d
25*
RW. 4
RULE HISTORY
.1100
msoa td
%# 4 C-rldwt E~mn
'
97
ees..Ais
m.9
hkM 7
CWW app
,2 IFA G*9y"1" CkWne 1pgimd mod aIn
is
4i
1 yei Cla.r Vpw as in 12
ID 0=212
XFL = 1096.47
IL = 187.12
X# = 17
A
\i
"',~
4ly
<
RULE HISTORY
1
4
'o -1
4 Cnet
o
Eb
en pWs
M
td
i..2
I.
,3 %ft " wW le
.*
.*
3.
vo
+
w
pmo
0 ".f->t
30 %d omrwitEm erssm tad
-+L
=a~
802.93DWm'#M
Nal
X2=en
205.03efggseiine
plmniasad 13
d
y
RULE HISTORY
2
y
42
R," 6
r
i o esaid
S.
Ix la!12N
Pom eeee No
'
I,
/
1Z#
I$,_.
97
tNd!
12
XFL = 970.67
IL = 215.89
X# = 18
'1
I
RULE HISTORY
-0 00om
EFL = 1527.89
EL = 196.3
1# = 15
f
RULE HISTORY
9'
;2 lum
v Co
4
wElm apo 0
SsaCwWOs'staN"
o Sma
s &.
:13luV 6il
wCwne wstaloft 0
ft 0o
d. 10
EFL = 719.87
XL = 129.83
'9
-
E#-15
25%
RULE
RULE
3
98
S
HISTORY
lpe sm
ConC w O
nw
wlas N o I
XFL = 998.89
IL = 188.29
1# = 14
14
RULE HISTORY
t-~*
A
.,
%fts
G*Wwe
r l6'i alNd
'%M go .o1lm
Now
9yu O.W.Now 1<|#1010
a
I%
0 : 0WAC
IFL = 658.61
IL = 109.81
1#= 14
I'
RULE
2S%
RULE HISTORY
4
zoooll
IFL =
1160.36
IL = 248.89
#
15
'
~A
>1
-
IT
'I--
A
'9
RULE HISTORY
-4
99
I I
I....
......
10 EDM
XFL = 1035.94
IL = 192.86
1#= 19
v
RUL
25R
RULE HISTORY
A
:1 '
-m
sp
bl
1sv l")
Cw
PP..
W ~ ,I
-
W
wyt i.
1l'gai
0 00"IE
IFL = 1523.47
IL = 244.98
E# - 21
I
RU
E I~
26
A
RULE HISTORY
XFL = 1765.51
IL = 346.63
4,
4
____7
4k
RULE HISTORY
%a
ni!': r INmbf 11pas
i
1rAm
o_-ni"sviil
M~let asm1
Byb~e~pdN." is
10%sRSema
a,20%a
ftft-y 6 -.By-~a
Onow
100'ipeaeie1
100
ise
N
d 20
61
Ih
EFL = 1128.89
IL = 247.26
# = 24
~\
VI
/
I,
I,
RULE HISTORY
-1
-
I.~
16l0 *WT
A
' s
Q
:
Conc d lnm lofse t Nn1
4v.
, '%A*
s 5 wo
sy
on
mft
-
RowM
.
igr
oomE
IFL
=1108.85
IL = 265.25
X# = 24
4
RULE HISTORY
/
't--
ZOO
9
kae4 Contete l
2,
to o
a
a ea
-Pmm
a,.on
,.w..
I,
1
mntgps
I
d-
pm
XFL = 1036.65
IL = 244.29
# = 24
i
I'
4'
RULE HISTORY
S
'-Ir
lE d
.:,
1&i
-
1
4. =
u
2D lkb
101
CnerA"
wPerate
"a, pe =4 w
c, Nyim osaseo~al 19
e.
=d
3
IFL = 990.76
ZL = 182.66
Z# = 17
'\
~.J
A
'-.9,
RULE HISTORY
EFL = 1230.12
XL = 240.69
21
-=
A9
IRULE HISTORY
A
C-L-M
.
RW
i9
6 Sv
+.
1W
-.
Q
Se4Ct.- Ck-
4
$I.mC
.
men
eer
W-4C
sa a
9) 00,C2
IFL
= 930.89
= 171.84
E# - 22
IL
4
972
--
I
v
k
'~
f
RULE
9-
4
---- 9.
HISTORY
9*.-,.
R.A sv
2
C=ie
.0*.n
'.,y
k, 'A- 9 3onec 0-*
102
i'tN
.
EPP-
mtNoj
.
11ap~ra Nd
C-.
.
A.
pbW
1
13h
2
a od
0D
001EE
IFL = 838.03
IL = 144.94
K# - 17
Rul
4
2S
RULE HISTORY
13%
XFL = 806.63
IL = 203.68
# - 22
~4
-
~
-
t
RULE HISTORY
.'~..
'*A
-O
4,
W
-,-
-C-
+%ft
o
|-
-
a
'
)
IFL = 757.38
IL = 169.45
I# - 21
4
RULE HISTORY
4,
, 6.t
,4
103
m
w
.:iN|+
*
Oftw
00 nsWWWe~ft@0 Oft* I
Ise~ssene-psa as
owlq Wh69psiCW000* ~psa ftlye
ibte
--
. ...
..
.....
....
0 00207
IFL
= 1263.72
IL = 287.34
X# = 22
It
---
,#
RULE HISTORY
I
-"-
w
m
=y~was
oet
4 8.W cw ohna
12
-
-
I.,
s(:smone .ohe. osod s
lks Se'
.y
IFL
= 1487.35
ZL = 248.61
X#= 16
I
'A
I
RULE HISTORY
L5
-A- %desa ",
10
-asenta
OD" Smsls-aeampsi
XFL = 1194.36
IL = 169.91
I#- 15
RULE HISTORY
12
104
svft. soswm w~ps
moot
a
M
ie6Ssm os s,, e WNW
'*A
Ned. I
0D
00=3
XFL = 1554.21
IL = 146.73
E# =16
As 25%
Ru
Rl
ji
2
0
1.
2$%
-.
sm. cmw
'Nki
awd
6 5yVW-
ClaWa
XFL = 1465.11
IL = 115.25
1# =12
P.,* 4 75%
1
N
RULE HISTORY
EFI = 2535.04
IL = 203.64
T-# = 16
RULE HISTORY
~
'4 A0,t1 sy
/
---
,
RULE HISTORY
105
appw A
Cbw
kts
t
M*W;
a Ng 12
IFL = 2536.05
L
X#
= 164.26
=13
k
RULE HISTORY
/-
XFL = 1866.04
IL = 194.47
X#= 16
'I
M
04
3vFL
= . NOW ..
l
-.
'L
=%ta
o.N 1944
RULE HISTORY
I~-~-
~A'
tD 003M
IFL = 2897.47
EL = 299.21
1#
-
16
RULE HISTORY
W 6a4 cl
Csner
No
- .ue3yme came pwne
lbfst& Sysmi
tfmen
:dMNe
atsmm
,
,00'4pe
0 PiAP ZV amC WIW~pntll
106
t
.as
. ....
......
IDOMWE
XFL = 1512.31
IL = 122.72
1#= 11
R.W A 25
RULE HISTORY
10 OW03A
/
EFL = 1855.61
IL = 155.49
# = 12
RUlE
25R
RULE HISTORY
-ft a0 S
. v
M.W ,ataPw
0D
W421
/
/
/
XFL = 1325.13
EL = 100.15
F# 7
RULE HISTORY
I
107
dasN
io cos
IFL =
1581.72
88.29
EL
8
#
RULE HISTORY
MueaSy,- C~oe .0.hal
a n
0 cODS
XFL = 2602.02
IL = 142.73
# =8
7
e-
/
RULE HISTORY
IFL =
/
1486.02
IL = 259.81
# 24
'~
4
RULE HISTORY
l $s
1
1.
108
6
d
,2
$y-s
%
C~es
C-oe
'sym-s
Vp-eda
ls'
ine1
16ee l$4d
Ipoea oe1
/
*
XFL = 2872.94
IL = 204.18
# = 20
-~
PAO. . 2s,
A
/
RULE HISTORY
%A0 " 2ai
s
b
w
ft
~,
i
EFL = 3365.02
EL =361.78
S17
2 ,"."S s,. .. e ow w =... ..
clo pm.ck
'W '
ISTO. R
+L
M V o owT*mi
d
. N .0
10 ommo
XFL = 3743.07
EL = 244.5
E#= 16
RULE HISTORY
14
109
4 25%
/
RULE
I
ft
Bft& Coe
.pesa
ass1
9
M. 0
.... ....
..
/
XFL = 2192.14
EL = 166.0
# =13
RULE HISTORY
-~
E
0
DMI3
IFL = 2918.24
EL = 214.33
Z# = 22
A
'K
RULE HISTORY
V
A -*
& l
-t 8
0t* 6 &ysA-sls'sssa~
W SV OO80GW 040.V
's 3 %M
mv
IFL
= 2691.37
250.13
X# - 17
EL
=
I7
RULE HISTORY
$v- Cwata
---
110
lF
XFL = 2409.52
IL = 205.1
# = 19
11
10
IL = 169.23
F#= 18
RULE HISTORY
LK
EFL = 3052.6
IL = 252.1
T# = 24
k
RULE HISTORY
.
W
A'1-
,
11114 C~Minptw
S't-al
C-
yneCiEK~L-edal900
S'1ume39e
ua asoe
111
astns
,,,iA~
Eew
'
"
d
k
ten o
In
00004
XFL = 1178.53
IL = 281.65
X# = 25
-- 0
/
I
XFL E 1548.14
IL = 295.22
U#= 17
/V\
10 Wf27F
-
XFL = 1569.93
IL = 299.67
# - 22
1
112
I ~
...
.. ..
. ....
-
-.. -...
0074E
IFL =
#0
1140.77
IL = 215.83
x# = 19
RUI
RULE
HISTORY
-
-
26S
-
A
.8-
4
I lef
,,.1
-
met N
~ Q w ow
4
12 -%ft
6sy
"0 Edw
5~
clwi
C
' Agerop
sd
C
d
oa" apsdalNe
1
IFL
= 835.51
IL = 217.86
I# = 21
25
1
RULE HISTORY
44
I
8 =wtot=8I
ow
*& 9~t
13
r
Cft
" -%ft v
10
:4
lmw
w Pmeow ,yne *
aloe
oowaaisd
OO7EY
TFL = 988.58
IL = 221.74
# "22
'I
Ru
A, 8
t s
s
4 26'.
~
RULE HISTORY
-7
A
t
a Icrlwe
6e
10
13
"%
a
MP Nft 6
-9
n
088.86 88stmViiapp.8..8na
Mi
88
" Itef . sp~e Cww m*ptas ft Ism
88
828s6SelmiesepV=l~d1
108fi6Sw.8m~ls'0p.88tfc.
113
N
%
--8.~~
-
-
0o ooma
XFL = 950.62
IL = 229.0
X# = 29
er-
RULE
R
2
RULE HISTORY
-
J
4
ysmQ.Wvr*
0pte N a
$I, OSyn Pow ws epsadNa2
%svm
w o
Iytm claptnins
Oti 5 Sste G Ws apMX Wlte 21
94 ".s yse Clos"
nes w w od
sq CSA#a6 d22
Sytmie'pan
o"- CdeMO.mae'phdt ed2
-
0 -M" sv
I1 ltw.
12
3
8,- ne'p
Syu
,d
Adaloe2
IFL = 1130.65
#7
IL = 255.31
X# =25
RULE HISTORY
Cor a pp nr m eas
uv
S%
6
C m'ape
ysm
?
lMd
XFL = 800.0
IL = 168.93
Z#t - 17
a5%l
0,
i#
-;a r
RUL H
114
$SO
Syste
Ciuse
W~m
ntie2
1
IFL = 1269.17
IL = 243.15
X# = 22
WU
4
25R
RULE HISTORY
4
1
Cloe " 4 m ad
0 er6 syle
as 6 s*. Cwe phda ont
4 A-l 6 - yimCnsaesda aal
IFL = 1074.44
IL = 236.25
E# = 22
RULE HISTORY
RULE 6 aST
'R5ul -
ClowY
yls
b 9d
-
Cl.Ws .01s n lids1
yseC..we p-le t oe
1- 21-
10 OD65
IFL = 883.43
IL = 206.93
7#
21
RULE HISTORY
4 uS.-$ytlCks-, ft~na~me
SAde
Sls-
115
ystem
-con
cbw ae-pp-oa~aet
CD-
asise
IFL = 1355.3
IL = 307.61
Z# = 22
P
YFL 833.3
EL = 220.38
T#= 22
eo
IFL
= 1248.62
= 314.76
X# - 32
/
IL
'A
:,
116
Ma6syst C--s V
an s- Qas" pheahd=-1
.ena
Nn
A
to
WO37D
XFL = 1030.17
IL = 298.69
F# = 34
RULE HISTORY
4
2e6
'Asm ineapeatne2
-neeslu a a
de
5-
P~ .yte
16 'R- 6 6yal
W-/apid
is'iuoasy.-e
C
Witt"
C..*s'
iloe2
1t
4
IFL = 817.57
IL = 227.45
1# = 32
RULE HISTORY
,
-
-
-I
I
Wi
14
-
SyimC ns
PPss t N d
"oMl- 6 9-te C-ue~lie
-ad24
IFL = 1004.78
IL = 257.98
7# - 31
RULE HISTORY
lu
6- SO-te cowe W..as
m 106- 5s-,
ci,,w
ap~s
tM 5
k id 2'
%d 6 9y,,t- Ctt-,' qtpte
18Aa6 sys- Cw -W- - ne st-,id 20
Ma6 Siml as'teleasrn 10
-R
1RW
117
0l t-od
7
1
p
IFL = 1411.54
EL = 325.4
1#
4 .~
4
HIS fOR"
-
Pluj
-
-
N1
IFL =832.59
EL = 212.97
X#= 27
aa
ytmcas-aaea
ne
a Mie
tiSysema Ne
a mue
yste
6apartat Md2
Cisa^apped
Ckng
RULE HISTORY
TFL = 1547.6
IL = 311.67
T# - 28
A
118
2
.
p
= 34
..........
XFL = 1248.62
EL = 314.76
X# = 32
A
'1
4
RuLf
25%
RULE HISTORY
FL9 ( 51 5T
o'pphfd e
%A& 0 6dS~ teCkW
:2 "%
8~ammlws-ppw da M
eC.Wftoppwetla
"y
10 .io
,? Ai6. S" sCbweases~d2
,a %daSee~ae un-u ai
is
ftf , 210.17 po N
A
FFL = 851.59
EL = 210.17
X# = 23
/1
'1~
5.-
23
RULE HISTORY
4
t-77~
~
Conk
t
a
P
ckw t- apsd
ID caM
XFL = 817.57
.54
IL
$\
#
I,
_
A
= 227.45
32
A
4..)
RULE HISTORY
U'
s
am V-- ==:=eeaee&Nog
Is -&"
Is %m s c f*wasM-irn a No W
cmw WPM
a Nd
fl
iV
119
ori
EFL = 1004.78
IL = 257.98
#= 31
V
RULE HISTORY
p p|
sl
-
o
s- -
iYmY
-,
IFL = 909.25
IL =223.1
E#= 26
ftl 6 y m w w.*weshe W- 30
aoe2
is Rs S se CI-1s mewse
1l
RU
1H STORY
-
'p
4
4
y
IFL = 980.06
EL = 279.51
1# 35
R25%
H
RE
RULE HISIORY
V
I'
oll l
\
.--
20
,,
120
-
:
m w 2
Ma
s ae appWe
.-
.
...
.3
tgoft 20
fiv-= 44 ytmcsaoea~n22
XFL = 435.0
IL = 111.5
# 9
RULL HISTORY
-l
XFL = 549.15
IL = 177.1
1# = 15
-A
RULE HISTORY
10
W0514
IFL = 369.93
IL = 126.95
-# 14
i
RULE HISTORY
121
XFL = 776.41
IL = 199.72
1#= 19
A,
-
it.
1
*
A
HULE HIS FORY
IFL
I
= 511.33
= 182.47
# = 14
IL
f
RULE
A,
HsTOR
XFL = 730.05
IL = 246.79
1# - 26
RULE
4
122
HISTORY
XFL = 487.85
= 190.36
X# = 21
IL
Ru4
251
RULE HISTORY
-4
IFL = 511.33
TL = 182.47
7# = 14
RULE HISTORY
IFL = 524.79
IL = 166.6
-# 17
t
a
RULE HISTORY
-j4
123
IFL = 587.26
IL = 136.68
I# = 13
A
IV
RULE HISTOR
EFL = 1037.31
IL = 255.58
# = 22
RULE
All4
HISTORY
S.-e Canapad:Ne
i 3".11 r- -ass
ago
ari
%
XFL = 495.0
IL = 111.83
T# - 9
PULE HISTORYv
f
124
10 . mw1
4
4
4
IFL = 646.72
IL = 189.34
I# = 17
4
R l A 26%
,A
2v,
RULE HISTORY
-~
~-.
7
'o
CbWs Ssa o opftsssd stiafs
Satis~lue-dulleethmar12
0 p waa
apb
ytl hn a N 13
6: by-ma COweor Pw ise
"Rl
"Rulm
d
XFL = 695.55
IL = 172.05
I#= 13
4
4
4
4
7
.4
4'
RULE HISTORY
Sms seo-cb.-Now~=Nn 2
90 0OA25
4
4
14
1
EFL = 644.32
IL = 167.15
I# =18
4
44
I,
4!
~
14
Rad
4 25%
/
RULE HISTORY
'4
-I
%ft I Cyt low 4e-P~ 11~me
wieo ytmsCcsapm a
ftf "
13 %df6 ., te~na !!!- da !-
125
13
IFL = 584.39
IL = 163.29
X# =22
4
~1
RULE HISTORY
p.
4
r
W.Ws 406 "n-awe aa
-
0 ouo
EFL = 465.0
IL= 115.64
# =9
11
11
lf5
RULE HISTORY
IFL = 675.0
IL = 130.37
r# -
5
*5
9
A
RULE HISTORY
I,
Sw
126
6 Sste afa- e gz d .o
10 00,1E
EFL = 465.0
IL= 115.64
#=
9
t
'
RULE HISTORY
' R
5
i
,
go-te
Cice'
aow e o
QD IA)4ft
FFL = 581.69
EL = 146.11
X# = 13
9
i
i
RUL
E HISTORY
4 le6 S.-te
I
I
Ckye
IFL =
6
~6
1486.59
IL = 401.68
l# - 26
A
Ii
RULE
HISTORY
\N
.4 l..
127
.... c,,,....4..4.4
.444
use Nw1
IFL
4,
= 741.62
EL = 286.51
X# =30
j
IFL = 1098.83
IL = 259.69
4
7#= 24
y
A
7a aSya c-e pea tsm
i
A
IFL = 1225.53
4,
IL = 311.68
1# - 32
2 na
sysemca~-
a 9un6
128
sgo i
$y0-e C
m'
N
ae
24iod
C
References
Akbarzadeh, M., Van Mele, T., & Block, P. (2014). Compression-only Form finding through Finite Subdivision of
the Force Polygon. IASS-SL TE 2014 Symposium "Shells, Membranes andSpatialStructures: Footprints".
International Association for Shell and Spatial Structures.
Akbarzadeh, M., Van Mele, T., & Block, P. (2015). On the equilibrium of funicular polyhedral frames and convex.
Computer-Aided Design.
Allen, E., & Zalewski, W. (2009). Form and Forces: Designing Efficient, Expressive Structures. John Wiley and
Sons; 1st edition.
Applegate, D., Bixby, R., Chvital, V., & Cook, W. (2006). The Traveling Salesman Problem (2nd Printing edition
ed.). Princeton University Press.
Baker, W., Beghini, L., Arkadiusz, M., Carrion, J., & Beghini, A. (2013). Maxwell's Reciprocal Diagrams and
Discrete Michell Frames. In Structuraland MultidisciplinaryOptimization. Springer.
Bathe, K.-J. (2006). FiniteElement Procedures. Cambridge, MA.
Beghini, A., Beghini, L., & Baker, W. (2013). On the Layout of Least Weight Single Span Structure with Uniform
Load. In Structuraland MultidisciplinaryOptimization. Springer.
Beghini, A., Beghini, L., Schultz, J., Carrion, J., & Baker, W. (2013). Rankine's Theorem for the Design of Cable
Structures. In Structural and MultidisciplinaryOptimization. Springer.
Beghini, L., Carrion, J., Beghini, A., Arkadiusz, M., & Baker, W. (2013). Structural Optimization Using Graphic
Statics. In Structuraland MultidisciplinaryOptimization. Springer.
Bendsoe, M. P. (1995). Optimization ofStructural Topology, Shape, and Material. Berlin: Springer-Verlag.
Benr6s, D., Duarte, J., & Sean, H. (2012). A New Palladian Shape Grammar. InternationalJournalofArchitectural
Computing, 10(4), 521-540.
Block, P. (2009, June). Thrust Network Analysis: Exploring Three-Dimensional Equilibrium. PhD Thesis. MIT PhD
Dissertation.
Bow, R. H. (1873). Economics of Constructionin Relation to FramedStructures. London: E. & F. N. Spon.
Cagan, J., & Reddy, G. (1995). An Improved Shape Annealing Algorithm for Truss Topology Generation. Journal
of Mechanical Design, 117, 315-321.
Courant,, R. (1943). Variational methods for the solution of problems of equilibrium and vibrations. Bulletin of the
American MathematicalSociety(49), 1-23.
Cremona, L. (1890). GraphicalStatics: Two Treatises on the GraphicalCalculus and ReciprocalFigures in
GraphicalCalculus. Oxford: Claredon Press.
Culmann, K. (1864). Die GraphischeStatik. Zurich: Meyer und Zeller.
129
Dom, W. S., Gomory, R. E., & Greenberg, H. J. (1964). Automatic Design of Optimal Structures. Journalde
Mecanique, 3, 25-52.
Fivet, C., & Zastavni, D. (2013). Constraint Based Graphic Statics: New Paradigm of Computer-Aided Structural
Equilibrium Design. J. lASS, 271-280.
Flry, S. (2015). GOAT: Optimization Solver Add-on Component for Grasshopper. Vienna.
Geyer, P. (2008). Multidisciplinary grammars supporting design optimization of buildings. Research in Engineering
Design, 18(4), 197-216.
Greenwold, S., & Allen, E. (2003). Active Statics. Retrieved from
http://acg.media.mit.edu/people/simong/statics/Start.html
Hrennikoff, A. (1941). Solution of problems of elasticity by the framework method. Journalof appliedmechanics,
8.4, 169-175.
Koning, H., & Eizenberg, J. (1981). The language of the prairie: Frank Lloyd Wright's prairie houses. Environment
and PlanningB: Planningand Design(8), 295-323.
Lachauer, L. (n.d.). Interactive Parametric Tools for Structural Design. Zurich: ETH.
Lee, J. (2015). Grammatical Graphic Statics: Rule-based Generation of Diverse Equilibrium Structures.
Massachusetts Institute of Technology.
Lee, J., Borchers, S., Su , I., Sun , M., & Wasef, A. (2014). Roof Structure Proposal for MIT's Hayden Library
Courtyard. MIT Master of Engineering Project.
Liem, Y. (2011). Graphic Statics in Funicular Design: Calculating Force Equilibrium Through Complementary
Energy. Graduation Thesis. TU Delft.
Malcolm , C. (1907). Elements ofgraphic statics.
Maxwell, J. C. (1864). On Reciprocal Figures and Diagrams of Forces. Phil Mag 26, 250-261.
Michell, A. (1904). The Limits of Economy of Material in Framestructures. Phil Mag 8(47).
Mitchell, W. (1991). Functional Grammars: An Introduction. In Reality and Virtual Reality (ACADIA 1991) (pp.
167-176). Troy, NY: ACADIA.
Mueller, C. (2014). Computational Exploration of the Structural Design Space. PhD Thesis. MIT PhD Dissertation.
Orponen, P., & Mannila, H. (1987-28). On approximationpreservingreductions: Complete problems and robust
measures. Department of Computer Science, University of Helsinki.
Oxman, N. (2010). Material-basedDesign Computation. Doctoral Dissertation, Massachusetts Institute of
Technology.
Rankine, J. M. (1858). A Manual ofApplied Mechanics. London: C. Griffin and Co.
Reddy, J. (2005). An Introductionto the Finite Element Method. McGraw-Hill.
Rippmann, M., Lachauer, L., & Block, P. (2012). Interactive Vault Design. InternationalJouralofSpace Structures
Volume 27.
130
Rozvany, G., & Lewinski, T. (2013). Topology Optimization in Structuraland Continuum Mechanics. Springer.
Schrens, M., & Kotnik, T. (2013). On the Extension of Graphical Statics Into the 3rd Dimension. In Structures and
Architecture: Concepts, Applications and Challenges (pp. 1736-1742). London: Taylor & Francis Group.
Shea, K., & Cagan, J. (1999). Languages and semantics of grammatical discrete structures. Artificial Intelligencefor
EngineeringDesign, Analysis and Manufacturing, 13, 241-25 1.
Shearer, M. (2010, June). Analyzing and Creating Forms: Rapid Generation of Graphic Statics Solutions through
RhinoScript. Master of EngineeringThesis. Massachusetts Institute of Technology.
Sondericker, J. (1903). GraphicStatics: With Applications to Trusses, Beams, andArches.
Stiny, G. (1980). Pictorialand FormalAspects of Shape and Shape Grammars (InterdisciplinarySystems
Research). Birkhauser.
Stiny, G. (2006). Shape: Talking about Seeing and Doing. Cambridge, MA: MIT Press.
Stiny, G., & Gips, J. (1972). Shape Grammars and Generative Specification of Painting and Sculpture. In
Information Processing 71 (pp. pp. 1460-1465). Amsterdam.
Stiny, G., & Mitchell, W. (1978). The Palladian grammar. Environment and PlanningB, 5(1), 5-18.
Stromberg, L., Beghini, A., Baker, W., & Paulino, G. (2012). Topology optimization for braced frames: Combining
continuum and. EngineeringStructures(37), 106-124.
Uspensky, J. (1937). Introduction to MathematicalProbability. New York: McGraw-Hill.
Van Mele, T., Block, P., Ernst, C., & Ballo, L. (2009-2012). eQUILIBRIUM: An interactive, graphic statics-based
learningplatform for structural design. Retrieved from http://block.arch.ethz.ch/equilibrium/
Van Mele, T., Rippmann, M., Lachauer, L., & Block, P. (n.d.). Geometry-Based Understanding of Structures.
Zurich: ETH.
Varignon, P. (1725). Nouvelle M&anique Ou Statique. Paris.
Wolfe, W. S. (1921). GraphicalAnalysis. New York: McGraw-Hill Book Co. Inc.
Zastavni, D. (2008). The Structural Design of Maillart's Chiasso Shed (1924): A Graphic Procedure. Struct Eng Int:
J Int Assoc Bridge, 247-252.
131