0:02 All right, hello, my name is Keyan. I think this will be something a little bit different, it’s mostly subtractive manufacturing for one thing, so hopefully there’s still something interesting in here for you guys. But yeah, so I’m going to going to go through this case study and talk about what we call an approach to computational design, which we call procedural BIM. I’ll go in through it in gross detail, but fair warning, basically we had to do a ton of work in a very short amount of time, and I’m going to kind of like put you in that head space by covering a responsible number of slides in a short amount of time. So yeah, so strap in, I guess.

0:39 Okay, so these are the Lucil Plaza Towers, they’re in Doha, in Qatar, they were built for the World Cup, they were designed by Foster and Partners. I was working with Front Inc, which is a facade consultant based here in New York City, well, everywhere, but yeah. And then the facade contractor was a company called Alitech, which I’ll say a little bit more about later. So there’s four towers here, 23,500 curtain wall panels, each of which consists of hundreds of individual components, each one’s different. Those four buildings, the exterior facade systems, consist of 8.5 million fabricated components, and we generated all of that in four years.

1:15 So just a little zoom out again, so Front is a facade consulting company, we do all kinds of technical consulting and analysis for complex envelope projects. This project is characterized by this spiral, right, so there’s this shifting geometry from the base to the top, which I’ll talk more about, but this spiral is what makes each individual panel a different piece of geometry. And we took this from a rendering to a datar, parametrically generated model, all the way to fabrication.

1:46 I’m giving you kind of a high level view of what we’re going to cover, and then I’ll go into detail. So during the design phase we worked with Foster and Partners to do all kinds of parametric studies, how is the sun going to, you know, hit these panels, how do we optimize a facade to meet lots of different parameters, that results in a kind of datar rich annotated model, so that we can generate the models for fabrication, to fabricate every single component. And then we’re going to talk about the frame, we’re going to talk about the glass, which is curved and twisted as you can see here, and that required some machine learning. And then you put it all together and you get, you know, four towers.

Some context, we started the design in fall of 2018 with Foster and Partners, and the things that we knew, right. So you start with things you know, and you kind of like figure it out from there. So we know it had to be done by winter of 2020 when the World Cup was going to happen, that deadline is not moving, right. Then you figure out, okay, well, if that’s going to happen we need to award the contract to the fabricator by 2020, and if we’re going to do that then we need to finish the design six months before that, and if we’re going to meet the deadline we have to fabricate the first piece six months after that. Then there’s things that you can’t really anticipate, like, oh, there’s going to be a global pandemic, and then there’s going to be a total shutdown in the supply chain as soon as you start making pieces and need to move them around around the world.

2:59 So to accommodate this kind of unpredictability, we have this kind of framework we call procedural building information modeling, and this is enabled with something called ELR, which is a grasshopper plugin that helps with metadata. I’m going to talk more about that. If you didn’t know, if you know this plugin, it’s called that because Front is in the name, not everybody gets that. I’m the lead developer, if you want to talk about this more we can talk about it.

3:21 Basically the idea is this, so let’s zoom out. I know a lot of you know about metadata, but let’s just take another tack at it. So these things are just boxes, right, can you see that, it’s kind of faded out, these things are just boxes. It’s really the annotations on it that make it meaningful, right, that make these things something other than just a box. Is it a beam, is it a column, what floor of the building is it on, and so on and so forth. You can do this in Rhino, this is out of the box functionality right here, but you got to do it by hand, not tenable. So grasshopper, that’s where that comes in, and Elron is what lets you manipulate that metadata in an automated way.

3:53 Here’s the idea, so you have objects, they have metadata, they have these parameters, these properties. You read them in, you filter them, and then you can relate them to each other using those properties. Then when you author new geometry, that comes out of that process, it’s a composite of the information that went into it. If we use a real example from a building, you have structure. I’m going to read in the structural elements from level 12, I’m going to relate them to each other using their parameters, so I don’t have to do some geometric process of like, what’s the closest line to this other line, I can just read the attributes, right. Then I can write new geometry, like brackets, which again this is kind of washed out but that’s what those red dots are, and those things are, they combine this information so they know what beam and column it’s attached to, it knows that it’s a bracket, so it’s overriding their properties where it need to, where it needed to, and then, yeah, so it has information about what it’s attaching to.

4:46 So you stack up these processes on top of each other, and then as your model becomes more and more detailed the metadata accumulates. So as you have more detail in the model, it requires more information to describe those components, so the metadata accumulates in this progressive, procedurally generated way, it’s sequential. So kind of like this, basically you have repositories of information that are connected together with scripts, and you represent all these levels of detail simultaneously, so it’s not like you’re refining one model over and over and over again, each of these representations coexist, and then they maintain their relationships together using the metadata, and that’s mediated through grasshopper.

5:22 The other thing that’s important about this is that it preserves the sequence of decision- making, so of course if you do things in a different order you get a different result. But when you’re working on a complex design like this, there’s no way to know from the beginning all of the decisions you’re going to have to make over the course of the project, right. So you need a framework that allows this kind of modular swapability and is going to record the decisions as you make them, because as we’ll see there’s a lot of kind of nuance decisions that have to be made in the design process that you never would have expected when you started, right. This allows like new entries of information, like things that happen on site that need to be injected into this workflow, and it kind of scales up organically over time.

6:03 Okay, so let’s go back to where we started. This is the design of the building, basically you have one profile at the base and a different profile at the top, that’s why every single floor is different. It is rotationally symmetric, but once you add this one dimensional, one directional spiral on the outside, that doesn’t get you anything, course there’s lots of ways to tesselate the outside of a free form geometry, you could triangulate it, you could do shingled quads, or you can go with cold bent quads, which is what we ended up doing, for lots of reasons, namely it’s less frame, like triangulated has extra frame, more parts to be fabricated, so on and so forth.

6:35 And during the design process with Foster and Partners, we’re using our kind of parametric model to, because again these, the relationships are codified as you build the pipeline, right. So if you want to change the level of the amount of opacity on the facade you can do that reusing the same scripts, right. Then you can do studies like this, so how much sun is hitting the building, how how effective are your shades, so on and so forth, optimizations, to do that. It’s all being run through this kind of parametric network of relationships. Eventually you get to this point where you have a model that’s annotated with metadata, 23,000 individual panels, 400,000 square meters, or 4 million square feet, of total surface area.

7:15 Okay, that gets us to this point where we have to start fabricating, so the thing gets awarded, and then we have to, six months to fabricate the first part. So this building, the facade contractor was a company called Alitech, they are international but they are based in Qatar, in toha. What is amazing about Alitech is they’re fully integrated, so they buy the aluminum extrusions, they cut them themselves, they put the panels together, they buy the glass, they fabricate the glass, they make the igus, it’s all like a vertically integrated shop, which is pretty much the only way you can do what we’re about to talk about. They also have like the largest anodizing bath in the world, 20 large format CNC machines, the largest PVDF coder in the world, like they were equipped, right.

7:56 Okay, so this is where we’re at, right, right, again, you’ve got this data rich model, metadata, it’s all linked together, that lets you start extracting information to make decisions, which is the important part. You got to engineer these panels, so the wind load is already embedded in this model as a series of metadata, each panel knows the wind load on that model, on that panel. Then we can extract a report and tell the engineers, okay, here’s your five different kind of general correlated groups you can engineer to. If we need to analyze the curvature on each panel, well, that’s already available in the metadata. If we want to export this to Revit we can use the metad data to put it on the right floor, in the right format, so that now it’s in Revit. If we want to make a three, a two-dimensional drawing of where the eds go, that’s available here. We’re measuring the linear feet of every single element in the model, so that they can start ordering aluminum from like the second month on the, in the fabrication process. Finite element simulations of like, you know, eight floors, or all floors, or, you know, whatever.

8:51 Okay, so we’re going to talk about the frame, right, so these panels are made out of a frame and a piece of glass, well, four pieces of glass, but. So normally the way you would do this, these these twisted panels, is that you would build them flat and then push them into shape on the building, but that’s really slow, because now you got a person hanging off the building 200 meters in the air, like with a winch, trying to like inch it into place, and then the crane is busy holding up the panel the whole time. You’re not going to be able to do that in time, so we decided to build the panels in 3D.

9:19 I’m going to go back actually, that way when it gets to sight it just goes up on the building. There’s other considerations, like when you push on that fourth corner, even though the one that’s m us is fixed, it’s also twisting, so every other component is twisting in the panel, that causes problems with the engagement between adjacent panels, like this, what you see down here on the bottom, the kind of interface between these things. Here’s a version of it, so you push that panel into place, you think it’s all well and good, and then you push the fourth corner, and now you’ve compromised the engagement between these two pieces, not going to work. So what’s the solution?

So the alternative is you actually fix the top edge in place and adjust the angle of the cut on the end, and then you can dial in the amount of twist in that element. So here is an example, like a prototype. So the other thing that’s nice about that, you’ll see, as they screw those pieces together it will force itself into the right position by twisting. So now you don’t have to have a custom measured jig, you get the full threedimensional dimentionality of that panel simply from how the miter cuts have been created, so all the complexity is handled by the CNC machine. These guys basically need like a screwdriver and two pieces of wood, and you’re ready to go. But to do that you need a model that’s model that’s at this level of detail, right, you got to have every single facet to an incredible level of accuracy and detail. Fortunately our metadata helps us get there, so we have these curves and they know what profile, they know what combination of pieces they need to represent.

10:41 Then you kind of follow the physical process in real life, so you start with an extrusion, you make the large cuts, you locate the holes, you drill those holes, now you’ve got a piece you can fabricate. So the digital process is kind of following the physical process step by step. Of course you can see here the wide range variation and the complexity of these pieces, so the amount of detail in each of these pieces that has to be fabricated, you can see all the holes and notches and so on and so forth. The thing I want to draw your attention to here are these flush cuts right here on the right, so the fact that these are kind of like, you know, face tof face cuts. So those of you that have spent a lot of time doing boolean subtractions know that this is a problem, so basically you, normal way you do this is you create the void shape, the negative shape, and you subtract it out, right. But you can see here the artifacts that it’s leaving behind, those little lines, that’s actually a problem, so when you put this into cam software, so that to program the CNC machine you’re relying on it, ability, on its ability to detect the features, if you have all those artifacts it’s not going to work.

11:39 The other problem is when you start adding twisting in here, the boolean fails half the time, and then if you have twisting and fillets it fails most of the time. So that’s not going to work, so we invented this other way of working, which is to break this 2D profile down into individual regions that we can then tag with metadata, so where to put that face, the orange face, the purple face, the pink pink face knows where to go in relation to another element, by tagging the sub pieces of that component. And then you have an infinite flexibility to dial in the level of like where the faces of this piece go. So the point in all this, though, is that you are encoding the design decisions that you make in the process as you build it, because it’s kind of stored, as you know, grasshopper’s original name was explicit history, because that’s what it is, it’s an explicit history of the decisions you’ve made.

12:26 So that’s what’s going on here, this goes down to the level of detail of the, even the holes, so the holes on these pieces have metadata on them, integrated into that network, so you can actually extract the individual faces of these pieces, and I’m going to do that, yeah, we’re just going to like grab one here at random. And then what you’ll see is grasshopper is able to determine which faces are cut with a saw and which faces are drilled with a router bit, and then you can separate them by their whole type, and then you can measure them, and that lets you do things like generate fabric tickets automatically.

12:58 So to kind of skip ahead a little bit, we ended up developing 1.5 million fabrication documents for this job. Ultimately, though, we went straight to the cam software, so once we were able to remove those artifacts with like our improved process, right, they could batch load like thousands of parts into their cam software, and then, you know, two or three throw an error, and the technicians can go in and fix it. So we’re still integrating directly into their fabrication pipeline using the software and their quality control control processes that they’re used to, but very quickly.

13:33 Okay, so we’ve got all these fabricated components, then you put them together, and now we’ve got our panel, right, beautiful threedimensional twisted panel, but, oh yeah, we got to put some glass on there. Okay, we got to figure this part out. So as you can see we’re lowering the glass down onto this frame, and the glass is already twisted, and the amount of twist in these panels is extreme, this is about 400 millimeters, or what is that, whatever, it’s over a foot, it’s like inch of twist. So you would think the way to do that in a straightforward Rhino world is you have your wireframe, you generate the surface, and then you have, you type in unroll, and Rhino gives you the unrolled surface, right, sounds good.

14:12 Except the problem is that surface that it gives you is not faithful to reality, so in reality glass is a rigid material with thickness, so when you try to twist it it does not adhere to this perfect idealized geometry that you have, the top, that’s hyperbolic paraboloid, right, it starts to war, and we can see that here in this prototype. So you confirmed in the simulation, you can see how the reflections in that glass, it’s starting to develop a kind of semi- buuck shape, so that’s a problem, right. So we run a bunch of analysis here to basically try to quant characterize the deviations from the theoretical shape that Rhino is giving you, so what you’re seeing here is, as you skew up to bot, from bottom to top, is the skew from a rectangle to a parallelogram, and to the right right, it’s how much you’re twisting that panel. So the plot is basically showing you the deviation from like the surface that Rhino gives you, versus what comes out of our material simulation.

15:07 By the way, the way this is fabricated is that they, the glass is actually held in its final shape, you you you put it on a rack, you twist it out of place, that thing goes into an autoclave, which bonds the two pieces of glass together using an interlayer, like an adhesive sheet, basically. So that’s what H, that’s why, at the end it doesn’t need to be braced, the interlayer, and the middle has returned back to room temperature and nominal stiffness, and that’s what’s holding these panels in place, like this. Okay, so this is what it looks like on the rack, then it goes in the autoclave, this is 3D scann.

15:41 So here’s our point, you know, our point cloud, and here we’re correlating our, the point, like what we’re seeing on the prototype, to our simulations, and you can see it has this kind of characteristic like side by-side bubble shape, which is what we’re going for, up here on the right. The other thing that comes up is that as you twist this panel you’re developing curvature in the middle of the panel, right, so that means that the straight line width of that panel is getting less, because it’s being turned into curvature, so the edges are kind of like pulling in from the frame. We can see that here in the prototype, up to 3.6 millimet, you might think that’s not very much, but the worst case we saw on the project was 6 millimeters, when we looked at all our simulations, which is enough to challenge the connection, here that’s going to compromise the silicone.

16:23 So to solve this we look, and we like, okay, we have four types of panels, some of the panels are curved on one end, some are none, some are both, that gives us four different patterns of curvature. Now we can start to create like a mapping function, from the outside of the panel, the perimeter of the panel, which we know, to these points in the middle, these sample points in the middle, to figure out what the deviation is at each of those points, because that can help us characterize the actual curvature of the panel. So what you’re seeing here are the values, those kind of seven deviation values happening in the middle of the panel that are correlated with what’s going on on the perimeter.

16:55 So if you’ve got those inputs and those outputs, then you’re basic on your way to like a very coarse machine learning model. So if you run something like 3500 simulations, I’m just going to skip ahead here a bit, you know, you get to like this level, and now you have a nice database of sample points. So what you’re seeing here is the correlation of one of those deviation points relative to the three parameters that like describe the geometry, right, it’s actually like a four-dimensional function, these are threedimensional plots, anyway. So here’s the seven different plots for each sample point.

17:29 Right, now that you have that, you can take your three, you can take your three perimeter points, map them to those deviation points using your mapping function, to tell you how to distort the shape relative to what you got out of the box. Now you can take that warped shape and simulate it going flat, and then as a quality control you kind of trace a new shape, perfectly flat, push it into 3D, make sure it matches your panel, if it doesn’t then it was out of tolerance, and that means you didn’t have a point in your sample space that was close close enough. So the good news is that simulation is still a pretty good approximation, so you chuck it in the database, rerun the training, and you get better as you go up the building.

18:07 At the end of the day this is what they get, they basically get a DXF and like, you know, four lines on a sheet, which is kind of really underselling it, but we were able to get this tolerance down from 6 and a half millimeters to half a millimeter. All right, so again, all that decision, there was no way to anticipate that from the beginning, because nobody had ever made panels like that before, but it gets embodied in the parametric process as you go through this kind of like chaining of metadata.

18:31 And then as we kind of race to the finish here, so then you put your glass on your panels, but in order to do that you need to know which pieces to put together, so we generate these assembly drawings, because all the parts in the model, all 8.5 million parts, know which panel they belong to, so you can basically ask them to sort themselves into the right bucket and then put themselves on a drawing, which is really nice because they have no autonomy. And then these panels, yeah, so here is like the kind of pace at which drawings are being generated, so you can see there’ll be like these huge jumps in output of fabrication data, and like I said, in about 18 months of production work we generated 1.5 million documents.

19:09 Now the point of all of this was, again, so that the panels install quickly, right, so there’s no computers happening on site, but this is the whole point, is that when this goes up you’ll see this huge like 2,000lb panel is only being held in place by the crane for a few moments, there there’s no real adjusting it snaps right in place, in its full threedimensional twisted geometry, and the crane is off and ready to pick up the next panel. And they’re done, ready to pick up the next one, on a good day on a flat building, like 40 panels a day would be a win with this process, go, why is it going, come on, 200 panels a day, that’s the punch line, there we go, each one’s different.

19:59 And so then to kind of just like recap here, we went from design to a data rich design model, which generated all the fabrication documents for the real thing, in this kind of like integrated network of decision- making processes encoded in parametric descript basically. And just to again prove the point, hopefully you you can see now that like there’s no way to guess from the beginning that it was going to end up like this, right, but then in the end you get some really lovely buildings. That’s it.