Above displays daylighting analysis used with Grasshopper and Ladybug.
Aqua Utopia|海の底で記憶を紡ぐ

izzy's playlists!
h
noise dept.

No title available
No title available
occasionally subtle
Show & Tell
sheepfilms
Mike Driver
almost home
ojovivo
Peter Solarz

JVL
Sade Olutola
🪼
NASA
KIROKAZE
RMH
art blog(derogatory)

seen from United States
seen from Spain

seen from Italy

seen from United Kingdom

seen from Türkiye

seen from Finland
seen from United States

seen from United States

seen from Canada
seen from Spain
seen from Netherlands
seen from United States

seen from Canada

seen from T1

seen from Iraq

seen from Netherlands

seen from United Kingdom

seen from Malaysia

seen from Ireland
seen from Germany
@parametriccourt
Above displays daylighting analysis used with Grasshopper and Ladybug.
Analyzing Wind Load with Karamba
We are going to take the same geometry and isolate point loads on the shell of the structure in order to see how wind load will affect our building. In order to do this, we need to differentiate points on the outside versus points on the inside by culling our list of points. We will then get the area where the points intersect the surface in order to apply the wind load.
First we are going to use our Points from our LineToBeam component to plug into a Line SDL component from grasshopper. This is going to compose our Wind Load. Use a Vector Y component to insert into the Direction input of the Line SDL component, and a slider to pick any number to assume the Wind Force.
Above you will see the directional Wind Load. (in the Y direction)
Next we need to take our original geometry (LOFT) and plug it into a Geometry component. From there, plug the Geometry component into the Brep Join component and flatten this.
Then, in order to get the points isolated on the surface, we are going to use the Brep intersect component.
You will then plug your wind load and the Brep into the Brep Intersect component.
Follow the above in order to cull the list of points - True being the points that are on the surface. From here, you will be able to see the points isolated on on the surface.
As seen above, you are going to take your isolated points (The Culled List) and use the Load Component from Karamba, but this time select Point load. Plug the Cull into the PosInd input. Then we are going to apply a Wind Load force (use Vector Y, with a value of -100) in the Force input, and finally, in order to differentiate this load case from the Load 0 (Original Gravity Load Case), input a number slider with a value of “1″ and then this will be Load Case 1. Now we can plug this Load into the Load input of the Assemble component, (hold shift) to have 2 loads plugged in. Then flatten the loads so they all come in at the same level. See below.
We can see the result with the combination of both gravity load and wind point loads applied. The view shown below is with Axial Stresses.
Although I would have to check the measurements, etc, it appears the building would blow over. Our wind input could be far too high though, in this case, but regardless, this will give a visualization on Axial Stress coupled with wind load.
Updated Karamba Analysis
---As reviewing this, please refer to the previous “Test, This is Only A Test” Karamba post, as the steps that are followed are the same. The only further step that occurs is the Wind Load Analysis.
So what I’ve done different from the last attempt at Karamba is to isolate the geometry into Pipes, Floors, and Structural Facade (red) as you see here. From here, I’m creating one mesh to treat the entire building as one interconnected structural element.
To understand further how I did this - you can follow along with this wonderful instructor’s series of tutorials found here. https://www.youtube.com/watch?v=_znWGFvZImM
Fig. 1 Shows the geometry isolated into a mesh.
Fig. 2
Fig. 2: We are doing the same thing as before where we are taking the Mesh Edges and combining them into a Line component, and then flattening that. Use the Remove Duplicate Lines component to make sure that we don’t have multiple lines (or repetitive load calcs).
In Fig. 3. We are converting these lines to Beam, using the Karamba “Line to Beam” component.
Then we are plugging it into the Elem input of the “Assemble” Karamba component.
Next, in Fig. 4, we show how we are isolating the points lower than a certain number in order to direct the load into the ground- just as a building would be as loads would be carried into the foundation.
Fig. 4
You can see the points isolated in Fig. 5
Fig. 5
Further, we are going to input the data into the Support component. Selecting Transitions and Rotations (the black dots in the components) means that these are fixed and we are assuming no Translations or Rotations.
Further, as we did before we are going to plug in a gravity load into our load input. Everything should be plugged in similarly as follows:
Then, we plug the model into the Analyze component and further into the ModelView component. This is where we are going to start to be able to see visual representation of data. Immediately, we can see that the Deformation that will occur is large, this is large due in part because the structural supports are limited to one side of the mass.
Green represents “Deformation”
By raising the “Supports” slider in the ModelView, we can increase our support capacity at the base. (Shown below)
The BeamView component is going to allow us to see different render settings.
Selecting Axial Stress will allow us to view the Axial Stresses, as well as get numeric output (in mm) or stresses to further analyze with our structural engineer. You must make sure that your model in Rhino’s units match accordingly as Karamba’s units are automatically in mm.
Below is how the render view of Axial Stresses looks.
A detail shot of the stresses. (Red, but not the fixed points)
Plugging in a Panel from the Analyze component will give you the Displacement value.
Further, you can use a component called “Beam Resultant Forces” to acquire data like Moment and Shear forces.
This is the basics of analyzing a structure using Karamba. Please see the following post to see how we analyze Wind Load with Karamba.
This is a Test.... This is Only a Test: Structural Analysis with Karamba
Fig. 1
Prologue -
Addressed to: Professors Rajaa Issaa + Michael Riggin, Grasshopper III: Spring Quarter 2015. New School of Architecture + Design.
Choosing Karamba as an analysis method seems the most rudimentary and basic analysis to start with. Seeing if the building will function structurally at the get-go makes sense. I didn’t have to change anything about the project as far as design thus far because all of the inputs necessary are available and the structure was already considered in Pre-Design. After this mini test with Karamba on the main spiral columns, I realized that I need to make a greater effort to link multiple structural components for analysis, ie: floors (which are attached to the spiral columns for nodal stresses - not shown), horizontal beams between the spiral columns (for cross section, transverse, or horizontal loads + their transfers), and even the facade or ribbon faces (the glass window portion between these columns and beams). To simplify things, a mesh from the ribbon portions of the definition will allow a more sound structural analysis and better visualization for the bending, deflection, etc.
The result of this analysis yielded an obvious understanding that a gravity load on these spiral columns will yield an extreme result - warranting the building currently not structurally feasible (which could be predicted as the spiral columns, as mentioned, are not connected to their other structural brothers and sisters.) Further and more concise analysis can pose the parameters and the questions: What are the best connection points? How many? What yields the least amount of shear? How can I achieve the least amount of deflection? At the very least, numbers can be gathered out of this as empirical data for parameters.
Also, going ahead, changing the ribbons into one large mesh, I can then observe the wind deflection, decide the best orientation of the building, or further even the orientation of the individual louvers.
The result below means that more inputs are needed, or the input needs to be simplified on the building as a whole. Going forward, will prove yet another interesting/exciting academic and professional adventure.
The Process
Here I take an existing Grasshopper definition of a tower (Fig. 1) that was worked on with my partner Ryan N. Conner and I and apply a simple structural load analysis to the main columns composing the majority of the main structure. This is a beginning analysis in order to visualize and see the load deflection results from a gravity load. Just for the example’s purpose, I am only isolating the main structure, and disabling all other components (ie: floors and thickness) - this, later, I will understand that enabling the floors will allow for a different deflection result as the main columns will have nodes connecting to the floor edges. For this purpose, lets just analyze how the main structure is working.
Fig. 2
First and foremost, I am going to start with isolating the PLines found (within the piped structure) [later, will analyze the piping]. I need to convert my lines to beams, so I am going to pull down the “Line to Beam” component from Karamba. This reads the existing geometry in Rhino and converts it to structural language in Karamba. Karamba does not yet know where the geometry is supported or what loads are applied to it. (Fig.2)
Fig. 3-
From the Assemble Tab, I pull down the Assemble component so that Karamba can start reading the geometry as structural numbers. I plug my Line to Beam Element output into the Element input of the Assemble component. (Fig. 3 - the first and last components highlighted in purple)
Next, we want to say that the base, is where there are fixed points that are taking the load. This is assumed in most buildings that the foundation is taking the load at fixed points (that do not move). For this, we need to isolated the points. The way we are going to know what points are at the base are if their z coordinate is below a very small number (like, for example, 0.1). In this particular case, our lowest points are equal to 0.1, so I’ll choose a little bit higher of a number for my slider (.113)
We are going to use the Deconstruct Point component in order to isolate these bottom points (Fig. 4) (below)
Fig. 4
So we are plugging the Pts from the Line to Beam component into a Deconstruct Point component. We will then use the Less Than component in order to isolate the points less than .113. Cull will then isolate these.
Fig. 5
I will then take the List from the Cull component, and utilize a Support component from Karamba. The Support component will create “Conditions” located in the support component. Marking all of these conditions black (filled in circles) says that Translations are not going to be able to move (T) and Rotations are not going to be able to rotate (R). We then plug this into the Support portion of the Assemble component. (Fig. 5)
Finally, we need to apply a load. For this purpose, we will use a Karamba component just to apply a Gravity load. The Gravity load component already has a set number for the gravity so an input is not needed although one can be implemented. (Fig. 6)
Fig. 6
See above, the Gravity Load is plugged into the Load input of the Assemble component. These are the minimal requirements for structural analysis data inputs. CroSec, Material, Joint, Set etc. can be additional inputs. As you can see above, a Z vector is hovering next to the Loads component with a slider with -100. This can be inputed later for increased load -but as we will soon see this will not be needed for this particular case.
We will not see any visual information yet, at this point Karamba is just receiving and calculating numbers.
Fig. 7 - Here Karamba is Analyzing the data.... this will give you a number, if you hover your mouse over it, which will be the maximum displacement. This number is used in mm, so keep this in mind as your model also needs to be in mm, and you can use this number for structural calculations.
Next I want to take the data and plug it into a visualization component. This component is called ModelView. This is found under the Results tab.
Fig. 8
This component will give you the Deformation which is pretty significant as you can see (50). And visually, we can see this is quite ridiculous. (But keep in mind these columns are not connected to the floors as in the actual model). (Fig.9)
Fig. 9 (Green shows deflection - ridiculous! and purple shows load points)
Fig. 10
Next we can plug in a BeamView component. The BeamView component will give us more in depth analysis on the forces on the “beams” (in our case columns) (Fig. 10)
Here we can further analyze, and it will also give a thickness. From the drop down menu of BeamView under Render Settings, we can view different visual data. For example in Fig. 11 we can see Displacement selected. In Fig. 12 we can see the visual representation of displacement along the “beams” and it also gives a thickness.
Fig. 11
Fig. 12 Displacement Visualization in Rhino
Clicking Cross Section will give you a purple color for the analysis visualization. (Fig. 13)
Fig. 13
Finally we can look at the Axial Stresses
Fig. 14 Axial Stresses Analysis.
I repeated all of the same processes (component arrangement for the Pipes) To note: The Pipes are turned into meshes, first, in order to get the Lines. Again, this scenario is hypothetical, because you are going to get over 10,000 lines (which theoretically become beams) out of your mesh lines, and this isn’t quite realistic (budget and material wise - although, we could consider a kevlar or some progressive material but this is an entirely other topic. [sidenote]. But here is a detailed screenshot of how the Pipe is turned into a mesh, the lines are combined and flattened, duplicates are removed, and then this information is plugged into the component in Karamba. (Fig 15)
Fig. 15 From the line component, you would then continue the same as above, plugging the line output into the Element input on the Assemble component and continue there. The deflection on this I found rather entertaining. (Fig. 16)
Fig. 16 Pipe deflection. It’s a smashed spider, and a building that structurally, will not work.... yet. (Don’t forget, we don’t have the floors considered...tune in next time to see if the building holds up.)
Skatescape : An Inline Skating and Skateboarding Landscape
Busan Biennale 2004
Project Team: Michael U. Hensel and Achim Menges
From: The OCEAN Design Research Association
“The OCEAN Design Research Association is a not-for-profit association registered in 2008 in Norway that conducts inter- and trans-disciplinary research in design across creative disciplines.”
via: http://www.ocean-designresearch.net/
The webpage achimmenges.net portrays Achim Menges academic design research as well as architectural and product design work
Karamba!
www.karamba3D.com/downloads
The Pro-Student version will include more components that you will need for extensive analysis. The Pro-Student version cost $30. (all amounts of beam elements and shell elements as well as other features are unlimited). For the purpose of analyzing the entire tower in this tutorial, a Pro-version may be needed. The expiration date is unlimited, so it may be worth the purchase.
If using Imperial Units (ie: inches, feet, etc.) select Imperial Units during the download.
If you need to change it back to metric units system, go to the Plug-in root file of Karamba - Program File: Rhino 5 - (whatever bit) - Plug-ins - Karamba... and change the configuration file (after this download) back to SI (Metric).
When selecting which folder to send Karamba to upon installation, the “/Rhinoceros 5 (64-bit)/ Plug-ins” selection may be missing the “.0″ (ie:
/Rhinoceros 5.0 (64-bit)/Plug-ins) therefore you may have to add the .0 to the installation path text.
*Karamba does not run on Rhino 4.
General Overview of Karamba
Karamba is a structural analysis program that is easy enough for both architects and engineers to use early on in the design. Because it is fully embedded in the parametric environment of Grasshopper it is also easy to combine with other optimization algorithms like Galapagos or Octopus.
Just to get one accustomed and primed we are discussing things like kips, load deflection (along beams etc), and further analysis can be done with regard to:
cross sections of loads
defining hinges on a structure
imperfections with regard to members and curvature
calculate global buckling
torsional buckling
beam and truss analysis
shell element analysis
placement of loads on elements or nodes
Material analysis (steel vs. concrete etc with regard to load ksi and psi)
General Overview of the Karamba categories:
License: component that contains all license info
Params: beams, loads, models
Algorithms: components for analyzing the structural model
Cross Section: contains components to create and select cross sections for elements.
Ensemble: lets you create models
Export: export of Karamba models to RStab or Robot via DStV file. (other structural analysis programs linked to AutoDesk and ANSYS)
Load: components for applying external forces
Materials: components for the definition of material properties.
Results: calculation results
Utils: extra geometric functionality that makes it easier to hand and optimize tools.
General Overview of Process:
Create wire-frame, point geometry or meshes for the structural model with Rhino or GH.
Convert wire-frame or point geometry to Karamba beams, meshes to shells.
Define which points are supports and which receive loads.
Assemble the Karamba structural model with points, elements, supports and loads. Optional: define custom cross sections and materials and add them as well. They reference elements either by index or user defined element identifiers.
Analyze the Karamba structural model
View the analyzed model with “ModelView” component. Deflections can be scaled, multiple load cases can be viewed together or separately. The “BeamView” and “ShellView” components can be used to generate mesh representations of stresses, level of material utilization.
(Karamba Parametric Structural Modeling User Manual Version 1.1.0 written by Clemens Preisinger, March 8, 2015) (here is a link to the manual - just print it, it will save you lots of time)
TUTORIAL
First, make sure that your Rhino units are in Feet. Not arms, not legs, but feet.
In Grasshopper: NSAD Students: Open the 4_NSAD_CDMIII_SystemDetailedPanelsTemplate.gh file example.
Other People in the World: Use the Paneling Tools to apply a UV grid to a mass.
1. Connect the wire from the paneling (Cellulate) component to a Line component (Flatten) to “Line to Beam” component found in the Model section.
Fig. 1 of Step 1. Line to Beam component.
2. Connect the Pts from “Line to Beam” component and plug it into a “Deconstruct Point” component Then plug the Z into the “Less Than” component. The Less Than component plugs into a “Cull Pattern” component (marked above with the red x). The “L” of the Cull Pattern (List) will receive its imput from the Line to Beam Points). (Why the.03 you ask? Because you would never have a floor that low) - Next, pull down a “Support” component from the Karamba Model section. Selecting the the 3 (T) Translation buttons to black means that 0 translation in the direction of the global x, y, z axis is occurring. (R is for rotation) .
Fig. 2 Showing the support points on the ground level.
3. Connect “Support” (from Step 2) component to the “Assemble” component from the Model section of Karamba. Connect the Model to “Analyze ThI” found in the “Algorithm” section of Karamba.
4. Now, we will talk about the Load, CroSec, and Material inputs from Step 3 and how to create these inputs. Below is Load. Input a Factor number slider into a Unit Z Vector component. Plug the Vector component into the vector input of “Loads” component from the “Loads” category of Karmaba. (Loaded, I know, just don’t get loaded while doing these steps) The “Load” component will plug back into the Assemble component from Step 3.
You can also select the Type of load in the Type of Load pull down menu. Let’s do Gravity for now.
***(SIDE NOTE) Both A and B are the SUM of U and V value from the U V Domaine values. (This is where the 0.136) And then 6, represents the kip for 1 floor. This is an estimate of load for the area of our example on an average floor. (This is assuming 6K is in 1 floor) - further research is needed to input exact kip amount for complex designs.
A drop down menu for the Load component is also available to select the type of load. For this purpose, we will use Gravity.
5. CroSec - “Cross Section” component comes from the Cross Section Section in Karamba. Here we are going to imput a Thickness for (wall thickness) - although for this case, we are changing the thickness of the material, so .1 is adequate for now. (stuctural frame) * We are not sure why this automatically goes to inches and not feet at this point - because it should read feet from Rhino. CroSec plugs back into Assemble.
You can also choose I-Beam or other kinds of Solids from the drop down menu.
6. For information on Material: “Material Select” component from the Material Section in Karamba, For more detailed information on the coefficient of materials, you can use the drop down menu to select the material - plugging in a panel will give you more detailed information on the properties. You will plug this back into the Assemble component. For more detailed information, you can specify a material and its properties.
7. From the Analyze ThI component, plug the Model output into the Model input of “ ModelView” component from the Results section in Karamba. Further, plug in the Model output to the Model input of the “BeamView” component found in the Results section. ***Now use Grasshopper to disable all other views other than “BeamView”
Fig. 3 Cross Section view on Render Setting
Fig. 4 Showing Displacement from the Render section (from “BeamView” component) -
Showing from TOP to BOTTOM of tower when selection “AXIAL STRESS”
8. Further, you can analyze. Wind Load. (Optional.) For Wind Load, you must connect the “Geometry” component to a “Join Mesh” component. If you do not have the “Join Mesh” component you must download a MeshEdit plugin from www.Food4Rhino.com The Pts from the “LinetoBeam” will connect to a LineSDL component and Cull Pattern component. MeshJoin component is needed as well as Rotate (so you can get the angle of the wind) Since we are in kips units we need to factor a Point Load and the wind point load amount data can be obtained from http://k7nv.com/notebook/topics/windload.html. Because the data on the website is on pcf (lbs per cubic foot) we need to convert this number to kcf (kips per cubic foot).
Fig. 5 Directional Wind load when viewing LineSDL
Fig. 6 Intersect Point to LineSDL which represents the point load intersections of the wind on the panels.
Fig. 7 Deformation of Structure with Wind Load
Computational Design, Progression, and Future Generation
Computational Design, Progression, and Future Generation
Explorations, Challenges, + Possible Future Solutions
Courtney L. Fromberg + Yangyi Situ
Grasshopper Spring 2015
Professor Rajaa Issaa
Abstract: Computational design processes have evolved over the last 20 years with the speculation that unification between disciplines within the realm of architecture is necessary. Throughout that unsolved difficulty, much advancement has been made with regard to generative modeling, building optimization, energy analysis, and materials development. To unite the fields for further optimization strategies in the future requires unifying factors that may lie in the exploration of morphogenetic design.
Computational design has come a long way. From inklings of wonderment of whether or not morphogenetic design can link discourses and cause cross- referencing data analysis, to knowing that it can, has, and now with the open source sharing of Grasshopper, will do so, excites one further to understand and explore its possibilities. People are curious of one another, and their surrounding environment. We all share the desire to search and explore, to understand, to help, and to make. It is through this process of sharing, searching, exploring, understanding and making, that we find letting go, the answers to creation.
As we have achieved the accomplishment of optimizing material and pattern organizations in order to enhance performance and increase efficiency, we learn that we are capable of much, but that leaving generative design up to self-organized chance really is where exists magic in the creation. Dangers may lie therein, but we are hopeful that if mimicking the Creator as closely as possible, perhaps we will be rewarded something wonderful that can do well for our brothers and sisters, and our world. We can utilize several tributaries of thought with regard to computational design to understand how different evolving branches acted in the past, present and will possibly help to contribute in the future.
Fig. 0 Leaf Venetion algorithm with different densities. (Gokman, A Morphogenetic Approach for Performative Building Envelope Systems Using Leaf Venetian Patterns)
As Alvar Aalto put it : “the large amount of demands and sub problems (from architecture) form an obstacle that is difficult…after I have developed a feel for the program and its innumerable demands have been engraved in my subconscious I begin to draw a manner rather like that of abstract art.“ We are struggling like babies taking small meandering steps to take this massive amount of data we are given through the evaluation of computational design and generative modeling, make sense of it all, and optimize it for the best possible solutions to form, structure, and energy concerns. We have found out its efficiency and effectiveness regarding its possibilities.
Fig. 1 (Otto, Frei, 1966)
Currently, computational design and generative modeling is being used to analyze everything from building envelope, form, and core, to material design and comparisons to those structures found in nature. For one, we are trying to analyze and develop optimal massing structures. We find problems lie therein later with communication between parties to ensure that this method is optimal. (Marcello, Eastman, 2011) Simultaneously we know that benefits lie in development of optimizing use of materials. As NASA explores use of morphogenetic design principles in their study of how computational design and algorithmic principles can help to develop design and manufacturing of tow-steered composite shells using fiber placement (Wu, Tatting, Swift, Smith, Thornburgh, American Institute of Aeronautics and Aerospace, 2009).
Fig.2 Fiber courses for fuselage shell showing varying fiber placement. (Wu, Tatting, Swift, Smith, Thornburgh, American Institute of Aeronautics and Aerospace, 2009.)
In 2011, Daniel Richards of Manchester Metropolitan University noted when speaking on evolving performance within component-based structures that “to date, design processes that facilitate the integration of ‘form generation’ and ‘spatial analysis’ remain under-developed” – and we can now question four years later if this is still as true when we see the many contributing bodies of people and knowledge with the open source database of exchange that programs like Grasshopper offer ( i.e.: Kangaroo, Firefly, etc.) We know that the repeated pattern of difficulties that shows up lie in our communication and network of exchange of information bridging over the various disciplines falling in the field of architecture (the age old scene of exchange between architect, engineer, etc.).
Fig.3 (Evonne Heyning, 2013)
With regard to biological considerations, we know the potential of this exploration is almost limitless, but this somewhat ontological exploration may be the key to the synergistic cross exchange of language and sharing of information to solve this problem. Meaning, a common goal that is the human exploration of truth and necessity for biological solutions (via an inherent need for survival solutions) may generate new models to offer receivers for input to link the various disciplines together, thus simplifying the complexity of ideas. But first, we have to start somewhere, and that possible solution may lay in the “letting go” that result from the outputs of morphogenetic design. It’s within the results found from morphogenetic design that the “ontological” becomes explored.
Whereas the ontological means to study the nature of being, becoming, existence, or reality, mimicking nature, via biological data inputs, analysis via parametric modeling, and resultants via morphogenetic design will signify all of those categories, with the mystery, excitement, and perhaps even non-argumentative results of the “becoming” the natural element to unify our fields of study towards a common goal.
We see that a natural inclination to argue for a “top down” approach in about building core development exists in the discipline of parametric design. “Design activities vary from high-degree of freedom in early design stages to highly constrained solution spaces in late ones, which entail large amount of design expertise. A top-down approach based on nested assemblies and custom functions is proposed to embed such a design expertise in reusable parametric objects.” (Marcello, Eastman, 2011) Naturally, this is understandable, as we saw Aalto mentions the need to start large with many inputs of information, and reel these factors in to come to a concise formula for solutions within building design.
Fig. 4 “Top Down” Approach(http://bestaboutpages.com/2011/12/12/made-by-shape/)
Marcello and Eastman argue that the “specific case of architecture entails a specific amount of knowledge in some design decisions which makes translations into parametric environments more difficult.” The authors further argue that expertise within the field of architecture is strongly based on “rules of thumb” from trials and error from previous experience, (Marcello, Eastman, 2011) and those parametric objects can be developed to nest what has already been learned in order to create the parameters to generate more concise solutions. Rather than relying on human expertise alone, we are entering this data into the computer, and storing it for future output and solutions. The use of this is to store what we know is empirical knowledge, and therefore to formalize it. In analysis of how to do this with an MCM (massing core model) and a SCM (service core model) Marcello and Eastman explain that while BIM allows for solutions regarding cost and automatic floor plan schedules for design solutions, a problem lies in finding a solution with regard to real – time updating of this information when designs are changed.
Earlier in time we see “As Clarke ( 1991) points out, the conflict between power and ease of use is further exaggerated by the divergence of the conceptual outlook of the design-orientated program users and the technically orientated program developers. And to add to the confusion, the various engineering professions use subtly different terminology. “(Hensen, Eindoven) Again we see, a pattern of difficulty of exchange between communicating parties who build the buildings, and the computer as the “middle man”. We see an opportunity for morphogenetic design to step in and take the reins with regard to “no argument” with resulting empirical and evolved evidence for design.
Morphogenetic design is defined as being “concerned with the breeding (or replication, mutation, selection and survival) of forms and structures according to a fitness evaluation function and the emergence of more complex systems out of the produced aggregations.” (Daru, Schnijder, 1996) In Daru & Shnijder’s “Morphogenetic Designing in Architecture - resolving controversies in and between design, research and development” we find out that the authors were intriguingly accurate when predicting some key nuances with regard to generative modeling within the sphere of computational design.
Fig. 5 (Otto, Frei, date unknown)
“The development of morphogenetic design opens new possibilities to bridge the gap between the different traditions.” The traditions Daru & Schnijder refer to here are the hermeneutical and empirical traditions of study within design and science. The authors point out that the “form generating acts” can provide better design studies that prototypes alone can, meaning that patterns and sequences generated from within the sphere of “emergent design” can offer much needed information that will interest all fields, thus causing greater cross-exchange and sharing of inputs which one can argue is derived from an inherently instinctual need for the ontological pursuit, and biological necessity.
How to make the computer, as a design partner, more “human” to ensure the safety in this pursuit is an obstacle that we may never overcome. Whereas we can see how necessary this is becoming as “to try to set-up a system that would enhance the design process by suggesting possibilities, has been preferred to an approach that emphasizes optimization and problem solving.” (Carranza, Self-design and ontogenetic evolution). Carranza importantly brings up that “societal development” can be considered a morphogenetic process.
When looking back to 1996 again with Daru & Schnijder’s discussion, noteworthy is the suggestion that “for the majority of architects, working within the artistic and hermeneutical tradition, the morphogenetic approach to designing will feel strangely familiar. The morphogenetic software programs developed so far …suggest a new way to explore and enjoy.” It is in this exploration and artistic approach that we find the natural inclination of intuition –following our design, natures design, we see the possibility of our intrinsic and intuitive minds formulating flowing ideas through fingers onto the keyboard, to commands and gut instinctual shapes and forms, informed through already acquired empirical evidence and data – to be released into the secondary tool of the computer, to, within a series of defined parameters generate an evolving model, random and beautiful as nature is. Our challenges going forward lie in further understanding the Creation and all of its properties. A caveat to that will be our ability to evolve our building materials to suit these needs. Because design research “about architectural designing could use the automatic registration facilities of the morphogenetic programs involved to automate empirical observations or quantitative analysis”, Daru and Schnijder argue that this will therefore unite the schools of thought i.e.: the artists and the hermeneutists and the technicians and the empiricists, especially the latter because of the empirical data put into the parameters. Where this gets tricky, lies in the unification of the schools of thought when we release the design to chance, organic evolution, or happenstance to see “how the plant grows”. Chaos exists in nature, and therefore, we must be wary that the advances of morphogenetic design come with it, the chaos and the chance. Where we really have an ability to hone in on our optimal ability to optimize, may be in the exploration of textiles and materials. As NASA uses parametric modeling to advance its fuselage structures utilizing different angles of fiber in varying manners for the structure of the overall form, we are able to see just how beneficial parametric modeling can be. It results in less material wastage, less touch labor time, and greater performance. (Wu, Tatting, Swift, Smith, Thornburgh, 2009) Applied to a building in this manner, it is safe to say all of the same things can be achieved.
Fig.6 (Gerken, Mark & Partner Architects, 2005)
Reviewing back to Daru & Schnidjer, “the hermeneutical researcher might ask global questions and get holistic answers with ethical and moral connotations” whereas “the empirical researcher on the other hand might ask more specific questions and get both analytical and generalizable answers out of his simulated experiments.” It is here that we can see the unification may occur. What will unify us all is the logic – biology – cycle. Human activity is in a cycle of polluting. Can computational design analyze those cycles? Also, we might pose the question of the relationships between human vs. building vs. plant. A building needs air and a human needs air, and a plant needs air. However a plant and a human don’t need the same things. So how do we find the equilibrium between the existing sciences? Perhaps this generates our next discussion, and next list of parameters. But first, we need to bring together the disciplines of science, biology, and architecture and unify them in the virtual world of computational design. There we may be able to achieve the nexus to develop this balance.
Fig.7 "Silk Leaf" (Melchiorri, Julian, 2014)
REFERENCES
Derix, C., Simon, C., & Coates, P. (2003). Morphogenetic CA 69’ 40’ 33 north.
Doumpioti, C. (2008). Adaotive Growth of Fibre Composite Structures. 1-8. Retrieved April 20, 2015, from Cuminicad.
Gurer, Ethem. Cagdas, Gulen. A Multi-Level Fusion of Evolutionary Design Processes. (n.d.). 904-907.
Gokmen, S. (n.d.). A Morphogenetic Approach for Performative Building Envelope Systems Using Leaf Venetian Patterns. 497-506.
J.L.M. HENSEN. DESIGN SUPPORT VIA SIMULATION OF BUILDING AND PLANT THERMAL INTERACTION. (1993). Design and Decision Support Systems in Architecture, 227-238.
Johnson, J., & Parker, M. (2015). THIS IS NOT A GLITCH. ALGORITHMS AND ANOMALIES IN GOOGLE ARCHITECTURE, 389-398. Retrieved from CUMINCAD.
Marcelo, B., & Charles, E. (n.d.). Top-down Approach to Embed Design Expertise in Parametric Objects for the Automatic Generation of a Building Service Core. 149-164. Retrieved April 12, 2015, from CUMINCAD.
Miranda Carranza, P. (2001). Self-design and Ontogenetic evolution.International Conference on Generative Art. Retrieved April 17, 2015, from Cuminicad.
R, D., & Snijder, H. (1996). MORPHOGENETIC DESIGNING IN ARCHITECTURE. 35-41.
Richards, Daniel (2011). Towards Morphogenetic Assemblies - Evolving performance within component based structures.Circuit Bending, Breaking and Mending: Proceedings of the 16th International Conference on Computer-Aided Architectural Design Research in Asia, 515-524. Retrieved April 20, 2015, from Cuminicad.
Shin, J., & Sabin, J. (2013). TISSUE ARCHITECTURE: PROGRAMMABLE FOLDING IN DIGITAL RESPONSIVE SKINS. 443-444.
Wu, K., Tatting, B., Smith, B., Swift, J., & Thornburgh, R. (2009). Design and Manufacturing of Tow-Steered Composite Shells Using Fiber Placement. 1-20. Retrieved April 17, 2015, from NASA achives.