Dynam(o)ite Your Architectural Design: Optimization of Facade Panels

DIETER VERMEULEN: OK, well, welcome, everyone, on this cozy session. Hopefully we are not suffering from the party yesterday, like having some kind of booze air by the end of this session over here. So we'll see how it goes.

My name is Dieter Vermeulen. I'm a technical sales specialist at Autodesk. And I'm a structural engineer by trade, which is going to show you some stuff around architecture. So it might be challenging.

And I want to use my experience I have from the structural engineering in the past that I did in engineering companies with a workflow on architectural fabrication today. So which means trying to involve analysis where we can.

Now, the topics we are going to discuss today are quite a lot. You could see it already in that starting video, the trailer video that I just put up on screen. These are all the products, all the workflows that we are going to see today in this presentation. It's about facading. It's about complexity. It's about architecture, 3D printing, fabrication, computational design, anything you could think about when it comes to facade designs.

You might notice that if you went on the app and looked for the handouts that it was a very short handout. The reason for that is because everything is explained in this presentation with video material. And I wanted to share that information in a different way than just typing everything. Because everything is about Dynamo that is going to be used in here. And if you know Dynamo a bit, then you know that if you want to learn it you just have to read the scripts. And if you read the scripts, then you have to try to understand them. It's like reading a book.

And that's why the videos are in here in this presentation. And they will help you to understand a little bit more on how to do this yourself. Also the data sets are delivered. You find the links in the handouts. So you'll find links to the presentation. It's quite a huge one. It's about 700 megabytes. And the data sets are also quite big. So a lot of Dynamo scripts. A lot of Revit files and so on that you can find in there.

Now, the key learning objectives for this presentation-- of course it's about [INAUDIBLE]. It's about optimization the whole things around that design facade at least. But with that kind of perspective that a design is made in a certain way, that it's fabricatable. And like Andrew already told-- or [INAUDIBLE] already told this week in the opening keynotes, it's about doing more, doing it better, and using less for it.

So that's the thing we are going to do in here as well. When you create a facade, we want to do it better. We want to do it with more design options and use less resources to get to a specific solution. And this is actually the project I'm going to work on in here. It's not an existing airport. We call it the Millennium Airport. It's a data set that we started with, some people from the team I'm working for in northern Europe.

And it's about complex facades, as you can see on the top left, that needs to be filled with these panels. And the panels need to have some kind of dynamics. So the panels will not move in some way. But we want to apply dynamic mathematical formulas to them, so they give a very nice aesthetic representation, like that sine wave, for instance.

Now, for achieving this, I collaborated with a few partners. One of them is EvolveLAB. Yeah, he's sitting in here. So you can go to Bill afterwards, see if you have some more questions about it as well. And Canon from the Netherlands. They helped us to build these nice models that you can see here in front of my desk. So these 3D printed models. Yes, it's not that big. They are scaled 1 to 500. This airport like 160 meter of length. So it didn't fit in the room here.

And there is also Schuco. Schuco is a facading-- let's say, they develop products for facading. And one of their products is called parametric systems. So they helped to create fabrication drawings and the real fabrication of panels for that specific project in here.

Now, the challenges that you as a facade designer, or just a facade designer in general, is facing. We could see this as two separate challenges, One's during the design phase and another one during the fabrication phase. Now, during the design phase, the challenges that you have in there is mainly about the concept of that facade, the layout of your facade. Like the grids. How many vertical grids, how many horizontal grids I'm going to use.

This could be an aesthetic decision. But it could also be a more informed design decision, like for instance, using solar analysis. That one will go to define how many panels you want to have, or at least what is the aperture size, for instance, within panels.

When it comes to the fabrication phase, a fabricator can receive designs which are very difficult to fabricate. They need a lot of custom solutions to satisfy, actually, the requirements of the architects. So what if the architect has the tools already when he starts designing the whole thing to make something fabricatable, so that the fabricator doesn't have to challenge with, for instance, non-planar elements? So that's the whole idea behind this workflow.

So the project goals for this Millennium airport was defining a facade layout with an optimal grid division. We're going to optimize, then, the facades by driving their parameters, like extension, and height, and some kind of things-- you will see it later on in the presentation-- by external influence. That is external influence. Could be solar analysis. Could be mathematical formulas. And we want to reuse that data to do some architectural prototyping. The results are on here. At last, also, we want to reuse, again, that data to create a fabrication model, like fabrication drawings or fabrication digital data to drive machines.

Now, there are some constraints when it comes to the fabrication of these panels. And one of these constraints is a very important one. It's planar deviation. I've talked about that already in another class I taught yesterday when it came to steel plates. Some of you-- I see some familiar faces from that class. We talked about that as well. If you're producing steel plates, you want to have very flat ones. You don't want to have double curved ones, because it needs more fabrication methodologies to get to that point.

And when you have a double-curved facade, sometimes you can only solve it by having non-planar elements, or at least that's what the easy methods would do if it comes to designing. When it comes to fabricating, then you are, again, with that very challenging solution. So what we are going to do here is take a double-curved facade and try to make flat elements on it. It might work at some parts. It might fail at other parts.

Now, to get to these points I took four phases. The first phase is where we are going to define the layout of that facade. So the grids. How many grids are we going to use? Then finally, we are going to use that grid to place panels-- that's not finally. That's the second step, actually. The third phase, which is more like an optional step, is making a facade prototype with these 3D prints. It's not obligated to do that, but it might be helpful to have something tangible when you are talking with your customer, for instance, about that facade. And then final, in the phase four, that's where the panel fabrication is going to be executed, retaking all that digital data from the Revit model, for instance.

Now, we could call this-- or we are calling this, at least at Autodesk, connected BIM. In this case, it's connected BIM from design to fabrication, just focusing in here on facade panels. There is also connected BIM for any other discipline, for structure, for construction, for just general architecture. In this case, it's about having that conceptual design, bring it into detailed design, go to that facade prototyping as an additional optional step. And then come into the facade panel fabrication.

Now, the products that are used in here can be mapped as this. What is very obvious here is that there is an overlap between all these products. That's actually what our competitors sometimes fail in. They have gaps in between several of these products. So we try to get an overlap throughout these phases. To get, for instance, that Revit model starting already in the optioneering phase, but drive it through until you get into the fabrication part of it.

It might happen that if you're doing this on your own projects, that a solution mapping might look different. For instance, Dynamo for Revit could be used already from the conceptual design phase if you, for instance, are not using FormIt in this whole process. So this is really for this solution that this mapping has been used. On the bottom right, you can also see three products which are not Autodesk, which are products coming from Schuco but build on top of Revit and Inventor. So these are called SchuCad, SchuCal, and SchuCam. So I will tell you more about later on in this presentation.

OK, let's kick off with phase one. And I'll need to have a look on the time. Phase one is a part where we are going to set up this whole layout of that facade. So I told you grids, vertical and horizontally. And these are going to be defined-- or that layout, at least, will be defined by means of Dynamo. The reason for that is with Dynamo Studio you can reach out to the cloud. You can connect with Dynamo Customizer, which makes it possible for external stakeholders to work with that script and to find solutions for a specific problem. And then finally, we are also going to use Fractal to get all the design options generated in multiple ways.

As you can see, there are a lot of colors in there. These colors are not just for aesthetics. These colors are results of analysis. And before you start, you need basic geometry. The basic geometry in here is the facade of that building, of that Millennium Airport. Now, as the facade already existed in another product-- could be Revit. It could be AutoCAD. It could be an external non-Autodesk software. We need as SAT files to have that one back in to Dynamo Studio.

Now, of course, it could also happen that you are creating your surface of that facade yourself already by using a Dynamo script to create that geometry. So this is only for this solution. We are going to use SAT files.

Now, the creation of that SAT, you make it in different ways. In Revit, for instance, if you want to have an SAT of the facades then you select the surfaces and you export them to an SAT file by means of Dynamo. And that's it. Nothing more, nothing less.

Now, if you want to configure that whole layout-- so as you can see, it consists of four parts. The first part is inputs. Then you have the surface which is going to be created, or at least recreated. Panel fabrication will be checked, or at least the readiness will be checked. And then we will get the results from it.

Now, the inputs in here are these four facades. So you can see them. This is one of the facades. This is the other one. And then we have two at the back. So these are the four SAT files that got brought in back into Dynamo studio. Now, the reason why this facade-- why these surfaces are rebuilt in Dynamo is because these facades were created in Revit by means of a mass which is trimmed.

So actually, if you create a geometry in Revit and you're using void to trim it, then Dynamo reads it in the same way. And it reads it that way that it will generate lines on that surface and a-- it's very difficult to explain that. If you look at the class that I did yesterday, you will find out more about how this surface evaluation can be done.

Now, if you recreate this whole surface then you also have the same result as the ones that Revit has done before. So creating that trimmed surface. And this means that you can create in an easy way those quad panels on top of that facade. Now each of the panels are unique in here.

Another thing is that the quad panels node that is used in here, it's coming from a package I built called BIM for struct productivity. They are built up with design scripts. The reason for that is because Fractal cannot read the custom notes that are built with, for instance, zero touch technology, Visual C#, or, for instance, a Python script that's built in. So design script can be read by Dynamo Customizer and Fractal. So that's actually the only reason, not because I wanted to reinvent these specific methods.

Now, once these panels are generated, you get an output for the quad surfaces, the four points of each of the quad surfaces, and also its perimeter. So you get the polygons from it. Now, we need all that information to do some kinds of checks. Now, these checks are very custom. Might be that you don't want to check on the surface area. Maybe you want to check only on planar deviation. Or you want to check on, for instance, the panel size in a different way than I'm doing here. This is more like showing you, how is Dynamo helping you to create all your own analysis from it. So the whole pink part is actually validating the geometry of each of the single panels.

Now, at the end, you get a few results. You get the results for typical panels. Typical panels are the ones that-- meeting the design check. You get custom panels. These are the ones that need special attention from the fabricator and might need a custom solution to get there.

Now, it depends on which analysis you're performing on this whether Dynamo will decide if it's a typical or a irregular or a custom panel that needs to be created in here. So it could be, for instance, that you're checking on the dimensions, or in this case, on the rectangularity. Or you might check it on, for instance, the planar deviation. Rectangularity. It's also a very important thing if you work with standardized panels.

Now, some nice stuff in here with Dynamo is that you can toggle your results. You can bring all your results together into some kind of list and then use sliders to toggle between all the possible results. So this is, for instance, the results for rectangularity, then the planar deviation. And then another one is to check if it's fabricatable, for instance, based on the surface and its parameter distances.

Now, these colors are then-- these are important to use when we come into Fractal. Because Fractal is very visual. It gives you the results into nice thumbshots. Or nice thumb-- just like that thumb images. And if you filter them on the basis of these colors, then it makes it easier to find out the right results for it.

Similarly, you also have these watch nodes, as you can see in here. They are nicknames. If you nickname those watch nodes, then you get them as a real result in Fractal. So you will see a few slides later that we will have all kinds of results in there based on these watch nodes.

So once you have built that whole script in here, so the whole analysis from it-- as you can see, the surface creation is a really small part. It's really about creating that fabrication validation. That's the most important part of this whole script. And that will change depending on your inputs. If you change the input parameters in the front of the script, then you will get other results. You will get other colors. You will get another analysis. You will get another output for these watch nodes.

Now, this is Dynamo Customizer on screen now. And Dynamo Customizer is actually accessible for anyone. It means that people who are scared of that Dynamo script, and they just want to drag the sliders and want to see how it works or what results you might have if you use a specific parameter, that's where this platform can be very helpful. You just share that link to another one. He can open it, or she can open it and then work with these sliders and see the results from it.

Now, the results can be downloaded. On the top right, you can see that little arrow. You can download the Dynamo script from it with the right values and then reuse it in the rest of the workflow.

Now, of course, it's not just that easy to find out the right solution for that facade. You might drag all these sliders all the time. And after one day long dragging sliders you don't even know what is the best solution now. So that's where Fractal comes in. This whole design, this whole script is also available through that same web platform, which we call Dynamo Reach. And that server exposes the whole script into Fractal.

So Fractal will-- what you can see on there is on the top left, you have those black parameters. On the right, you have these red parameters. The black ones are the input. The red ones are the results. That's what we call a parallel coordinate system or parallel coordinate diagram is better.

On the right hand side, you can see all the parameters, all these sliders. And what Fractal is doing right here is making combinations of all of these input parameters. It calculates it according to the analysis that we just built up in the first script. And then it generates all these little images. And plus, it also gives you the results in that parallel coordinate diagram.

Now, the thing is that you can then make decisions based on these results by, for instance, filtering them. So let's take the full generated panel in here. So as you can see, on the left there's really a combination-- a cross combination of all of these-- cross product combination, as we call it-- of all of these number of vertical and number of horizontal divisions. So the lateral and the transversal divisions of that facade. And you get the results in red. For instance, number of custom panels. Or you take the panels with the smallest planar deviation.

As you can see, the result for this facade is not generating something where planar deviation is zero for each of the panels. It's inevitable in here. There are always some parts that will have that small deviation.

We could solve it with triangles and pentagons, maybe. But in this case, we wanted to have rectangles for all of them. And then it's inevitable. But as you can see, there are 10 possible solutions. For instance, the solution on screen right now only needs four custom panels. So these need special attention. That may be a cheaper solution. So everything else can be done with the standardized elements from Schuco. But the four others cannot be done by that. So they need different methods of fabrication.

If we did, for instance, another way of facading-- let's say that we have, for instance, one transversal or one vertical grid extra in here, it might come up with maybe 10 of these custom panels, which is a way more expensive solution in here.

Now, once these layouts are defined, the architect wants to represent it to his customer. And that's where FormIt comes in. Now, as FormIt is also a cloud-connected platform, it can connect with these scripts that got uploaded to Dynamo Reach, so to the Dynamo Customizer. So you get it from Dynamo Studio. You send it to the web. It's available through Dynamo Customizer with that shared workspace as we just saw. It's available in Fractal. But it's also available in FormIt.

So the thing, how it works in there-- and we just saw it-- is you create your surfaces in Dynamo. You send it to the Dynamo server. And then you reuse it in all the web platforms that are connecting with that part.

FormIt can be helpful in here to set up the building environment. And then we get that Dynamo script that got used in Fractal and Customizer. And you can place it on there.

So this is how it goes. So I'm not showing in here how the building environment is set up. So I'm assuming that someone who is using this knows how it works in FormIt. But one specific part in here in FormIt is very exciting. As you can see on the right, there is a panel with all the Dynamo scripts that are available, in this case, on my Dynamo server. So you can click on them and place them into that building environment. So you also get those sliders. So you get those parameters that make it possible to drive that layout, again, of that facade. Plus, you also get the results. You get your fabrication verification immediately in there.

Now, doing some other specific tricks in here in Dynamo-- in FormIt, at least, like, for instance, copy-pasting the facades, put them on another facade, and so on, makes it possible, then, to drive it for the whole design and then see if there are any differences between each of the different oriented facades in there. Now, to get to that point, you need to make sure that you make them unique. That's very important in here. Because if you place one of those Dynamo components inside of FormIt, and you place them a second time, if you change one of them, then all of them will have the same change. If you make them unique, then you can have, like it says, unique facade panels over there.

In the second phase, we are going to get into a more detailed design. A detailed design where we want to have all of these panels coming from that FormIt layout, coming from that Fractal analysis that has been done. And we are going to place, now, the real elements inside of a Revit model. So again, we have the specific masses that have been created. They could be extracted from the FormIt model. That's also possible. In this case, the model existed already in Revit. So that's a bit easier to work on.

Second step, you need to create your panels, of course. You need to create some adaptive components that can be placed in here. So that is a technology that is used in here for that.

Dynamo is used, then, to calculate the panels or at least to calculate the points that need to be used for the placement. And then afterwards, we are also going to use some specific analysis in Dynamo to give it a more dynamic feeling on those panels. So we are going to change the parameters of each of these panels individually.

The panels that are driven in here, it's very simple. Only two. One is called extension, and another one is called height. As you can see, by driving them you get all kinds of different results on these panels. That's typical for that parametric system from Schuco. You can change these two parameters and make completely different-looking facade panels. You can change also the material of each of the sites of that panel. So the top, the left, the right, and the bottom can have different materials.

In this case, I also built in a few detail-level representations in there. Of course, one could be used, for instance, to only have the flat panels inside of your Revit model, which could give you the idea of a concept. So it doesn't show anything about the real geometry of that panel. It's only showing you the placement of it. That's something very handy if you want to use colors on top of that Revit model.

The medium one, the medium detail level, that's the one that's used for 3D printing. So the result is, for instance, on here. As you can see, there are no openings in this model, only some colors representing the class of that whole thing. So that's where the medium detail level is very important for. The fine one, that's the one that is important for making the fabrication. So for making the real panels afterwards, in this case with Inventor.

So placement points, easy. You need to have four placement points to have a rectangle. It's important also that you respect the right order. Dynamo generates these points in a specific order. Make sure that your Revit family also follows that order, so that you don't have panels that are upside down.

Very specific in this whole workflow is reusing scripts. So you don't need to rebuild that whole script to place the panels. You just reuse all of the things that were created for the panel layout. Also reuse the panel fabrication readiness, for instance.

Now, there are many methods to place these things. In this case, I want to use Dynamo Player. It's a very accessible tool palette you get in here. It makes it possible, actually, that anyone within the company that wants to use Dynamo can use it without having to be a Dynamo scripter, or a Dynamo programmer, or whatever you want to call it.

So let's just have a look in here. This is not to get to that point. This is really a video to show you how it is built up. And as you can see, the first parts of that script are completely the same as the ones that are used with the panel concept fabrication, or the layout as we called it. The only difference that we have is that the facades are not read as SAT files in here. They are read as just surfaces. You pick the Revit surfaces. Then you create the layout again on top of that surface. And the quad panels will generate you the placement points, which then can be used to place the panels for it.

I take some time to place these panels. Let's go a little bit forward, because we saw the fabrication already. If you want to place them, you don't need to go-- you don't need to dive inside of that Dynamo script. You just use Dynamo Player. Select the face, select the panel that you want to place. Give the number of vertical grid lines, and so on, and so on. And in this case, there is even a toggle that is used, like the create Revit panels toggle that you can see in the middle.

It doesn't generate anything in Revit. But you get your analysis results in Dynamo Player. It gives you the ID if your layout is fabricatable, yes or no. So that saves you some time. Because if you place adaptive components, like in this case, 306 per facade, it's a bit-- you need to wait some time. You need to wait, like, five minutes until the facades get generated. If after this five minutes you see-- you notice that the results are not really satisfying, you have to restart all over again. So using those switches is very handy to get to that specific point.

In this case, the facade is very irregular. Each of the panels have the same extension, have the same height. So there is no dynamic that is placed in there yet. That's something we are going to do in the second part to save some time again. To first have a look-- OK, are these panels fabricatable? What about the layout of it? And then we're going to start to drive these whole dynamics in there.

The first one-- I'm going to show you two specific workflows to drive these dynamics. The first one is panel dynamics driven by a sine wave. Actually it's going to read the placement points of each of the existing panels. And it will create a sine wave along that curve that it generates. So you can see on the third slide on here we have the placement points of the panel. So there are, like, one, two, three, four five, six, seven rows. Each of the rows are generating a sine wave. That's actually the thing that is going to be used in here.

Now, once we get that sine wave, there will be a delta set. So that's where engineers start to like architecture. If you talk about engineering values like, oh, delta, that's nice. So we are calculating that specific value. And we are going to use that value to remap everything for creating the extension values and the height values of that specific panel. So you will see it immediately how that works.

So this is the starting. Each of the panels have equal values for extension, which is driving the outside part of that panel, and the height, which is driving the vertical bar, let's say, of that window. Looks like a huge script. It is a huge one as well. But the first part-- the half of the part, actually, on the left is just sorting. And that's specifically needed for this project because there are four facades. And I don't want to have each facade working in a different way for that sine wave. I want to start with, for instance, the front left, and then and go to the front right, go to the back, and so on. So you want to do it facade per facade.

While all the panels in this whole model are using the same family, and we're reading all that families inside of the script, then you need to group and sort them a little bit. So in some cases, might be if you just have one facade, then you can skip this whole part. And you only have half of the script. So it's only about taking the right panels and then trying to get their location points.

Now, in here, the location points, it's actually the middle point of that panel. Just create two diagonals. Take the intersection of those two diagonals. And you have the middle point of that panel. This is the one that is used.

So these are the points that you see, now, on that screen. If we change the facade, then that whole grouping in the first half of the script-- that whole grouping will change the position of these points. And will consider another facade, of course.

Now, in the next part, these points are going to be used to create the specific curves. At the start we are going to have straight curves. And by applying a mathematical formula, these points are going to be driven in a specific way that you get that sine wave. So it sounds simple. If you understand the whole thing, how it works in Dynamo, it is actually simple. But it just needs some thoughts about how do you displace a point in that way that it shapes you a sine wave. Well, the solution is in there. If you face that problem once, then you don't have to look for that anymore. It's completely in here. And you can reuse it for any type of facade actually.

So these are the points. These are the points that need to be evaluated to find that delta set value. So we have the points of the panel, the placement points. We get that sine wave. And now Dynamo is going to project that point onto that sine wave and evaluate the original position of the point with the new position of the point. And that's what is going to be used as that so-called delta set value.

Now, these deltas set values are used, then, to remap. As you can see on here, there is a mat dot remap range node. This node is one that can change all the values, for instance, between 0 and 1. Imagine that you have delta set values between, let's say, 300 and 1,500. You want to remap them in a specific way, like minimum extension and maximum extension. Because these panels have fabrication constraints. They cannot have an extension of 1,500, because that panel would be too big. So there is some constraint on that.

So the remapping is going to use those constraints. So remap all the values of that delta set to have the minimum extension until the maximum extension. And that's how you will get a dynamic. If you look on the top of that facade, which is going to show a sine wave. And if you look on the front of that facade, you will also have that sine wave driven by the height parameters.

So this is how it works if you are going to execute them. So the first part was explaining you a little bit on how you get to that sine wave and to those values. The second part is showing how to actually apply it. And the application of it is very simple. You only need to select your panels, and then give some parameters which are specific for a sine wave, like the amplitude and the frequency. And then run it and nothing more. Has to be done in here.

So if we take one of those panels, you can see now that the parameter of extension and height has been fitted with a specific value. Now, this value is something that has been remapped between that minimum extension, maximum extension, minimum height, and a maximum height.

Drive it again for the other facade now in here. So that's very specific for this project. As I told you, we have four facades. So there is that slider that is using the grouping of all the panels and then drives the other facade on it. Might be in your own project that you don't need it. Then you don't need to have that switch.

Now, this is the result you get from it. As you can see, the sine wave is working in a frontal view. It's also working if you look on it from the top of it.

Another way to drive these parameters could be, for instance, solar analysis. In this case, we want to create a solar analysis on top of one of these facades, which will be influenced by, for instance, the roof. As you can see over here, that roof has a small extension above that wall. So we will get a specific shadowing on that.

And based on these results, the points, the analysis points, will be taken. Again, they will be mapped with a specific panel, the one which is closest to it. And then it will remap the values again for extension and height. And it will get a specific result. The expected result that I would love to have in here is that the places where we have a lot of sunlight on that specific moment, there the panels should be as closed as possible. The panels where we have less sunlight, these should be open. That's actually the project goal in here.

So you get the panels. We're going to perform a solar analysis on the facade, then remap the calculation points with the location points, and then change the parameters from each of the panels to meet, actually, the results of that solar analysis. So the definition of that specific script-- again, we can use Dynamo Player at least for it. It's exactly the same way of working. You go into Dynamo. You build up the whole thing. And then you use Dynamo Player to apply it on all of these facades, and done.

Now, the solar analysis is done with a specific package called Solar Analysis for Dynamo. Obvious. Very important for that is that you need an internet connection. So if you try it and you don't have any connection-- for instance, you go home and you sit on the airplane. Oh, let's test that solar thing. It won't work. You really need internet. Or you're using a weather file, which is actually an online file that you can connect to it. But I wouldn't advise that. Take the real place that you are using for your specific project.

Again, as you can see in the front the panel opening extension and the panel opening heights are limited by that fabricator, in this case Schuco. So these parameters are used, now, later on in the script to find the appropriate remapping. Again, filtering all the panels. Because we have panels at each facade. And I only want to get the specific panels that are placed on the facade that I selected.

That's a little bit of complexity I added into that Dynamo script. It's not really needed to have it to make that specifically working. What you could do yourself if you're working in Revit is select the facade, select all the panels that belong to it, and then done. It saves you half a script.

In this case, I did it differently. I told myself, OK, I only want to select the facades. And done. Find which panels are belonging to which facade. So that's actually that kind of filter.

Now, engineers like colors. We like colors to see how analysis actually-- what are the analysis results actually for a specific thing that we've done in here. So you make a color range with the dedicated Dynamo nodes for that. And then you can display these colors in many different ways. Or you display them on the surface of that geometry in here. Or you display them, for instance, with points. So in this case, I'm coloring the placement points of each of the panels. Or you display them on the Revit geometry. It's also a possibility.

Now, as you can see the black points are the panels. The colored points are the analysis points. So actually the solar analysis is generating some kind-- it's not really a mesh. It's only generating points. You can simulate it with a lot of points if you want. But if you have, for instance, a million analysis points and you only have 300 panel points, you need to know which point is actually closest to that panel point. That will be the one that will be deciding what kind of value that should be used for the extension and for the height.

So that's where that specific node came in, as you could see, called closest point search. It's actually an algorithm that is built in in one of the nodes on the BIM for struct productivity package. And it finds the appropriate points of your panel mapped with the calculation points. It takes the value of that calculation points. And then it drives the parameters of those Revit panels.

Now, as you could see already a few seconds ago, suddenly the Revit geometry came in and was colored. These are actually the results of bringing those closest points calculation, mapping it with the analysis results. And that way you can see if your process has been executed in the correct way.

Another thing which is showing you, actually, that analysis results can be displayed in many ways is the view analysis inside of Revit. There is a possibility to create view analysis results inside of a Revit model by means of Dynamo, store them inside of that Revit model, and then use, maybe, other ways of representing the results using color maps, or points, again, using a specific legend for that, yes or no.

So that makes it easy, then, to evaluate this panel design, compared with a solar analysis inside of that Revit model. It's actually the result that you see on this 3D print. We have the colored facade. And then if we place those panels in front of it, and if you have a closer look-- maybe the people in the back will not see it. But at the end of the class feel free to come over here. You can watch through those windows and then see if the solar analysis will not influence too much the openings of your panels. Maybe you want to use that sine wave. But maybe these solar results are too extensive on that facade and makes it impossible to have the right lighting inside of your airport, for instance.

In this case, the panels are driven differently. And as I told you, I want to close down the panels way more where we have too much of sunlight or where we have a lot of sunlight. And I want to open them up where we have less sunlight. So it's like an interpretation that it has done in here to find the right values. Instead of you having to find manual which panels should have which parameter value, it's mapping with the results coming from that solar analysis.

Again, if we want to use this on other facades to drive these specific parameters, you just go into Dynamo Player, select a facade, and then go on. So in this case, I select this facade. Select the shading surfaces, which is the roof. Could be more than only the roof. Could be also the roofs on the other objects. And then run it.

So actually the script that you got in here, without the panel dynamics part, could be used to just create solar analysis on any surface you have in here. So just get your Dynamo Player configurated with that script, select your surface, play it, and then get the results in there. Now I must say in this case, the solar analysis is going very fast. And the reason for that is because it's just taking one specific point of the year. It's looking at one day at one time.

Of course, if you do this for real facading, then you might need to consider a whole period, maybe summertime, for instance. And then you might get very weird results as well. It might happen that you only have very dark places underneath that roof. And all the other places on that facade are very bright. So that won't do anything to your panels actually. Or you might get a very dispersed distribution of all of these panels. So might be less aesthetic. This is really just about the concept of it.

Now, let's go to the third phase, which is actually that optional phase. In this case and this project, the architect wants to have something tangible to find out if, for instance, these sine waves-- if it's really going to be easy to place these panels. Is it easy to, for instance, fabricate them? Plus also I want to have something to present to that customer in a more, like I said, tangible way.

Now, for that, we collaborated with Canon printers in the Netherlands. They have specific printers that can work with gypsum. And the idea in here was also to have colored prints. Now, it's not the idea of having, say, solar analysis printed. You might wonder what's the use of that, printing solar analysis results. Well, the use case in here is more like to see-- how can we get those colors into a specific file format and then use it to drive a 3D printer, which can print in color? Now, the only way how you can get to that point is using what we called colored OBJ files.