Advanced Computational Design Folio Brian Duong 761765

Advanced Computational Design

Subject Folio ABPL90123 Brian Duong 761765

Master of Puppets

1 ABPL90123 Brian Duong 761765

The concept of this design is to create the frame and structure to hold recycled glass bottles and form a bench using parametric design

Form CreationS urfacing Structural ImplementationD ocumentation

to contain

Start with input curve surrounding the curve

Start with curve the curve

The surface needs to be equally spread to contain

Structural components are created separately

Meshmachine in Kangaroo re -meshes the surface and outputs the points

Use points to create volumetric geometry, in this case with the aid of Cocoon plug-in

points to create volumetric geometry, in

angaroo re- meshes the outputs geometry to points

Orient geometry to points on the mesh

Oriented to the correct position, where placeholder circles were

Structural are created where were components added

Additional structural components added

Take geometry and orient to

Take geometry and orient to

abel

Label objects accordingly

Layout objects and nest to page

Layout nest to

Levelled Bench

Vertical

Levelled Table

As the geometry becomes more complex, the form becomes more interesting, however the overall size and detail increases. This will require more resources to fabricate, therefore a balance bet ween complexit y and practicalit y is necessary

Each iteration implements a diff erent element to adjust the functionalit y of the bench.

Levelled surfaces allow users to sit and lie on a more even area.

Levelled surfaces act as integrated table tops and allow for objects to be placed on top.

Vertical geometry acts as shading whilst allowing light to pass through the glass and frame.

Design Iteration Matrix

Initially creating points from the input curve. These points can be further manipulated to achieve the desired result, for example, the distance is taken betw een a given point and the centre of the curve. This data is hen used to scale the charge at the point so that the radius of the cocoon will be smaller the further it is away from the cetnre of the curve

Here, the points are used in conjunction with their point charge strength to form the volumetric geometry using cocoon. Detailing in the form is controlled at this stage, points are manipulated and tw eaked so that the desired ef fect is achieved.

The next step uses the Meshmachine component from Kangaroo to remesh the surface of the geometry so that we are able to orient the circles to the surface without having intersecting circles. The output of this portion can be used to orient the necessary geometry to t he correct position.

This portion of the script handles generating the geometry that will be used in the structure of the bench.

Here, the geometry is oriented to the correct position on he surface and additional structural geometry is created.

Towards the end, the geometry is used to create the curves required for documentation. Here we need to arrange each geometry accordingly

Lastly, we create the layout for the documentation. Here we can adjust the size and text accordingly.

Parametric Workflow

For documentation, as there are over 10,000 parts for the entire structure, the fabrication can be divided into sections. This documnets one of those sections.

Lastly, we create the layout for the documentation. Here we can adjust the size and text accordingly.

Adjacent module at tachment

Each frame module is welded to the adjacent module with a support beam

Each support beam is labelled and has a corresponding position on the top ring

Rubber Stopper

Inserts into the bottle and holds the bottle in place in conjuction to t he top and bottom rings

Top Ring Plate

Holds the glass bottle in place late rally, inner ring has a rubber gasket to keep glass in place with friction

Suppor t Column

Welded to the top and bottom plates, cor e to the structure

Bot tle Rod

Rubber attached to the rod, with small indentation for the rubber, bottom section of t he rod is thinner width and threaded to bolt the bottom plate to t he module.

Rubber Washer

Small rubber washer to hold glass bottle in positio n against the bottom plate.

Adjacent module at tachment

The top and bottom plates connections to adjacent modules provide the rigidit y and structure for the bench

Glass Bot tle

Above: Brunel Gateway - Pavilion Proposal, sourced: http://minimaforms.com/#item=brunel-2

The form of this structure is reduced to the essential elements, enabling it to maintain structural integrity and reduce its weight. The organic form is also expressed here with elements melding into each other forming a seamless structure.

Below: Supertree Grove - Gardens by the Bay, Singapore, sourced: https://www.shutterstock.com/g/tpopova/sets/46357505

The branching of the structure at the top is representative of the branches of a tree. They extend up and outwards creating a surface like effect. The branching pattern could be determined parametrically using a recursive algorithm.

Precedents

Form Creation

Analysis & Optimisation

Fabrication

Recursive Script

Cocoon Mesh

Subdivision

Form Division Fabrication Layout

Form Creation

I began the form creation with a recursive script, the foundational elements I sourced from Danil Nagy and implemented a number of additions and adaptations. In particular, point and line creation, tree paths and additional numeric controllers.

The tree path setup allowed for grouping of each iteration into a separate branch for easier accessibility later on.

I then set up a range of values to adjust the branch thickness in relation to the iteration level.

In order to refine the outcome of the script, I used octopus and some fitness conditions to narrow the outcomes. For efficient optimisation, I used this process on the basic form as further progressions of forms took longer amounts of time to compute.

The resulting form was intended to have a reduced number of endpoints to reduce collisions within the higher iterations of the recursion.

Ladybug was used to complete the solar radiation analysis. The aim here was to test the shading capacity of the branches.

For structural analysis, I used Karamba to test the structural capacity of the form. Here the diameter of the branches were varied to increase structural support. Additionally, the secondary form reduces the weight of the branches.

Secondary Form Creation

The next step was creating the secondary form. The curves from the recursive script were used to create line charges for the cocoon mesh. This was then remeshed and adjusted to an appropriate mesh cell size. These mesh faces were then framed, thickened and subdivided to create the final form of the canopy.

Creation

2. Large Scale 3D Print

1. File Preparation

The fabrication portion of the canopy design results in a casted aluminium structure. To create this, the entire form is divided into sections that are able to be 3D printed in PLA. This is a large scale print with a build volume of 1005mm x 1005mm x 1005mm. As such, the form is divided into 1000mm x 1000mm x 1000mm porions.

3. Lost Wax/PLA Metal Casting

Above: BigRep ONE - Large scale 3D printer, sourced https://bigrep.com/bigrep-one/ Large scale printers allow for larger components to be printed.

4. Assembly

In order to maintain the structural integrity, each casted portion is welded together. The welds are ground and polished to create a seamless form.

Above: Lost Wax Casting Process, sourced: https://i.materialise.com/en/3d-printing-materials/gold

Lost wax casting is a metal casting process involving imbedding a wax model into plaster, then burning out the wax, leaving the plaster mould. This is then used to cast the metal. The wax can be substituted with PLA which can be 3D printed. The advantage of this process is that it allows for more complex forms to be casted. Additionally, the secondary form reduces the volume of aluminium needed for casting.

Stairway to Heaven

Taichung Metropolitan Opera House, Rio de Janeiro, Brazil Toyo Ito & Associates

I was drawn to the form of this building because of the way the organic and rigid forms interact to form voids in the structure. The concept allowing organic forms in the project appeals to me but I would like to constrain them within a more regular structure, similar to how Toyo Ito is able to in this building.

Serpentine Pavilion 2013, London, United Kingdom Sou Fujimoto

The combined use of structure integrated with the platforms intrigued me in this design. Similar to Toyo Ito’s Taichung Metropolitan Opera House, there is a relationship between the rigid structure and the overall organic form that is generated within this pavilion.

Precedents

The initial idea for the staircase came from a combination of the precedents and the parametric ability of the staircase. I wanted to create a robust staircase script that was able to adapt and generate a staircase for the form I would settle with later. As shown in the diagram, I first needed to determine the parameters that the staircase would consist of and how it would be generated from those parameters.

The staircase geometry is determined by a single line base that is drawn between two points. By creating a input parameter as simple as possible, I was able to generate all the other parameters and requirements for the staircase through that curve.

There were challenges in creating a parametric staircase, one of which was implementing landings into the staircase in order for it to adhere to building regulations. Having landings is dependent on the number of steps in the staircase and by including a landing, the angle of the stair changes. Therefore I needed to create a way to determine what the steepest angle a staircase, in relation to the number of steps, could be in order to generate the appropriate geometry.

Once these challenges are overcome however, the staircase can be automatically generated from two points.

The process for generating the staircase begins with the python component above. This component calculates the values for the information needed to generate the staircase. Input parameters are selected based on Australian Standards.

It can also be noted that this will later be used to calculate values such as the maximum stair angle based on a variable number of step input.

The Python script shown on the left shows the necessary code to account for the parameters and restrictions specific to a staircase adhering to building regulations.

In general the script is fairly straightforward, requiring a number of definitions that separate the output of the script based on whether the staircase is short, mid-length or long. For these staircases, since 18 steps is the number of steps requiring a landing, the ‘lowStair’ does not require a landing. ‘midStair’ requires one landing, while ‘highStair’ requires two landings due to the step count exceeding 36.

While this is useful information, for the purpose of the context of the Redmond Barry building, floor heights do not exceed 4.6m, therefore most of the staircases fall within the ‘lowStair’ and ‘midStair’ category, meaning typically there will either be no landing or one landing.

In addition to the maximum angle the stair can be, total horizontal and minimum horizontal stair length can also be calculated. This is used later on as a restrictive condition for optimisation.

Staircase

Once the necessary information is calculated, the process of generating the staircase geometry can begin. The heights between each floor is measured, and it can be noted that these do vary up the floors. In general the lower floors are higher while the upper floors are lower.

This information is passed through the staircase calculation to determine the minimum staircase length for each floor. This is then used to restrict the optimisation to generate staircases that fall below the maximum stair angle.

Staircase

Each staircase is generated sequentially based on the position of the previous staircase. Since the generation of the staircase geometry is repeated for each floor due to the flexibility of the generation script, it is contained within a cluster which can be repeated for each floor.

Here, Galapagos is used to optimise the position of each staircase. To simplify the optimisation process, lines are used on a single plane, constrained by the dimensions of the floor area. This will later be oriented with the correct floor levels.

The fitness condition tests for the curve length, minimising it as close to the minimum staircase length as possible. However within the clusters are filters which produce null values. Galapagos avoids these null values and aims to reduce the staircase length value.

The initial cluster contains the base line generation script. This creates a line between two points. The points have variable X and Y parameters that are adjusted by Galapagos.

The first filter here determines whether the line generated by the two points is longer that the minimum staircase length. If not a null value is produced, and new values are tested.

The second filter is created to ensure there is enough clearance between the staircases of each floor. This script creates a region at either end of the staircase and tests for interesections with the previous staircase.

The optimisation needs to clear both filters to produce an acceptable line.

Staircase Generation

Here, we can see the optimisation process as Galapagos attempts to minimise the fitness value. This process needed to be repeated for each floor sequenctially as it increases the overall success of finding solutions.

Once the base lines are created on the single plane, they are moved up to the appropriate level and connected to form a polyline. This polyline is the overally guide for the location of the staircases.

The next step in the process is to create the actual staircase geometry once the guide curves are determined. The staircase geometry generation requires a minimal number of parameters to generate the staircase. These are the start and end points of the staircase guide curve as well as the floor height and cumulative floor height.

With all these values, the staircase geometry is generated for each floor. Again clusters are used to the versatility of the script within.

The cluster, consists of the script that generates the geometry for the staircase as well the balustrades and structural support element. One challenge in particular with generating a staircase script that is versatile is accounting for the varying step count. In particular even and odd number of steps in a staircase will change the location of the landing. Typically when there is only one landing it is placed in the middle of the staircase, ensuring that the steps on either side do not exceed the 18 step limit. However, with oddly numbered steps, the landing needs to be skewed. In this script, it is skewed upwards, so there is one extra step before the landing than after it. This is resolved with a filter that determines whether there are an even or odd number of steps in a particular staircase.

The first step is to ensure that the input curve is within the acceptable maximum angle of the staircase. The filter passes the curve if the angle is below the maximum angle for that particular floor.

The curve is then filtered depending on whether the number of steps is even or odd.

The curve formation for the odd number of steps is slightly more challenging than the even steps as more calculations are required. The first section of the curve generation is purely calculations to determine the number of steps in each portion and the location of the points to generate the lines. The curves are generated at either end of the staircase to the appropriate point. These ends are then joined to form the landing in the middle.

For even steps, the landing is positioned exactly in the middle of the staircase, so the landing can be created first in this case and used to join the diagonal sections of the curve.

Staircase

Once the base curves are generated for the appropriate staircase, the points for the steps can be generated. These simply use the step height to generate a series of points which are then projected onto the polyline base to form the location points of the steps.

Once all the guidelines and points for the staircase are generated, the geometry can then be generated. Here, steps are created by extruding planar surfaces at each point on the curve.

In addition to the steps, using the base polyline, the balustrade and support structure beneath the staircase can be generated as well using extrusion.

The staircase generation occurs for each floor and together form the overall staircase geometry. An issue that was met had to do with orientation of some of the support structures as they extruded in the incorrect direction. As they were all extruded in the cluster across all the floors, this needed to be manually amended with the tweaking script for the particular staircases.

Staircase Generation

In addition to the staircase itself, the landings at the top and bottom of each staircase needed to be generated as well. These were created from rectangles at either end of the staircase.

The landings also need to connect to the floors of the Redmond Barry building. To reduce the floor area, the landings were directly projected across to form the platform connecting to the Redmond Barry Building. It can also be noted that there are a few anomalies in the landings, but overall did not effect the final outcome significantly.

Once the staircase geometry was complete, the overall structure of the enclosure needed to be generated. The overall aim was to generate an organic form restricted to the polyline of the staircase.

First the build volume needed to be determined as well as the build area on each floor. This is simply generated using planes and the floor levels.

The organic form was created using a Cocoon mesh. The staircase polyline was used to generate a number of points to be used for the charge locations of the Cocoon mesh.

The mesh is then generated based off the points of the polyline. Additionally, to create a smoother transition between some points, additional points were added by dividing the polyline.

The size of the mesh was determined by considering the height clearance needed for the staircase.

The Cocoon mesh was then refined using Kangaroo Mesh Machine to generate a smoother and more regular mesh. This was then subtracted from a box mesh of the overall build volume to create a void where the staircase would be positioned.

The mesh was then framed and thickened to create the structural form. In fabrication this would be created from linear elements such as steel cylinder columns that can be joined together at nodes. It is also noted that this structure is not the primary structure of the encloure so only needs to support itself.

To create infill for the enclosure, the exterior portion of the mesh was needed. This proved to be quite a challenge at first however, I was able to use the mesh values and face normals to isolate the necessary mesh faces and construct a new mesh from these.

For the enclosure frame, the box grid was used, this aligns with the existing geometry on the exterior. The ground floor needed to be removed, so further mesh isolation was needed for this mesh as well. The removal of these faces became easier with the use of face normals or face centers depending on the required geometries and dispatching the appropriate faces to create a new mesh. This method was used a number of times throughout the project with slight adjustments depending on the need.

The mesh was then used to create a frame similar to the previous.

Next, the primary structure was generated. This consisted of large elements that support the overall structure of the enclosure and staircase.

The elements were created by extrusion. An issue that arose with the horizontal elements was that some did not meet the necessary height clearances for the staircases. These horizontal elements were removed individually from the structure.

The primary structure was then tested using Karamba. Overall there was little deformation and in general this was to be expected considering the shape and form of the structure.

Finally, once the structure and stair elements were complete, the facade could be generated as well. The exterior facade shell extends past the primary structure and hides the larger members.

In order to create the outer shell, a new mesh box was generated based off the original mesh box and the extruded inwards to form a grid shell like structure.

The mesh was then treated similarly to the inteior meshes. The lower ground floor faces were removed and the mesh was turned into a frame structure.

Within each space of the exterior grid, shading elements are placed to reduce the solar gain within the enclosure. The size of each infill panel is determined by the distance from the most appropriate shading location. Closer to the point, the panel is larger shading more, whereas further away from the point, the panel is smaller. This is especially the case due to the infill panels present in the enclosure already.

To determine the optimum location of these points, solar radiation analysis was used as well as some optimisation.

In the initial solar radiation analysis, the existing enclosure is used to determine the locations within the enclosure that experience higher levels of solar radiation. The output radiation will be used as a fitness condition that Galapagos will attempt to reduce. I.e. reducing the solar radiation throughout the enclosure overall.

The optimisation consisted of points that contained a shading geometry. These geometries were relocated using Galapagos to deteremine the optimum location to reduce the solar radiation of the enclosure.

These points were then used to influence the facade infill panels.

Overall, Galapagos had a challenging time determining an optimal solution for these elements. However, the total radiation value was not expected to reach 0. The orientation producing the lowest radiation value was taken and used to generate the facade pattern.

In the end, all these elements come together to form the final form of the staircase.

Mozilla Hubs Experience: https://hubs.mozilla.com/gfjAMo8/crimson-hungryvacation

Detail Joint - Facade