Structural Dynam(o)ite: Optimized Design and Fabrication Workflows with Dynamo

DIETER VERMUELLEN: Well, welcome on this Dynamo class about structural optimization. My name is Dieter Vermuellen, to make sure that you pronounce my name right. I live in Belgium, where I am based, in Belgium, and work as a technical specialist at AutoDesk for the Northern European region, so I see some familiar faces. Some people in here, we know each other already.

And in the presentation, you will find some links in here in my profile. And this is something for you for afterwards. When you open up this presentation, you will see it's a PDF. So I will upload the presentation, the PowerPoint presentation itself, on my blog later on next week, so then you will have the videos that they will show you today as well-- plus, also, the data sets, because it's a huge amount of files. So we will find them on my blog later on also. So keep an eye on the blog for the next coming weeks, and then you will have all the material that I'm going to use today so that you can practice yourself with all of this.

It's going to be exciting because I'm going to try to do live demo, so it always goes wrong if you go live. But let's try it so it's fun. And my goal is to give you some more insight and the specific techniques, the specific optimization techniques, that are available with Dynamo or that you can find out to use with Dynamo and understand all those techniques as well. So the goal will be to get a little bits into depths in those techniques, having very complex ways of performing optimization. But you will also see some really nice product that we launched this week, or at least we made it public as a beta. It's called Project Refinery. You might have heard of it already in other sessions. So we are going to go live with a product as well so to see how this can help in structural engineering.

Good morning. So let's just have a quick word on how to describe optimization. So the definition according to Wikipedia is actually that optimization is about selecting. It's about selecting the best elements from some sets of alternatives. So if you perform multiple designs-- if you get multiple designs you might have multiple design options, especially in computational design. So if you perform something by hand, you will have one ID. You might describe only one ID. But with optimization, you will have multiples. You will have thousands of design options. So the trick in here is to find the best one. So you need to define some specific criteria to get into that best solution. So that's what we are going to learn today.

Now, those thousands of design options could be like this book. You could see this as your design space. How will you find the best page in that book? It's not by reading this whole book, because that might take a lot of time. You want to find that as quick as possible. Because you don't have any time when you're performing your job and when you need to optimize structural problems. So we will have a space of optimal solutions. It could be that a few pages in that book are the ideal ones. It's not only about one solution. It could be like three, four, five, 10 solutions out of 10,000 that are the best ones.

And if you would organize all of these solutions in this kind of diagram, you get in what we call the parietal frontier. So a parietal one is actually all the possible optimal solutions in a multi-objective optimization. So multi-objective optimization is then where we are trying to find the best compromise between multiple objectives. Imagine, for instance, you want to have a solution which is as cheap as possible, but which has the best-- let's call it the structure weight or maybe the structure volume. So that's a contradiction you have. Because the more material you have, the more expensive your structure will be. So what is the best solution? You need to find that compromise. That's what we call a parietal.

Now, in a single objective optimization, which is very rare in the AEC world-- it's like saying, OK, I need to find the best solution which is cheapest. But just having something which is cheapest means, yeah, let's have nothing. OK. So that's what we call then the single objective optimization. And you get those two blue points at the end of that diagram. Or it's cheap or it's very heavy.

The methods we are going to see today. There are multiple optimization methods. I'm only going to use two of them. One is called brute-force search. Now, brute-force search is actually going through all the possible design options, evaluate them, give them a score, and then use some techniques like, for instance, Excel or Mandrill ways of working to, for instance, find the optimal solution in a diagram or in a table. So that's actually what brute-force is doing. It also evaluates problems that might be not even optimal. So that means that it takes a lot of time to perform that kind of optimization. But at the other hand, it's very simple to implement. So you need to find a good-- you need to find out what is actually the best method in here for specific structural problems. So I will teach you that today when we are going to use that brute-force, for instance.

Another one is a more complex one. It's about genetic algorithms. Now, genetic algorithms, is a optimization which is search-based, and it's using specific algorithms that are based a little bit on the natural evolution theory. So think about the evolution of species, but in computational design. So it's like survival of the fittest. It means that solutions that are converging to the best score, for instance, for your problem will be taken into account and they will evolve. So they will be like genetically manipulated to get the best solution.

So actually this guy helped us on that. Well, not about programming the algorithm, but his theory is actually used in that kind of optimization technique.

Now if you look at generative design, you always start with setting up your data. So you're initializing your specific problem. You initialize your constraints, your requirements, and you generate the first option. And that first option gets evaluated. Now, evaluating a problem could be, for instance, what is the cost of that structure? What is the maximal stress inside of that structure? What is the deformation? So that is an evaluation. And those results you get, you're comparing them with the constraints you set in there. So for instance, the structure cannot cost more than $100,000, or the structure cannot have a deformation bigger than 5 millimeters, for instance. So that's evaluating. That's giving something a score.

Now, if the score is bad, then it needs to evolve. It means that the parameters that are used to generate your structure need to evolve to some kind of better solution. It will be generated again-- evaluate it, evolve, generate, evaluate, evolve until the loop finds a specific solution which is meeting your requirements. And that's where you stop the optimization routine, and that's where you start selecting the best option in here. So that's where the human interaction comes in.

Now, I'm going to present you for that three workflows that are using specific software in here. So we are going to use Dynamo. But in this case, I'm using Dynamo Sandbox. So Dynamo Sandbox is actually Dynamo for Revit but you open it up as a standalone application. So by just going into the Program Files and then open up DynamoSandbox.exe. Important thing here is that for all the scripts that you will find in the data sets, you need at least Dynamo 2.0-- preferably Dynamo 2.1 in case you are going to test it with Project Refinery. Also, Robot will be used. We are going to perform also some structural analysis and use it to optimize the results. Project Fractal will be used in just one slide, just to show you how we did it in the past. But as you might have heard already in other presentations, we are now replacing Fractal by Project Refinery.

So actually, Project Fractal is more like a private beta. So you need to request access before you can enter it. So probably-- I'm not sure how they will do it right now, but probably if you try to request access for it, you will not get any access anymore because we are closing it down and get it into Refinery instead. Plus, also, this one is using Dynamo Studio as a connector. Not Dynamo Sandbox. There's a big difference. Dynamo Studio can connect with the cloud. Also Dynamo Studio only has until version 1.3, while Dynamo Sandbox goes into 2.0. So also an important thing to know.

The public beta-- at least, it's public since last Monday. Its Refinery. And with Refinery, it's actually generative designed for AEC. It gives you the possibility to optimize your designs, to explore your designs, to perform randomization, even, with your designs. You get thumbnails for it. You get scattered plot diagrams with four dimensions. You will get a table for it, and so on and so on. So really nice stuff you can do with it. I'm going to show you some live pictures-- at least live demos of that.

So the three workflows. The first one is about deformation. It's more a conceptual analysis we are going to perform without using analysis software. We are going to use Dynamo and Project Refinery. And also a package called DynaShape. So I will explain a little bit more about it later on in the presentation. The second workflow is about the shape of a truss. So we are going to optimize-- not really topology, but really about the shape of your truss. We are going to find the best shape for that truss compared to what the specific results in structural analysis. So we are going to use Robot for that. And then finally, the Mars Torus Arena. So people among you that already came to AU last year, for instance, might have seen that project already. It's something I used for other optimization and design automation techniques. So we are going to use that one again today, but then more in a brute-force optimization.

It's fun over there.

So the spatial truss. That's the one we are going to work with. This one here. And the idea in this case is that we need to find the best configuration based on three specific objectives. So the three objectives in here are the platform area. I want to have a platform with the biggest size. But I also need to have a minimal deformation. If we'd look at this from a single objective optimization perspective, and if you would say maximum platform area, then it would be like an infinite, big platform. But then it would not meet your deformation requirements. So I need to have something which finds the best combination of both of these objectives. And besides that, I want to have like a third objective in here. It needs to be as light as possible, so cost effective.

And how are we going to get this solution? Well, you need to tell your software-- you need to tell your script, in this case, what kind of inputs that can change. Because you cannot change everything of a spatial truss. You need to be quite specific on that. So we are going to change the width and the length. That's obvious, because I want to have a bigger area. These are the two drivers for the area. I also am going to start-- to change at least the starts depth of that truss. So it's actually defining how high it will be at the start, and also how high it will be at the end of that spatial truss. Besides that, also the truss divisions. So how many panels are we going to create within that truss? So this will be very effective when we want to have, for instance, the minimal structure weight. So the less divisions, the less weight.

What you will see in all of these data sets is-- normally, they will open up with his blue box centralized on your screen and it gives you some information about a script, and it also gives you some important information about which packages are used. So always make sure when you test it that you install those packages first. I'll explain in a handout as well where to start, where to download them, and so on.

So in this case, we need DynaShape developed by our dear friend Long, who's sitting here as well. And it's an open source plug-in. And it's used actually for form finding and physics simulation. So it's not really defining the deformation of my structure based on, for instance, strength of the material or based on the size of the materials. No, it's giving us more like a conceptual idea on how the truss will deform based on some loads that are put on there. So I will explain you a little bit more in detail when we go live.

The workflow which is used in here, it's starting with defining your geometry. That's obvious. That's always the first ID. So it's generating your initial set of data. Now we are going to perform the analysis. That's actually the evaluation parts together with the results evaluation. So you get results, and then you need to compare them with the constraints. So for instance, deformation can not exceed a specific amount. That's actually your evaluation from it. Or you'll give it a score. That's also something we could do. And finally, we are going to use this whole script to optimize it in Refinery. So Refinery will drive multiple sessions of Dynamo, generate all the possible solutions, and take all those evaluation results into a diagram, and then, there, you can select which is actually the best solution for it.

So the first step, or the first three steps, you need to do for this particular problem is you need to have your roof. The shape of your roof. It could be an SAT file or it could be geometry that you define and Dynamo directly. So in this case, we are going to model everything inside of the Dynamo environment. So no external software used in here to get that roof surface.

So the idea here is, how do we get to that spatial truss? So how do you create all those elements? So you need to think already from that structural perspective, because you need the specific beams, the beam elements, without even thinking about the strength of that structure.

When we perform the analysis, that's where DynaShape comes in. And with DynaShape, we are first going to define what are the anchors. So where is the structure attached to? And give it a specific weight. Not a weight in as, for instance, the mass of your structure, but the weight in, how heavy is this anchor? How strong is this anchor? That's actually the weighted follow for it. Same time, we are also going to define the stiffness. So how stiff is that structure? So we need to give it a weighted value for that as well. So the smaller this value will be, the weaker the structure will be. Define loads. That's obvious. If you want to have deformation, you need to have loads. Not only gravity loads or self weight loads at least from your structure, but superimposed loads, for instance. And then finally, we are going to perform that analysis and you will get results from it.

Now, how do we evaluate the results? Also something very important. In this case, we are going to use a deformation ratio. So it's not like the real deformation. It's the difference between the original points and it's deformed position. You will get a value, but this value is not like the real distance that it will deform in reality. It's more like an indication of how big the deformation will be. A material score, also very important. Because with the material score, this one will indicate how much of material we are going to use for that specific problem. And then finally, it's the platform area. Very obvious. Length times width-- that's your area. In the last step where optimization comes in, that's where Refinery is taking all those inputs, creates a study, and then performs the optimization. It's very simple. It's even more easy to use Refinery than to set up this whole script in Dynamo.

OK, let's show the real part of it. So this is that data set. Or at least that one file. This one file is doing everything. It's performing-- it's doing the initialization, the evaluation, and then after, it's also the optimization. And as you will see-- and I need to take a little bit track on time. OK, perfect. As you will see, we have like five parts in there-- input, geometry, definition, the goals definition for the analysis, then the analysis itself, and the results evaluation. Always try to work in that kind of principle if you build your own script. So that slide where I showed you-- data, generate, evaluate, evolve, select. Try to use the same principle into your own diagrams as well-- into your own Dynamo graphs at least, as well.

Now, the input in here-- we've already defined what the input will be, because the platform size will be defined by the width, it's length, and then also the truss dimensions with it's start depth, end depth, and the truss segments. So these are the values that are the drivers of our new geometry. So I will not go through everything in this script, because we are not going to learn about how to create lines in Dynamo, but more about how to use that to perform your own analysis. Now, what I always use in these kinds of scripts, and which are very handy, is our visualization techniques. Very simple. Just give it a solid volume, give it a color, and then you get these kinds of things.

So in this case, it's not a solid. It's just a surface. But this is already defining how our roof will look like. The roof is very simple. Two lines that are a lot of-- three lines at least, that are lofted together to get a curved surface. There is also a bottom surface. This one. It's our projection surface at least. So this one here. This distance between that point and that point is our roof start depths. And this one is the roof and depths. OK. So these two will vary along this whole optimization until we find the ideal solution. So these are actually defining how much of deformation we will have.

All right. The truss. How is the truss then defined? Well, actually in here, we start with generating quartz panels on there. So you see those rectangles? These are the quartz panels. So it's an equal distribution along this curved surface. So these will actually define the whole structure length. They're also defined by the truss segments indicator in the inputs. So the moment they start increasing that, we will get like more lines along the length of that platform.

And then by using some sorting techniques and projection techniques-- so projecting the lines to the bottom surface-- we will get the bottom part of the spacial truss. And then the next part is just connecting all these points with diagonals. And that's where you get this structure then. Oh, sorry these are the supports. This one. So these black lines, this is actually the structure defined by this full box in here. OK.

Next, part to do in here in our initialization thing is defining which points are actually the supports. So we also using sorting techniques again. Sorting techniques, for instance, by taking all the points that are closest to the original X points, for instance. These are the guys that are supporting this whole structure. Again, use some visualization just for your own reference to see what are the supports, otherwise you need to select all these nodes every time, and then see which points are actually used.

OK. So first step, done. We have our geometry. The next step is actually creating a specific goal, specific requirements for the analysis. So that's where DynaShape comes in, as I told. So our first one is the anchor goal. The anchor goal is actually a specific definition of your points that are fixing your structure to the world. So these are actually the supports. The bigger this value, the stronger these supports will be. But none of the supports in real life-- anchors in real life are never completely fixed. They're always having a little bit of movement possible so they can deform a little bit. So we have some elasticity. The thing is, in here, you have to tweak it a little bit until you find the best solution, at least until you have a reasonable deformation according to your own experience. So this value you have in here is not the best value for every structure. For this one, it's working perfect.

The second thing is the structure stiffness. The structure stiffness is defined by the length goal. And the length goal is-- I'm hoping I'm telling this right, Long. But the length goal is actually defining that your elements, the lines of that truss, can not extend or shorten during or deformation. So you're actually using the elasticity modulus of your structure in here. Again, if you fill in a value which is really high, then it will be a very strong structure, and it will possibly not even deform. If you fill in 0 or 1, then you will have an infinite big deformation from that structure. So we need to find again a good compromise to get a figure that is quite logical.

The third part that we need to include in here are the loads. So the loads for this structure, they are actually defined very simple. So I did a generalization of this whole thing by taking the panels, the surface of the panels, calculate them in some kind of way, and then add a factor that is defining the weight of each of the panels. Then also, take the total structure, all these elements or all the beam elements that are generated in here, take their total length, add a factor to it, and then you have like the total weight divided across all these points at the top of the surface. So it's a very simplified method of loading. You could go more into depth and really write a big part of that script and making sure that every point has a specific load like it would be in real life, but that's not necessary because it's a conceptual evaluation that we are going to do in here.

So this is the part where the analysis starts. Very important-- when we are going to use this script with Refinery, is that you need to use a different package than the one that is available on the forums. So the one that is available on the installation link that I've provided in the handout, it's the package that can be used the moment you just use Dynamo and DynaShape in other specific problem, except for Refinery. The reason for that is because DynaShape needs to run in a silent mode in here. So I provided, also, a link where you can download the specific package of DynaShape to use with Refinery. So read the handout very carefully, and then you will get all the information that you need to use it yourself. OK?

In the meantime, the analysis has been performed, and we see the results in the background. So let's open up. There we have-- this is like, as I told you, it's more like the conceptual deformation of that structure. So this is not like the real distance it will deform. It will not deform 2 meters, this structure. But it's giving you an idea. OK. Now, before we continue, I will just highlight all of these elements. So that we have a good few in here. So this is the analysis results. And again, in here, if you use this If formula, for instance, we can go into the tube results so that you have a more solid representation of this structure. Same here for the supports. And then another one for the roof. There we go. So that's our initial structure. So you know the drill. If you go into the inputs, and if you change, for instance, the platform size to 15 meters of width and 20 meters of length-- there we go. Updates immediately, of course. And then we also get a-- oh, I'm sorry-- the result at the end. That's where the evaluation starts.

So the evaluation of this whole structure-- well, it's going to do, as I told you, three parts-- deformation, structure weight, and also the platform area. Platform area is already obvious. So we just changed it. The deformation of it is actually taking the original structure-- this one-- and also the deformed structure-- this one-- and it calculates the points. So in here, it's using the curve start point. And the curve start point of the original structure. We could also use an alternative method. We could take the node positions in here. So the node positions is actually the points of the deformed structure. So if I show this one-- and let's put this one in a preview method. There we go. If we zoom in a little bit, you see all of these blue dots-- or these black dots, at least-- these are the deformed node positions. And these are the original node positions.

So if I take the deformed ones connected to this point in here-- so then we don't need the lines instead-- calculate the distance, and we get a deformation score, 21.93. Is that the distance, the real distance? No. It's just a ratio. It's just giving an indication. Because the moment I start changing the values of the anchor and the length goals and I use, for instance, a different value, one which is really big, then the deformation score will change as well with it. But rationally, compared with all the other solutions, it will be exactly the same. So this is just a ratio. And the idea behind optimization is that this score of deformation should be as minimal as possible. So the best solution is actually a deformation score of 0. But that's impossible in here. Everything will deform and a cantilevered setup.

The material score in here is defined by just taking the length of every curve. So every element that is designed in there has a specific length. Take that's curve length, put some magic this on it with math.sum, and then you have your material score. And the platform area is just like, as I told you, platform width multiplied by platform length, and that's your area. So these three guys in here are used for optimization purposes.

Now, before we start optimization, we need to define some things. We need to tell Refinery what are actually the inputs and what are the outputs. So seems real as, actually, with Fractal, if any of you has used Fractal in the past. You need to go in here and say, for instance, for the platform width I want to use this one as an input. So right-click on it and say this one as an input. If we click on this one, you will see it's not an input because it's a fixed value. I'm not going to change the shape of that roof. The roof shape is already defined by the architect. It's now up to me to define which structure we will need to support this roof.

OK. At the end, the results. These are the ones that needs to be optimized. So these ones are the outputs. All three of them. OK? So that's how we started it. And let's just switch this one again to the tube volumes so that way our thumbnails will look a little bit better. Switch this one off. And then a view like this. Yeah, that should do it. OK.

Let's start in here. Let's go to View. And in View, we have this one, Refinery. After you have installed Refinery, at least. So it's what we call a View extension. It's a specific plugin that is installed on top of Dynamo. Now, the screen looks empty at this moment. Well, we need to create a new study first. And a new study gives us the possibility to change the generation method. So this is the point where you can choose whether you want to optimize, whether you want to randomize-- so that's brute-force techniques, or whether you just want to use some cross products or like this method. So a cross product means that it will take every possible option, for instance, for every possible value of the platform width and the platform length. So that's actually what the cross product is doing. It means, also, that you will get all the solutions, including the solutions that are not valid. So this is more like for architectural purposes just to have multiple ideas.

So in case, I want to use the optimized method. And the optimized method will find a solution and will try to convert to the best one by using these genetic algorithms. The inputs in here are the truss start depths, the truss end depths, the truss segments, the platform width, and the platform length. So lots of inputs actually that need to change. So if I would do a cross product of these five inputs, we might have thousands of design options, and maybe only 20 are really valid ones. OK? So we are not going to play with these inputs. They are fine already. And then the outputs, these are the ones that need to be evaluated. So in Refinery, we'll evolve the inputs in a specific way until we have a minimized material score, a minimize deformation score, and a maximized platform area. So we have a multi-objective optimization in here, and also with multiple ways of looking at these objectives. So the first would need to be minimized, and the other one needs to be maximized. So that's completely inverse optimization actually in here. OK?

The settings. Settings in here, they are actually telling how many elements we should use when we started the optimization generations. So the initial-- this is what we call initial population. I will explain a little bit more about all of this in the second workflow, where we are going to use genetic algorithms inside of Dynamo. OK? But the thing is in here, it needs to be a multiple of 4. So I would-- in this case, I'm not going to run the full Refinery study in here because it takes some time, but let's say that we are going to start with-- we can start with 4. And we need to have four generations. So it will start with four initial design options, and it will make four generations of them. So it will evaluate those four options, see that, for instance, the input values need to change a little bit, so then it's where we are going to get four new populations in the second generation, the third generation, and then the fourth. Meaning that actually Dynamo will be running 16 times in here to get to that specific result. And then we start generating.

So in a few seconds, you will see it will write the results during the progress of this analysis, because this analysis is actually in here. Here, you can see what it's calculating. You will also see in that black diagram that the results are calculated and what the values are used for it. So this is just to show you that it's really running, that it's really a local service. It's called Refinery Server, a local service that performs all of these calculations inside of Dynamo. So don't close it. And there you go. So on the fly, while we are watching the results already, it's adding your results until it finds the optimal one. So imagine if you set your population list to, for instance, 60 and 10 generations. That's what we actually did for this type of structure. Then we will have multiple solutions and a scattered plot diagram, which is possibly showing you that optimal parietal front one.

So let's go to the real solution in there. So I need to open another version. So this is the version where all the Refinery optimization has already been performed previously. Let's add this one to tube volumes. There we go. So these are the original results.

So what you can do it in Refinery then is we can start to, for instance, change the way how this scattered plot diagram is organized. So for instance, the y-axis should be-- the platform area, for instance, this one will be the material score or the deformation score, at least. That's what we want. The size of the dots should be representative for materials, and then this one could be, for instance, the truss segments. So this way, you get an overview of what are actually the best solutions in here. The best solution is, of course, this one. But this one in here, it might probably look something like this. And besides that, I also want to have the maximum platform area. Not like minimal platform area. So let's take this one then. But this one will have a deformation ratio bigger than 40, or greater than 40. We don't want to have that. So it should be something in here in the middle.

So a next step, what you could do is, for instance, perform multiple optimizations in here, or just do randomization with parameters that are like this. So that's another possibility you could do in here to refine your selection. Or you could just say, no, I'm happy with this one. Or you could go into a tabular view and then have a look in here, oh, this one has 543. Yeah, you can almost see it at the top. Yeah, you can see it there completely above that blue dot in here. This area, this is actually represented by this line in the table. So this is probably the best solution we can find at the moment. OK?

So how does it look like in Dynamo then? How does our structure look like? Let's go in here. Very simple. We just click on this. Click and just wait a few seconds, and Dynamo will update it. There we go. So that's the solution that we want to have. Instead of just recording what is actually the real platform with according to optimization and so on, no, it's synchronizing from Refinery straight into your Dynamo environment. Make sense to you? Yeah? People among you that already were common with the use of Fractal liked this sorting of elements or solutions with the parallel coordinates, so we still have this in Refinery. So again, in here, we can go to the solution, for instance, with the maximum platform area. And we can select it from here to change your specific thing in Dynamo. But as we see in here, the deformation score is also too big, so it needs to be something that goes down here, and then goes up again. So that's the line that we need to follow to find our best solution.

OK. So far so good. So that was the first optimization technique. The easiest one, actually. Easy, why? Because you just have to set up your Dynamo script, and then run it through Refinery. Just make sure you have the right evaluation scores for it. Now, it's not always working like this, because sometimes you need other software to perform your optimization. And that's actually what we are going to do in the second part.

The second workflow is about truss shapes. And a truss shape in here is defined by this problem. So traditionally, if we calculate a two-dimensional truss, you might use a rectangular truss. Now, probably the best solution for this is a truss which has a little bit of a deformed shape below. Maybe like an arc. It depends a little bit on the loading system that you're applying on your truss. To find this best solution manually, it's really hard work. You need to change the shape of that bottom rule constantly then, and then compare your results.

So what you are going to do in here is we are going to use a brute-force technique to define the best shape. And the best shape, how is it evaluated? Well, I need to have a shape which has a minimal stress score. A minimal stress score, and that way the structure is not over-designed, but it cannot also-- we also need to avoid over stressing of that structure. So something in the middle. Also the weight of the structure needs to be minimal-- again, so cost effective. And again, in this case, deformation is important. So the bar displacement needs to be as minimal as possible.

Now, what are the drivers for that optimization? Well, we have those Z values. Z1 until Z5. These five values will be actually driven by the optimization.

And here, we are going to use multiple packages. The most important one in here is the structure analysis for Dynamo package. It's an older package. We used it already in a class in here. I think three years ago I presented that, about structural optimization with robots. So it's still the same package. It's still the same handout that you can use to understand how the package works. And also, we are going to use Optimo for the optimization. So it's a genetic optimization, but then with Dynamo and inside of Dynamo. So no Refinery is used in here. Very simple, because Refinery and Robot, they don't like each other. So they don't collaborate with each other. And the reason for that is Refinery opens up, for instance, I think four or five simultaneously running sessions of Dynamo. And Robot cannot handle that. Robot is opening only one session at a time. So that's why Refinery is not used in here. So Optimo is used in there.

Another package is Mandrill. And with Mandrill from Archi-Lab, so from [? Konrad ?] [? Sobel, ?] we are going to evaluate our results into a scattered plot diagram. So with the optimiza-- sorry, with the structure analysis package for Dynamo, that's where we are going to connect the geometry from Dynamo to Robot. So Robot will take that geometry, and within Dynamo, we are going to evaluate what are the supports, what are the bar end releases. And which type of loads are we going to apply to that structure.

Now, three methods are used in here. So three optimization methods. The first optimization method is more design exploration. And with the design exploration, we are going to set up a single data-- a single model, at least-- analyze the model, evaluate it, and then use the results to see what kind of stress we have in that specific structure, what kind of structure weight we have. So it's more like manual operation of it. It's a very important step before you get into the real optimization, because you need to know if your script is working in a manual method.

The second one. The second method is brute-force. Now, with brute-force we are going to generate multiple IDs and evaluate them. But multiple IDs within a range of variables. So for instance, calculate everything for Z1 value between 0.5 and 1.5 meter, and take 100 steps for it. And it will do that specific cross product calculation of it. So you will have thousands of design options in there.

And the third one is genetic algorithm optimization. So this one will be the shortest version, because it will only consider the values that are relevant for my optimization.

OK. So the first, the design exploration. This one is important for the other two methods as well, because this one is going to define how our analysis should run in the optimization with brute-force or genetic algorithms. Now, at least you need to have your truss shape. So you need to start defining the points and the lines that are generating your truss.

The second step is to configure your analysis model. So we take that full structure, we get it into Robot, pull on some loads, releases, and so on. Then perform the analysis within Robot. All of that is driven by Dynamo, so you don't need to go into Robot and click Calculate. No, Dynamo will perform the analysis, and then, at the end, we are going to read the results from it and evaluate those results.

So how do we define? Well, again, with those five typical values for Z-- Z1 until Z5-- they will be the specific number sliders, at least, that will pull that truss up or down. Second step is the truss skeleton. So we need to create a skeleton from the truss and then maybe, optionally, like I told you in the previous example, you're going to visualize them by adding some solids and some colors so that you can at least see how the structure behaves and with all the specific parts within that.

Second part in the workflow is where we define Robot. So first you need to define your analytical bars. You need to define what boundary conditions. So where are the supports and where are the bar end releases. Second step is assign the sections, because in here, we are going to use the real material. So you need to have a set of sections. In this case, we are going to use the circular hollow sections. For instance, are we going to take a diameter of 90 millimeter or 114 millimeter, 170 millimeter, and so on and so on-- so this one is also important. It can be even used as a driver for the optimization. So not only the Z values, but also which kind of section are we going to use. So that's actually broadening our optimization problem in this way.

And then the third step is where are we going to apply the loads? When we perform the analysis, we need to collect all of the information inside of Dynamo. So we need to collect the analytical model, you need to collect the supports, and you need to collect the loads. So the ones that you can see in here. All of this information will then be used by Robot. It will be consumed by Robot. And it will perform the analysis on it, and it will return as the results of those stresses, deformation, and the weight of that structure.

So in this case, I want to use the actual stress. I also want to get to the structure weight based by taking the reaction forces on my supports and the load case self weight, and this placement is also calculated in here just by taking the values for all of the loads together. But the stresses in here, if you say, I want to have a minimal stress score, a structure with, for instance, a stress equal to 1 Newton per square millimeter will be the most huge structure ever seen. You will have like cubes of maybe 1 meter to have it done in this way. So that's what we call over-designing, of course. So we need to define some limits and that actual stress objective. Because we don't want to have too heavy structures. It needs to be something reasonable.