The author hereby grants to MITpermission to reproduce and to distribute ... By combining shape grammars with graphic statics, the generative ...... of external forces (applied loads shown in blue, reactions in yellow) mandates: b) .... diagram with clear labels (Figure 3.1 lb), and 3) rule history, information and ..... Page 50 ...
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
'#
---
~
