Drawing from two precedents which use a Cartesian coordinate system as a means to spatially subdivide their repsective sites, Tschumi’s Parc de la Villette in Paris and Eisenman’s Memorial to the Murdered Jews of Europe in Berlin, this exercise utilizes transformative algorithms to accelerate grid nodes with a degree of randomninity within an urban volume.
Due to the parametric structure of the algorithms used, this results in a chaotic reapportionment of the grid points in three-dimensional space. As the site essentially lies directly at the city’s center, the new structural order is an appropriate diagram of the sites spatial composition as it emulates the potentially chaotic paths of travel that humans and/or information may take within and open, urban space.
The resulting form is not representative of traditional architectural form per se, but rather the process by which it has been generated. By first dividing the space into a rational grid in three-dimensions, we have taken invisible, open, chaotic urban space and applied a mathematical abstraction as a means of assigning order. By utilizing the capabilities of the machine to create a degree of randomninity beyond the scope of human computation, we have reapportioned the 3D urban volume into a representational diagram which is more suited to its future program and usage.
The (re)cursive structure is a play on the word script. The form itself is generated by a script that while randomizing of the x, y, and z coordinates of a three-dimensional Cartesian grid, concurrently randomizes the radii of a series of ellipses through which lofted surfaces are plotted.
The result is an interconnected network of structural members, whose forms wax, wane and flow like strokes of ink or a Script family typeface. Fashionably elegant...kind of like a princess.
Facad(sch)ism represents a schism, or separation, between a building's elements and the facade articulation. In parametric design, facade patterning can be programmed to create pattern, or be further informed in a more intelligent manner by a buildings structural, programmatic, or formal logic.
This project proposes a large, multi-use urban complex at the heart of Vine St. in Cincinnati, Ohio. The site lies directly south of the Cincinnati Public Library Main Branch, on both sides of Vine between 7th and 8th Streets.
Program spaces includes extended library program, specifically additional space for digital and new media, and space for mixed-use public/private including residential, retail/commercial, educational, and gallery spaces.
The intent of the project is to create a continuous corridor of usage along Vine St. Currently, the site is occupied by surface parking lots.
The facade uses a blending script to create a fluid effect. As seen below the diameter of the openings fluctuate based on two sine functions which run at different frequencies with respect to the vertical and horizontal axes. When imposed on the over all building form it creates an ephemeral atmosphere.
We've messed around the with the honeycomb script we wrote a few weeks ago. As you can see the form has the same basic shape but we've added a few surface functions to the script to articulate the hexagons. Also, we've put the arrangement in a somewhat more architectural context, just to legitimize what it is we do here.
Scripting allows us new ways to look at traditional architectural problems. This is true not only for problem solving and design processes, but also in the way we treat traditional architectural materials. This experiment was based on the experiments and findings in the book Digital Materiality in Architecture by Fabio Gramazio and Matthias Kohler. This book shows many different projects which create breath-taking architectural compositions out of various standard building materials. The work of the Gramazio & Kohlerhas been a key influence for our efforts and an excellent example of the potential of algorithmic design processes - but you don't have to take my word for it.
This week's entry is an homage to their innovation and talent. As you can see, by injecting a traditional masonry wall with algorithmic forces the result can be surprisingly fluid and sensual.
One of the great things about designing with scripts is the ability to link forms with random variables. One of our main goals at a r c h i t e c t u r e 2 . 0is to achieve unexpected results through our use of algorithms, and never is this more frequent than when scripting with random functions. We touched on this earlier with the packing script, but here we've decided to explore it further with surfaces.
By inserting a random value when calling our curve method we are able to give the skeleton of our surface an incredibly rich texture. The base curve for the skeleton is just a hyperbola mirrored back on itself. When we apply a random multiplier to the Z coordinates of the hyperbola we get the resulting (goose)bumps. When we loft these lines the transformation from curve to surface is complete. In the rendering we chose to contrast these bumpy forms against the rigidity of the cube. The use of the random brings with it uncertainty, doubt, and sometimes even frightening results. The forms here are are chilling, haunting, grotesque... and also time consuming to render. Happy Halloween.
Honeycomb - The honeycomb script seems to be a staple for newcomers to scripting. Throughout much of our research we have constantly come across programmers tackling this same problem. There must be something about nature's sweetest form that has people coming back for more. At a r c h i t e c t u r e 2 . 0we like to think that the honeycomb script is the "Stairway to Heaven" of generative design. So we've chosen to approach the issue the same way we did with space frames. We create an augmented grid of points and run a series of if...then s to connect lines for the hexagonal pattern. Increasing the curvature and density of the grid creates a more exciting form. Also, controlling the depth of the hexagon pieces has a substantial impact on the final result as well.
This space frame was generated by a double looped script. After defining the coordinates for connection point another series of loops were run to connect the points and form the space frame geometry. If you look closely you can see that the spacing of the members varies according to their own various geometric parameters. This variation in density is best noticed in plan view where you can see the overall pattern start to emerge. Scripting with space frames provides an infinite opportunity to explore different density patterns and the ability to map them on dynamic surface geometries.
We here at a r c h i t e c t u r e 2 . 0don't know much about engineering structures but we like to think that these denser areas could serves as girders or beams within the space frame. These lines could assume loads and direct them toward supports. But hey what do we know, our school only teaches us theory...
View the a r c h i t e c t u r e 2.0 PDF displaying all of our hard work during last quarter's independent study. This file shows all of the exercises completed throughout the term plus some insights into the development of the Crosley project.
CINCINNATI - It's been an age, but after a long hiatus this summer the rapturous duo of architecture 2.0 is back. As many of you may recall this blog was originally set up as a way to document exercises in generative design for an independent study taken through our beloved college of DAAP . The result of this course was a project done with a building on campus, everybody's favorite: Crosley tower. Le Corbusier once described architecture using these words: “Space and light and order. Those are the things that men need just as much as they need bread or a place to sleep.”
We're not sure if Crosley is exactly what he had in mind. Anyway, what we've produced probably would not fall into that description either, but we've decided to try and add to the discussion (and maybe the irony) anyway. Enjoy.
"Whether stars, storm clouds, or petals of a flower, the spiral is only detectable by observing things caught in its wake...The spiral is not so much a shape as the evidence of a shape in formation." --Aranda, Benjamin, and Chris Lasch. Tooling (Pamphlet Architecture). New York: Princeton Architectural Press, 2006.
As always, dimensioning our variables is the first step in generating the Spiraling algorithm. We create variables x, y, and z which will be our the plotted points through which the spiral curve is passed. We create the variables 'dblAngle' to represent the angle from origin that each new point is plotted, and 'dblRadius' to determine the length from origin at which each new point is to be plotted.
By looping the functions 100 times, we create 100 curve points.
We multiply our loop variable by 30, and pass that through the 'dblAngle' variable to increase the angular dimension by 30 degrees each time the loop is run.
Using right angle trigonometry, whereby the 'dblRadius' value represents the triangle's hypotenuse, we are able to write functions that plot our points out in a spiraling pattern.
Lastly, we run the Rhino.AddCurve method to pass the curve through our spiraling points.
"Packing is a powerful organizational method in which an element's position in regard to its neighbors is determined by certain rules -- not too close, no overlapping, etc." --Aranda, Benjamin, and Chris Lasch. Tooling (Pamphlet Architecture). New York: Princeton Architectural Press, 2006.
In order to generate the Packing algorithm, we first dimension our variables. We leave open parentheses which follow the x, y, z and dblRadius variables. This is because we will be passing values from the 'i' and 'j' loops which will be run later in the script.
We then run the 'ReDim Preserve' method when we wish to assign a value to a variable that we have left open at the beginning of the script. Passing the value '0' through each of the open variables. This gives the loop a starting point.
ReDim Preserve x(0), y(0), z(0), dblRadius(0)
Next, we run our first loop. We use the 'i' variable and set the loop to run 100 times. Again, we re-dimension our variables from above. This time we pass the variable 'i', which will insert a value from 1 to 100 each time the loop is run.
ReDim Preserve x(i), y(i), z(i), dblRadius(i)
Passing the 'i' variable through x, y and z creates a discrete amount of instances for each, depending on the number of times the loop is to be run (In this case, 100). Then, we assign a unique value for each of the 100 instances. We will the 'random' method which assigns a random value from 0 to 1. By multiplying this times 50, our values will range from 0 to 50. Because we want our circles to be drawn flat on the x-y plane, our z value remains 0. Also, we want the radius of our circles to vary randomly up to 5.
x(i) = rnd * 50 y(i) = rnd * 50 z(i) = 0
Rhino's 'PlaneFromFrame' method constructs a plane from a point and two vectors in the plane. By passing the 'i' variable through the origin parameter, we create 100 separate instances of the origin point, and ultimately the centers of 100 circles. We then set the overlap string value to 'no', And run our second loop. It is important to note that this loop is being run inside of a larger loop. For every singular instance that the parent loop runs, this child loop will run through its entirety. We have set the child loop (j) to at all times equal one less than the parent loop (i). Therefore, depending on which instance the (i) loop is at, the (j) loop will run from 0 to 1 less than where the (i) loop is at.
For j = 0 To i-1
Now we write our conditional statement to make sure that our circles do not overlap. It is important that we check this mathematically before the circles are drawn. If not, we would have to manually erase overlapping circles and start the process over each time. We measure the sum of the two most recent circle radii in relation to their x and y coordinates.
We say "If the absolute value of the 'x' component at its 'j' position is subtracted from the absolute value of the 'x' component at its 'i' position is less than the sum of the new circle and its most recent predecessor, and the same occurs for the 'y' coordinates, then we have an overlap.
If this overlap statement is not true, then Rhino draws the circle object as intended, and moves on to the next instance of the loop.
In the first we apply the sine functions to the center point coordinated of each sphere and create a fluctuation that implies a deformation to the overall cube grid.
In the second we apply the sine function to the radius of each sphere which also implies an overall deformation to the cube but with keeping all of the center points in strict adherence to the grid.
For next week we hope to continue these experiments with a variety of other shapes to see how that will affect the emergent patterns.
Architecture 2.0 is a domain for the exploration of emerging techniques in architectural design. Here we seek to explore and exercise a design philosophy rooted in the generative nature of digital processes. The goal of our research is to uncover the patterns and phenomenons that are inherently present in the use of these tools.
