British Museum Great Court Roof Parametric Modeling
Video Presentation
1. Form the grid
The grid is started from 1/4 of the rectangle and the circle. Divide them into equal segments and use line node to connect.
Divide the lines again to get the intersection point for the web structure. The next step is to find ways to connect those points. The divided points will be in different lists, belonging to the line it comes from. That inspires me that I can use line node to connect different lists. The connection method include: 1) connect list(n) to line(n+1) directly to get straight lines; 2) connect point (i) in list (n) to point (i+1) in list (n+1) to get the diagonal lines. Based on this logic, we may choose to use "explode tree" node to get individual lists and connect them one by one, which I used at the beginning. But this method is time-consuming and hard to modify when I decide to increase line divisions. In my second attempt, I used split tree node to separate trees into two parts: for total tree branches x, list 1 contains branches 1 to x-1, list 2 contains branches 2 to x. As the grasshopper components recognize data based on its input order, the first data list in node A will be match with the first data list in node B. The points in branch 1 (0,0,0,1) put in node A will be matched with branch 2 (0,0,0,2) put in node B, branch2 will be matched with branch 3, so on so forth. We can also achieve this by "shift" node. When list 1 is directly matched with list 2, the first point in list 1 will be connected with first point in list 2. When I cull the first point of list 2, the first point in list 1 will be matched with the second point in list 2, which forms the diagonal lines. The lines altogether are collected and convert to mesh using weaverbird plugin.
I mirrored the mesh twice to get the entire mesh and then join the pieces together. "Weld" node is used to remove the overlapping edges.
The mesh is not even everywhere. Some grids are narrower than others. I use Kangaroo physics simulator to relax the mesh. Naked vertexes are used as anchor point, every line of the mesh was set at equal rest length so the lines will find their balance position where the tensile force within each line is even. The result gives us a much more even mesh. However, the kangaroo solver will output the mesh lines combined with the mesh, as well as some empty data. I use "clean" node to remove the empty data and use list item to find the mesh we want to use in the next step.
2. Roof shape generation
The generation of bubble roof also employs Kangaroo plugin. Giving a force upwards for each point on mesh creates the bubble effect. Make sure the naked vertexes are used as the anchor point so the roof won't fly away. In kangaroo2, anchor points are no longer fixed as the previously released version. It offers two input node: points and target position. The initial input point will be the naked vertexes on mesh, but their target position can be adjusted using transformation nodes. To be noted that, the target point data list order must match the initial point list order, because the "anchor" component will match the two list based on input order. I attempted to bake the naked vertex and collect the points separately from the outer boundary and inner boundary in order to get more control, but the results from solver will become messy because the collected point data is not at the same order from the initial input list.
To solve this problem, there are several ways:
Method 1. sort both of the initial input data list and target position data list based on certain criteria to make sure they are matched
Method 2. Separate point list from the initial data source instead of baking and collecting them.
Method 3. Copy and flatten the two collected data lists and use the copy as initial input data. Make sure the target position node is flatten as well.
The intention of separating the anchor point is to match the boundary of roof to be updated with outer building height and inner dome height. Since the input mesh is flat, the initial input anchor point must be at the position of the mesh's naked vertexes. Because we build up the mesh based on our intersection points, we are able to locate them from the rectangle division points and circle division points. Those two data sources were flattened as initial input anchor point, and we are able to manipulate the two data source separately with transformation node. I link the building height and dome height node to its transformation in order to move the target point to the desired height.
3. Dome generation
The generation of dome is based on the input dome circle. From it we can get a series of circle with various sizes using the same center point and put them at different heights. The base dome use sweep node and a section curve to form the onion shape. The cap is from loft node and several smaller circles. All geometries originates from the input circle, and the operations are done entirely in grasshopper as it's even more convenient to achieve and give us more accuracy.
I didn't draw the section curve in rhino. Instead, I create it from parameters because I'd like to have more control over its shape.
Using "add" and "unit x" node with the circle center point can easily get the point toward x-axis direction. Using "closest point to crv" node can find two points on the upper curve and lower curve, which are on the same section line. Draw two vectors from the center point to the two points on curve. Add the two vectors and multiple them with a parameter will create the third point. Using the three points to interpolate the section curve. Sweep the section curve along input circle will form the opine dome. Adjust the parameter until the shape satisfy the need. The height and radius of upper curve can also be adjusted as it's created based on the initial circle with "move" and "scale" node.
The entire dome is created by a series of circles combined with "loft", "extrude", "cap", "offset" nodes. The panel on surface is generated by lunchbox plugin. The window frames are extruded invert from the window center point to the circle center. Dome frame is created by "rotate" and "domain" nodes. Rotate node will control the piped section curve to rotate around dome center point. Domain node allows us to control how many steps we want the section curve to rotate from 0 to 360 degree. As 0 and 360 is overlapping, I use "cull pattern" node to remove the index 0 curve so the final result equals to the steps we put in.
4. Analysis
Analysis 1 is to investigate what does Kangaroo physic simulator do when processing mesh relaxation. In 2D relaxation, I compared change of spring length before and after kangaroo solver when assigning them equal rest length. The change of length is colormapped by gradient node. We can easily find the maximum and minimum length change by sorting the list and "list item" node can give us the first item in the list and last item in the list. Remember to use the initial list to match with the input springs when visualizing them. The system I create here can compare any spring length change by changing the input mesh. So I also compared the difference between one-step relaxation and two-step relaxation.
In my modeling file, I create the 2D grid and relax it once, then use the output grid to generate the bubble roof, which experienced two-step relaxation. Alternatively, we can process this within one kangaroo solver, and assign equal rest length when generate the bubble roof, which I called one-step relaxation. The result shows that two-time relation experience more even stretch everywhere, while one-time relaxation will stretch more from corner and edge. The produced meshes are also compared. Besides most areas look close to each other with bare eyes, the edge of one-time relaxation mesh has larger grids than the two-time relaxation.
I think the input mesh does matter the bubble generation effect. As the gravity force is applied to each point on the mesh, when the input mesh doesn't have even spacing for each grid, the gravity is placed unevenly to the mesh. It will be more desirable to input an even grid spacing mesh in order to receive even gravity for the surface.
This comparison displays how different grids can affect the bubble roof effect. The left one mesh is generated automatically from mesh surface node. It creates many strange triangles around the inner circle as the node doesn't contain an algorism to approach a circle from rectangle by triangular grids. The second left mesh is the product using "line" and "divide" node to connect without 2D relaxation. The result is okay but not perfect. The third one is one-time relaxation product and the forth one is two-time relaxation product. Again, the result is rather similar except for certain corners with larger grids. But I'll prefer two-step relaxation because the result is more even everywhere.
I also analyzed the direct sun hour on ground floor from the roof truss structure, comparing flat roof and bubble roof. I'd like to see what may be the advantage bubble roof has besides its beautiful curvy form. I hypothesized that bubble roof will receive more sunlight than the other. But the result is surprising. Using ladybug plugin with London weather data, the flat roof receive more direct sunlight than bubble roof. It could be the design intention, as the roof is for British Museum, which will avoid direct sunlight for their valuable collections but still like some reflected nature light into the house.
5. Design extension
From this study, I gain familiarity on creating and controlling meshes. I'd like to use the grid generation method into other structures. Lunchbox is an excellent tool to create uniformed grid structure with different geometry pattern on most surfaces. It does well for rigid boundary to rigid boundary, or free form curve to free form curve, but it still does not contain a good algorithm to deal with rigid boundary to free-form curve boundaries. For example, the lunchbox plugin will still create weird triangular transitions for the great court roof that composed of rectangle and circle. This particular shape requires us to create customized mesh structure to get the even spacing grid.
But lunchbox is still useful for other forms. I'd like to introduce the process to convert lunch box created geometry to meshes that I observed when I attempt to use it for this study.
First of all, don't use "berpmesh" node either in rhino or grasshopper when you need the lunchbox grid line to be kept. Lunchbox will create several small surfaces for each grid. If we join the surfaces together and expect "berpmesh" will recognize the faces to create an approximate mesh, we'll be disappointed. The berpmesh node doesn't follow the input face and rather produce unpredictable mesh pattern.
Secondly, construct mesh will not work as well. The panels lunch box created are surfaces, but construct mesh will only recognize face, which is not the same type of data. If we'd like to create smaller mesh for each panel surface, each mesh will need to take at least 2 u and 2 v to be created. Since the uv direction is different for each surface, the final mesh that we join together will still not be the regular pattern.
The second method is for those who still like to use the paneling tool in lunch box. The panels can be joined together as a berp. "Simple mesh" node will tend to use the simplest way to generate a mesh approximate the berp input. The result is acceptable as an approximate product.
Comments
Post a Comment