In the following article, Andreas Kopřiva Lernis, Architect Engineer and Alumni of the Postgraduate Program in Parametric Design with Visual Programming in BIM, presents his experiences and thought processes relating to computational design methodologies, and also, how he utilized generative and parametric design to develop his form-finding and design skillset. He does it by providing three specific examples that are most illustrative and revealing.
My design path has been convoluted and winding over the past 15 years, having started as a 3D modeler then moving on to digital sculpting, and now moving into computational architecture, implementing parametric, generative and emergent design methods for form finding and optimization. Due to this diverse range of experiences, I have opted to focus and present three specific examples which I consider to be milestones on this ongoing journey.
Through these projects (and their associated developments) I have furthered my understanding of using digital tools for architectural exploration and have developed a more structured and programmatic mindset when it comes to solving design and form related issues.
Example 1 – A Fractal Pavillion
One of the first experiences I had in this field was using Mandelbulb (the 3D representation of the Mandelbrot set developed in 2009) software to generate fractal forms from combining formulas. Through these experimentations I began to value the unpredictability and the complexity that an algorithmic approach to design could offer, as a lot of the shapes being generated would have been practically impossible to sketch out conventionally.
Things got infinitely more interesting after the 3D models generated were exported from the software and as such, were made available for additional processing and manipulation. Upon getting those fractal forms exported, I utilized conventional and sculptural modeling pipelines to start deforming these shapes to form intentional architectural constructs.
One of the first structures I ended up presenting was a fractal pavilion which consisted of a generated module which was subsequently segmented and arrayed to create a functional space.
At this early stage, I was considering monolithic structures primarily, without considering building up structures from smaller parts. It could, in a way be considered a more organic and biomimetic approach referring to structures which develop holistically as one single entity instead of consisting of modular components. The next example attempted to create aggregations from generated building blocks.
Example 2 – Making Organic Building Blocks
For this series of projects I opted to segment the production pipeline to two distinct parts. The first part would serve as a continuation of the previous methodology of generating shapes using emergent design paradigms and general computational architecture workflows. This would involve setting up a virtual, experimental playground of sorts which would focus on form generation.
Part two would focus on a more hands-on approach to assembling and manipulating those forms to create aggregated structures. So, summarily, it was a hybridic approach using purely computational and generative methods for one part of the process but allowing for a manual manipulation of that generated data for the end result.
Part 1 – Exploration of Emergent Design
In this stage I experimented primarily with BOIDS flocking simulations and stellation based growth algorithms. These were recursive block additions to the parametric Grasshopper environment which enabled the creation of an emergent playground of sorts.
The above script illustrates the setup used and how this recursion system was implemented to facilitate ‘animating’ (or in this case rapidly iterating self-referential loops) sequential interactions between points (flocking agents) and a central attraction point (in this case a dodecahedron shape). By tweaking various behaviors, the agents would be attracted to, repulsed by, stick to and more to both a designated shape and themselves. This allowed for multiple shapes and iterations as almost each ‘frame’ (or step) could yield a potential shape.
The growth was driven by the following script:
Again, a recursive loop component was used to enable successive iterations. The ‘growth’ was facilitated by randomly selecting a series of points over a surface which would expand and subdivide outwards.
The above algorithms generated a large quantity of forms which would have been practically difficult to generate through non-computational methods. Furthermore, any bias or intentionality was also removed, which led to the generation of forms beyond the scope of my own understanding and capability.
Part 2 – Emergent Parametric Sculpting
The modules created in the previous step were ‘baked’ into meshes and imported into Zbrush, a powerful mesh sculpting software. Through using its built-in set of deformers and arraying tools, these initial modules were arranged and manipulated into larger more complicated structures.
To begin with, the generated artefacts consisted of single modules, for the sake of keeping things simple to begin with, which built up larger expressions and structures.
The above forms are examples of this approach and served as ‘feasibility’ studies in a way, where I was trying to see how far I could push a single building block type. After producing a number of the above morphological vignettes, I moved to the second stage which involved creating a large scale architectural construct combining different toolsets and techniques.
The above schematic outlines how that fundamental architectural form was generated through using a series of generated parts, arrayed primitives, and sculptural components. By combining a manual approach with a parametrically driven methodology, I managed to create a structure that I couldn’t even begin to consider without using computational architecture methods and which had a degree of morphological complexity which would have been difficult to manually consider and construct.
Example 3 – Scripting Buildings
The final example which I’ll be sharing in this article was part of the submission for the Postgraduate Program in Parametric Design with Visual Programming in BIM which aimed at developing participants’ understanding of algorithmic thinking and the concept of perceiving data as something that can communicate and generate form across applications.
Following with similar themes as those presented, we were provided with an IFC of a plot alongside a building requirement brief and were to design an algorithm to structure that building.
As this utilized the newly released Rhino.inside Revit extension, it was feasible to run an instance of Rhino (and Grasshopper) within the Revit API which ended up facilitating an interesting level of data abstraction and translation. As is hopefully evident by now, I prefer a hybridic workflow so I connected curve layers within Rhino with nodes which would generate structural components within Revit.
This whole endeavor worked as a great example of data structures and information flow. Through the algorithm, a simple vector shape drawn in one software, would drive the creation of a robust, information rich wall structure in a different software, which could then be represented in a real-time visualization software with accurate lighting and environmental details.
Through this setup, the opportunity to try different forms and to see these forms within a 3D context was facilitated and accelerated. This allowed me to iterate more and to fail faster within a much shorter period of time, as manually placing components and walls was offloaded to the algorithm.
The final model as presented in the rendering above, ended up being driven by 4 curve layers with different level constraints applied to them (i.e. curve 4 would generate slabs and walls from floor 4 to floor 10). The glass façade components were generated by separately subdividing those curves and linking those isolated and parametric extents to a different building component type.
Conclusions and thoughts
The above examples have all helped me develop my understanding of not only computational architecture methodologies, but of design logic and morphological manipulation and causality in general. Not only was I expanding my form language library but I was gaining a better understanding of structural support methods, especially when I would proceed to 3D print the generated models.
Furthermore, unlike my relatively chaotic journey in this field, the example provided follow a certain linear progression.
The first allowed me to see the possibilities and opportunities that computational architecture methods would allow. It enabled me to explore and begin understanding forms whose generation would have been practically impossible with non-computational means.
The second allowed me to further refine this output, by expanding my digital vocabulary to include emergent and experimental form-finding methodologies, and to begin considering aggregations and additional complexity through combining these methods.
The third allowed me to explore more practical applications of such workflows. How to automate and optimize pipelines by setting up systems of constraints and dependencies and how to accelerate the initial design stages through rapid and relatively effortless iteration.
Of the pipelines described above, this was the one which had the most significant real world applications, as it could be applied to a wide range of projects from skyscrapers to single residences, while the other methods worked best in terms of a purer exploration of idealized forms. Overall, I sincerely hope that this collection of examples has been helpful and I hope that it served as a good motivator to consider adding parametric and generative toolsets to your pipeline.
Author: Andreas Kopřiva Lernis, Architect Engineer and Alumni of the Postgraduate Program in Parametric Design with Visual Programming in BIM. Dynamo, Grasshopper and Python.