Dynamo Studio Model Information Analysis for Construction Builders

ENRIQUE GALICIA: My name is Enrique Galicia and it's about Dynamo Studio Modeling information analysis for construction builders. So basically I'm going to present myself. I'm an architect and a programmer. How many other architects here? Excellent. At least there are more than the other classes, because the other ones, they were all engineers, so they were like. So I'm an architect and a programmer.

I have been working with Revit for more than eight years, and I'm a BIM consultant on Mexico and Saudi Arabia. So I jump between cities once in a while. Just a little. Then I have participated in more than 70 projects regarding hospitals, water damps, urban roads, offices, housing, commercial, touristic complexes, and-- well several of those.

I am author of some 22 Revit Add-ins, so I started working with the Revit API since 2009. So it's really useful to have the background, because when you're trying to jump things in between, it will help you know how Revit works and how you can get together. And I have more than 84 Dynamo Workflows for analysis, for geometry, modeling, and a lot of other things like that.

So I have over 22 courses on Udemy, some of them in English, mostly the last ones from October to this date. And I have other ones in Spanish. I'm focusing on functionality for BIM. So I'm also a professor at Tecnologico de Monterrey in Mexico City, and I have been for more than five years.

Then my contact. Any courses, training, implementation, research, development related to BIM or not, you can contact me. Just feel free to ask a question, pop a question, or if you need something around the topics, have some concerns, just send me. We can check what can be done and maybe I can point you. It will be really good. You can follow on PracticalBIM. Actually, for today's lesson, we're on Periscope. So I'm Periscoping it so that they can see it in Mexico-- my students and everybody else. Also in Saudi Arabia, they are looking at it.

So my LinkedIn profile is there, so you can just send me a message and I'm more than happy. And my profile, it's already there, so at the end, just I have some business cards so you can have it and you can take it. Or as well, if you don't know the presentation or the handout, it's everywhere. In the other class, they told me, didn't you put your bank account and your numbers so we can pick something? I'm like, no, that's all right.

My email address, my WhatsApp as well. If I'm changing phones, maybe with that, you can search me or send me a message. I'm more than happy. And I have a lecture yesterday that was "Infraworks, AutoCAD Civil 3D and Revit 2008." I didn't jump too much on Dynamo on that one because I know it was a lot of information and I'm just going to keep it still.

I have uploaded, again, all the materials for today's lecture are updated. They have all the files, all the references, all the practice exercises as well. Within, I didn't upload the videos because they were too heavy, but there's a link on the presentation settings so you can download it, have the videos, and review it once and another one. They won't have audio, but still, you can check it. Or if you're following, you will have this Periscope presentation and you can watch them together as many times as you need it.

So the outline for today, we're going to learn from scratch-- how many of you are familiar with Dynamo? OK, that's good. Excellent. So I'm just going to go jump on that really quickly and jump through the things that may be a little complicated. So we're going to learn it for sorting and grouping elements that are different things that make it difficult, because you may have a lot of information and lists and you want to match them together so you can [INAUDIBLE] back the files.

We will learn how to visualize data and transform schedules, how to rename or change settings in any parameter you want it. It depends if it's only read-only can be, but we can set up a new shared parameter and then add information to that. And set some overview behaviors for a construction model.

So there are some other courses I have that it's about geometry having complex figures, using it for class detection, for general modeling, for InfraWorks, and making roads and things with those, Analyses Revit, and for these simulations with [INAUDIBLE] 3D Max, and making elements by elements. But that will work for scheduling software.

So this is beginner but we will get it since everybody have heard of it. I don't know how much you have jumped into it, but still, we can see it. I'm going to make some pauses for questions-- for quick questions in the [INAUDIBLE] so we can fix it. OK. Yeah. So Dynamo is now part of Revit 2018. They have it already when you install it. It's Dynamo with Dynamo Player. So that will really help you to start making movement between what it's-- to experiment and to play around. But also, if you use it with Dynamo Player, if you have already a workflow set, you can just save the same file, open it, and press play, and it will repeat or use it with different things. So we will be focusing on analyses for Dynamo and Revit.

Just the main idea is learn to review, extract, and insert information. We connect Excel files, set overrides to analyses, and use it for multiple sorting. So basic concepts. I'm just going to start from scratch so everybody is familiar with the concepts and that can help it. So Dynamo is located on Manage Tab. It's version 1.3.1.

So you go-- just really quickly, you go in Manage. You have it there on Dynamo with the Dynamo player around, and then from that, it will open. You just need to check the version because if it's not up to date and the packages are not up to date, you may find some crashes where you're trying to test things. So keep everything as up to date as possible and that will help you-- well that will avoid having crashes while you're trying to work.

So you have these areas that it's the file, the recent ones, some samples, and some references. And then we get here into the main performance place. We have this space that we have the graphics for being three-dimensional or being with other elements. We have the toolbar here. There's going to be-- I'm a little fighting with myself-- OK.

So then we have all the functions that we have. It may seem a lot but it's because there are too many and each time you download a package or get some more information, it keeps getting crowded. So really useful to use on the top-- your search bar-- or with the right click on the screen as well. You can search for functions so you can call it back. OK, we have seen that.

So the basic behavior we have is we have a node. Those nodes will be connected from one side to the other one. We have a running set that needs to be manual or automatic. It depends on how much information we're handling because we will not be taking information from a big model. I recommended you to use it manual, because if you save it somehow and it has a problem, when it opens again, it will try to run it and you may have lost your information. And for the Notes part, it's really easy just to pull up over it. It may tell you what you need. I'll just [INAUDIBLE] a little. Yeah.

It will tell you what it needs to input and output and the information is showing or is getting from that node. In the back part, will have the grid surface where we [INAUDIBLE] our geometries in place. Everything that is being generated can be just in Dynamo. If it's in Dynamo, doesn't mean it's actually on Revit. There may be things that you may look at, but they may need to have some other type of figure or shape.

You will set-- we have the [INAUDIBLE] staff, important. The environment of [? move, ?] graph an object, to change between them, because if you are looking within the graph, you may look at the back part and you need to change so you can find out how it works. Then you have your execution settings, the manual and automatic, and how to connect nodes.

So then we can go for the inputs. As a starting point for information, we have three basic ones-- and it's number, string, and Boolean. They were the basic level of information, we're going to be using it, because we can set it up for here numbers for length, or for whatever you need. We're using it as just number.

If we use the string nodes, we can get there just text with plain characters. And within the Boolean, it's just true or false settings.

We might use code blocks because code blocks will make everything much more easier-- just double click, and write whatever you want it. And in that case, it will make it much more faster to use.

So the inputs, you can search them for number, for string, or for other element.

I said three of them. Or you can look at it on the core settings for input. As you can see, you are clicking, you get the nodes, and then you're going to start getting some information.

You can also use numbers [? lighters, ?] or in the [? grid ?] as [? lighters, ?] but just in case, we are changing things.

So each time you want to see what's happening in a node, you have the output. And if it doesn't show when you're hovering it, you can use the watch-- the watch node will help you get from the output what it's looking at. Otherwise, you can have it from the lower menu, and you can press, or you can have the lists being completely displayed.

So for example, in that case, we're getting from the string, the hello with the quotes. And on the Boolean, we get whatever the value is it.

So in case we're using the code blocks, we can just write the number as it is. It will pick that it's a number, unless it's a decimal number and you need to place a serial at the beginning. If it's a string, you need to place it with the quotes. And if it's a true or false, it's good enough if it's without uppercases.

So it's the same result, but with just one simple node. And as you can see here, we have these many [INAUDIBLE] that opens. We don't need to open the watch function, we can just do it from there. That will be really helpful, because when we're deploying and we're getting the function [? beginning ?] complicated, we'll need this to check, where was the problem, what is giving me data, what is having some issues, and how we leverage those levels.

So then, first thing we need to get is understand lists and sub-lists. So the easy one, and just starting from scratch, we have the sequence on the range. Those two will build really quickly from some data a list. So for example, I'm using a code block, getting there from 0.

Having eight numbers, with a step of two-- so it will do from 0, 2, 4, until it gets on to having eight numbers. And then we have a list-- we'll have all the elements that we have created.

With the ranges similar, the thing is that you will have a start value, and end value, and a step. So you need to set how much is going to be the distance between each of those values.

So we see it, and we have those two lists, one list and the other one. The complicated thing comes when we're trying to get lists within lists, and then we want to make operations between one element and the other one. Because as soon as we pick up elements from the Revit model, they will start having some conflicts.

So let's just see how you write this sequence in code block. You will use the hash, and you have the starting point, the number of points, and the number of elements you want to have, and the step you want to use. So we have the same list, but with less writing, less connections. You will have all the information.

And as well, you can do it with a range. The difference with the range is that if you're having with a code block, you will have your beginning, your end, and the number of characters is not a step. So you're not doing it each one, you will have it divide me from 0 to 7 7 times. So you will have these decimal settings, or you will need to adapt.

So far so good? OK, just trying to start really, really slow so everybody can pick.

Next-- we have seen that one, we have seen that one. So now we get into sub-lists. What will happen now is that that list, those set of elements, need to be stacked over other one. So we have on this top bar, each time we open it, we have three signs. That is-- I'm just going to pose it a little.

We were on this one, yes. Because that's important. Just a moment. What's happened? Ah, yes, because it's the-- so just-- yeah, that's it.

We have these signs. It's really important, because each time you have a plus, that means it's a function for creation. If you get it for a lighting, it's an action that is going to be deployed over the data, or the values you are performing. And if you have a question mark, it's going to be a query.

So you're going to pull for that element things, or information that you want to use it later on. So I'm just going to continue with that.

We have the first function is list create-- we want to have this one and this one attached to one single list. So we will have them as sub-lists from the main list. We look like that, and we have the values from the first one and the values from the second one.

So then, we need two functions-- the first one is flatten and transpose. If we want to flatten all those list elements, we have the two of them, and we want them to be just one single one, we need to use a flatten. That function from lists goes from leveling, so we can set up the list to lower down one level, or lower down two levels, depending on how many levels we have on the list.

Or we also have a flatten that it's built-in function, only grabs everything to the global setting. The list transpose, on the other hand, will mix the values from those two lists. So creating the number of elements, multiplied by their setting.

So for example, we have here eight elements-- [? we have ?] eight elements-- and eight on the other one. We will have now eight lists of two elements. So they are crossing from one side to the other one. It will be really useful when we're exporting to Excel, because we want to mix between rows and columns to have different types of settings.

This is going to go for lacing. Lacing is a function that almost every node has. And what it will do is multiply elements with a relationship between them. So we have seven elements in the first list-- eight elements on the first list, and two elements on the second one. So we're multiplying them.

And we have a common lacing that it's a shortest lacing. We have only two elements, because we only have two here.

If we change the lacing to become a longest-- just going to wait a little-- change lacing to be longest, what will happen is that the first two elements are responding, and the other ones are getting multiplied but by the last element. So it's multiplying it by 2 for the last ones, and the first one is with the first one.

If we do a cross-product, it's going to multiply each of these elements with these other two.

So far so good? Questions? OK, excellent.

Just the same result. On a function from 1.3.1 of Dynamo is that now we have leveling. That is these arrows you see on each node. It's a leveling arrow. So we can start making the query, or making the product, not by the basic level we have, but we can change it instead of being this level three, level two, we can set it to level one. Or have different results being playing with those.

So for example, in that case, we're changing the level, turning on. And we are multiplying these numbers by the first one, or we can be doing it with different types of leveling. So it may be the case that you don't want to flatten the complete list to have one by one multiplication, so you will need to take care of the leveling yourself.

And the last part of this starting from scratch is this strings. Because we're going to be handling names of levels, names of elements, we want to change family names or other things, we can [? write ?] a string, and a string by itself will work as a list. We can split it up. We can count the number of characters it has, we can substring it to change or to get some information so we can concatenate elements, so we can draw that value and write it on another spot.

So that says it's 17 characters. Then we're getting the split. The split in this case is asking for a separator-- that, in this case, can be white space, black space. The result will be just each value by itself.

Then the concat with strings can help, as well as the create lists. We can place a plus, and it will have a lot of strings getting together.

For example, I'm there, making a concat of the string within the number 17. But as well, if we have a list, and we're having a concat, what it will do is put everything together. So it's having all the values being attached by themselves.

The last one is sub-string. Sub-string will get the string, and then you can have a start index, left index, linked index, so that can give you just part of the basic string. So you can take data from wherever you're getting it in the model, and then pull it and write it on another value.

So those will be the basic functions from the strings. And now we can get into our topic we have already that starting point. Questions? [INAUDIBLE] or comments? OK, then.

The first one, I'm just going to go through some workflows and protocols for getting things. We need to get now the Revit selections. So we have this model sample. That model sample, we want to take things for it.

So we open Dynamo, and we have our first node that it's select all elements. So we go up to the end. We don't know any node-- we can go just for selection review. And we will set those ones that are all elements at level or elements of category, elements of family type, or elements of type.

And what I will do is, you just need to set which category you want to pull, which family type, or element type. And they will pull everything from the model you have, so you are picking actually all of the information.

So as you can imagine, it has the starting point and the end point, and it will tell you what it needs. Because those are defined by the Revit API, you need to get the proper settings of a combo box. So it will tell you, this type of category, this type of level, family type, or element type.

So for connecting just draft from one node to the other one, and just need to select what you want to see. So for example, for that, once you pick it-- because we're in automatic-- it will graph all the elements that are on level two. For categories, as well, you will have all the basic categories, but also the ones that are from the Revit API. So there are elements that are not actually an object by itself, but I may pick from the tax or other things you're writing.

Family types, as well, for all the family you have in the project. So that's picking all-- the framings, as you can see, is not taking too much time. It's just running on the go. So that would be really good if you're trying to test it. But if you have already a big workflow, I recommend you to have it on manual.

So we're go for that one.

And then we have manual methods of selection. We have, for select model element, or select moderate elements, the difference is that we can pick one or several. But we need to do it through a window selection-- we cannot do it by a list coming. So we cannot pick individual, we need to select them. Then drag it from a window, and we will have all those elements being picked.

As we can see, it drags the ID of each element. So if we close this one and open it, it will look for the same element. If it's different, it won't use it.

And if we want to get several elements, we just need to be careful that they have the same type of parameters or settings, because if they have different settings, they won't find it, or they won't be able to have the same information. So for example, I'm mixing the two categories elements from one level, and elements from the framings. It will give me two lists. So really, sub-lists of all those elements I have picked.

But if I want to get a parameter or something that one is on one side, and the other one, may have some conflicts. So I'm using a flatten to have the complete list. And what I want to check, as well, is that I don't have-- I have only unique elements. So we will use function, unique items. They will get picked.

And then, in this case, we haven't any that was on the same-- it was repeating. So it was right.

So, question, yeah?

AUDIENCE: What's the difference between flatten and the list flatten [INAUDIBLE]?

ENRIQUE GALICIA: Is the thing that flatten is a built-in, so what it will do is just go for a basic. If you have different sets of elements, it will go just for-- have all of them in one single row. And with list flatten, you can have a leveling setting. So you can go one level up, two levels, three levels. Excellent, yes?

AUDIENCE: [INAUDIBLE] if they have different [INAUDIBLE] IDs? [INAUDIBLE] they have two [INAUDIBLE] elements [INAUDIBLE]?

ENRIQUE GALICIA: Yeah, what it will do is just pick just one of those elements. If you have it twice in the list, it will get it just one time.

AUDIENCE: But when they have the unique element IDs, so they should have [INAUDIBLE] they are different. So they wouldn't really pick them out.

AUDIENCE: It's not spacial, [INAUDIBLE]. If you accidentally put two [INAUDIBLE], you [INAUDIBLE].

ENRIQUE GALICIA: Yeah, what it will do is that-- in this case, what it will do is if you have a unique element, they won't delete it because there are different elements. They have different IDs. What you need to run will be some intersect, or to check if they are on similar position or close to each other. And then you can delete it.

The other one, the only thing it will do is a filter for you to have just one in a single list. I hope I answered? Excellent.

So then, the first one we need to learn how to create shared parameters. Shared parameters function, it's not running. You have all that list is on the settings for the class. To create shared parameters, we have a function called parameter create shared parameter.

And the thing is that you need to have the recipe, the lists. That it goes from having a string of the parameter name, a string of the parameter group. Parameter type, and built-in parameters, so you can build it.

Stop a little. It was just too quickly.

So you have it-- parameter name string, group name string type and group. There are functions from Revit. And then if you want it to be an instance and a category list. So the good thing here is that instead of opening and having your shared parameters being pulled from a list, and then applied to an element, you can use those to being created that you can pull it from an Excel list, and then just create several parameters.

The last part, the categories one, is where you can pick-- I want it to be on the structural column, the structural framing, and that will help you. Instead of checking it each time for all the elements individually, you can just run the script, and have it. So for example, it's already run-- haven't been run, it doesn't have the parameter. We're looking for level location.

We don't have it there in [INAUDIBLE] parameters. It's just a part of them-- not doing magic, it's not there. And then what happens is, if we run it, so in manual, it's completed. Now we go back to our model. And we have it loaded, and we have it on the elements, the categories and those.

So you can filter those, have it as a standard, and then we're challenging these ones-- we need these ones for this workflow. Just load all of them, and we can pick it, drag information in or out.

So then we have the parameters get set. So we have already seen how to pick elements, where we see how to get a list create a flatten of those elements. And what we're going to do is now check the parameter information they have. We need to use a function that it's called, parameters. It's element dot parameters-- it's going to wait a little for myself to catch me.

It's called element parameters-- element parameters, yes. What it will do is it will pick for all the elements within a list within all the parameters it has. And with that, I can check how is the parameter called, so, I can call it with a get function. The get function will bring me all of those that have all those elements together. It's checking.

So for example, in this case, I have all parameter types for the list. So I can see I don't have any level, I don't have level. I have it as a reference level, because there is structural framing. So that actually-- with a reference level, I wanted to have that one on level location. Or I want to do that for framings, and that for columns, so they are sharing the same one and I can filter them together, or do it using it however I want it on a database.

And I get the function. It's element get parameter value by name. So the only thing missing there is to have the connection between the elements and the connection with a parameter. It's element, and that's the set one, as well. So I just connect the elements.

And we can check it's a string, what it's asking me. So I just want to have the reference level-- 32 connection. And then it will bring all the levels I have for each single element.

Then in this case, because the level is an element by itself, I need to have a function so I can call their name, it's level dot name. With that, it will bring me the strings.

With those strings. I can write it on my new level that I have already created, the third parameter one. The level location, so I just pick the parameter name, with the values, run it again. And now the reference level is as well set on the other ones.

So what you can do is, if you mix it with locations with settings, you can have it-- these ones belong to this area, or another sort of thing. So I'm just going to keep building functions to the other workflows. Questions? So far, no? OK.

So we have it there. They have already written on elements. I just-- OK.

So then next function we need to see the filter, viable mask. We want to get rid of some elements that have some information in a parameter. So we will use a filter, viable masks. For example, we want to get only the elements of that list, that have a level B26.8.

We just need to check that with double equals to see if they are true. They are the same. And with those, we can filter them. So it goes from elements from one to the other one.

Picks will give me a list of true and false. And then the function is list filter viable masks. So for those who are true, will be picked on the selected ones, and the other ones will be out.

Will give me two lists-- the first one will be with the positive result, and the other one with the ones that are not the same. So I'm just picking the same parameters. The element, get parameter, and the level name. Just change the elements I'm picking, but this time with the level location. But [? I have ?] already written on the model, and it will show me something that.

Instead of having all the elements, I only have 76. But they are the ones that are corresponding to that filter, viable mask.

Then we have these ones too, that are export Excel, import Excel. So I'm just going to grab these ones. They have the function-- it's Excel right to file, and the other one is Excel import from file. So you only need to follow the recipe, having a file path sheet name, the start row and column, start column, and the data you want to get.

So I'm just using, for example, in that case, a single list of parameters. It's from zero to 10, having 10 numbers. And the other one, zero to 10. Just dragging the file path as well. Giving a sheet name.

And what it will do is we'll start from zero zero, because it has it on the zero start column and start row, getting all those information. So just to look at different-- I've changed it to 10 to 50.

We'll open the values, and it's already opened Excel, with the information being set on those ones. So if we're picking it from the Revit elements and getting from a list in the parameters, you can play around from one way or another one. Then we have the other one that is import to Excel, and then we will go from the technical to much more fun stuff.

Speaking again, the file, getting from the file, getting the rows. And it will pick the data, as well, on lists. So we can change it, transpose it. So we have a list that is being pulled up. We can change it and we can write it on parameters, we can set it back, we can filter the elements we want, and then modify the information we're trying to look for.

Yep?

AUDIENCE: So you're saying [INAUDIBLE]?

ENRIQUE GALICIA: Yes, the only thing that you will need is you will need to have some key sorting or grouping that we will be looking. So you can pull them in however the condition fits. So for example, if you just create the parameters like that, you don't have a reference to pull it in. You will need to export as well as the first row, the ID of the elements.

So you [INAUDIBLE] I want to import these ones from the ID of the element. Otherwise you can do is to have two parameters that will be as a reference, for example, when the family name is like something and with the type name is something. And then when you put it in, it can pick all those elements and filters so they can get the information [INAUDIBLE]. Really good.

So just going to get through the first workflow, it's a color overrides. These ones will help really good because what it will set is how you set up visibility through parameters, you have the information, but it's really difficult to see what's happening. So I'm just going to pause it again. I'm just going to go back, go back.

So in this case I have already separated by groups. We have this selection one, we're checking all the structural framings getting picked. We have again, getting the values, we're trying to get the reference level with a parameter value by name. And we get the name, we have already seen this, too-- we're getting now mixing everything together.

So with that list, you're using this function that it's list grouped by key. That will set up all the elements, but also the key elements that we need to pick. So they will have mapping range. So for example, I want to know how many levels I have in the project, but each single one has a value.

So with that, we'll give me all the values I have and all the key values I'm checking with. So we have this function that is a mapping range. We're getting the count of number of levels we have, and then using here a range function.

This is going to-- we will check it in a minute. And then on the upper part, we have the mapping keys. What we want to find out here is which one will be the reference. So if we set, for example, a value that level one is equal to two, we want to know that how all the elements we get that two value, the final result.

So for that doing it, we need this function that it's called for mapping. We are actually comparing the keys unique we have, with the values we got from the reference level. So for example, an object is a level B2. We want to check it with all the unique keys, so that element will correspond to the unique key of zero of one or two.

So with that, we use this function, that it's called index of, and list map. We will see how it works, just in a minute. It's going to just have an overview, and then we will seek the result. Then it's getting from assigning colors-- it's going to-- come on. It's going to be-- yeah, this is better.

OK, now I have the control. So we have here the mapping-- oh, come on.

It's going, yeah. OK.

OK, just go with it, because if I change it. It's not responding quite. So just getting back again, here we have the list grouped by key. We get the values. We get the keys [? write ?] down, so having a mapping range of the number of elements on the level we have.

So it's creating a sequence from zero to one, using the number of values I'm using it. I'm just picking it from the number to become a sequence. On the upper part, we have the mapping keys. What it's doing is picking this one, and comparing it with the one that every level has using a map function.

And then with those two, mix it, we'll get the number it corresponds with the value it's having. So at the end, we'll give it a color range. And then the color range, we'll [INAUDIBLE] it over the graphics we have on the three-dimensional element.

So if we run it, it will look like this. So you're picking just from the information to give it a set of colors for all the elements. Yes?

AUDIENCE: [INAUDIBLE]

ENRIQUE GALICIA: Yep, so you want to have different colors, or--

AUDIENCE: [INAUDIBLE]

ENRIQUE GALICIA: Yeah, it was. No, what it was picking is just the general elements. For example, in that case, it's having the value of the levels. And then what it's doing is it's comparing it, so it knows a level two, level three, level one, it's going to give it the value from that range, from zero to one. And then it will pick it from different color.

That's reviewing the list map. It will give us an example-- instead of having it as a number, it's giving me an index where it's true. So it looks and says, OK, this one is from a level one, level two, level three, level four, give me an index and then I can use it from the list of colors. So it will have a different type of color for each one.

Just going to-- yes.

For example, we have there the mapping range. So what is happening is we have 12 numbers, we need to have a value from zero to one, so they can pick the different set of colors we have on that.

We have it, [? crank it out-- ?] so we have it-- the list of colors and the final result.

So let's go from some sorting. We have the Dynamo packages, it's available on the upper part of Dynamo. This example, we're going to do a sorting of elements. We have that element, for example, it's a framing, it has a mark of N. So all the elements are with the mark of N, I'm just setting clear that they don't have any value written, and we wanted to write them so they can have a unique mark number, starting from lower to up.

So we have a Revit selection of structural framings getting connected. Then we're using this function that is getting the element-- element get location. In the case of framings, we don't have a point for itself, because it's a framing. So it will have a line that says from a start point to end point, depending on how we're working on it.

So we're picking from this function, curve point at parameter, the 0.5, which will be the middle point of that line. And then what we you want to get is the point, the x, y, and z values, so we can sort it. It will start from z value, from the y value, and then from the x value-- y and z.

Then it's getting in a complete list with this one, list create. Is using a [? matt ?] round, because maybe the point is a little bit [INAUDIBLE], and it has different type of decimals, we want to show the list out so they can have the same result, and the sorting would make sense.

We have a general starting with a list sort, but that's just with one value. In this case, we're using three sub-lists that will be the elements, the [? EC ?] value, the J value, and the x value. And we're using this function that is sort lists of lists, that was practical [? beam ?] package.

So you get there on the packages. You may have it for the loaded-- there are really good recommendations for those. Just going to get it from downloads. And the most downloaded lunchbox [INAUDIBLE] club [? work. ?]

I'm also including on the references, the Dynamo primer, if you haven't seen it. The Dynamo [? primer ?] gives a really good set for how all the basic functions that are running, and also you can get all the ones from the packages.

Then just want to run it. The multiple sorting will get the elements we want, on the order we're looking for it. That's the practical beam.

Sorting-- sort lists by two levels, three levels, four levels. And also if you change it, you can just add it to the [INAUDIBLE] to get more than-- as many levels as needed. Then it's doing a sequence naming. What they will do is, once it counted, it will give it a number from one to whatever it has, and it will add an F to the value. So it will use it on the mark element, setting, and it will write all of those. So you have 3,040-- yes?

AUDIENCE: How does it find them, [INAUDIBLE]?

ENRIQUE GALICIA: No, it's going to do it from the z, y, and x value from the position. So it will pick it from the [? product ?] base point, because that will be your 0, 0. So from that, it will get the ones that are down, up, whatever you get it.

You can also sort it, if you set one element to be the [? pivot, ?] and then having the closest distance to those elements. So it can get all those values. So for example, in that case, now all the elements are being written on the mark value. It has F 3,032.

You can split it by levels. And if you use the filters or the settings, you can start splitting all those settings of code.

So I'm going to jump to the other one.

We have this one that, as well, is display analysis and surface. So we want to pick a face, and we want to make a comparison on where are the columns. So I'm just duplicating that view we already have on the three-dimensional one, and just going to use a single floor. Just isolate it.

And then we open the one that is from display colors-- we want to use the display interface. So we have the three-dimensional one, and see points on the surface, to see where are the columns or some other elements. We can use it for room spaces, from values, whatever the model has.

And as well as picking a face-- so that's where we are going to make this study, it's going to be on that floor space. Then we're getting the element selection that will be all the columns. I want to see on that floor, where is the zone of columns, and where are far from it-- which have value distance.

So we need to set our z points reference. So what you will not do is, from the surface I'm going to split it in 50 times on x and y. And from the columns, I want to get just the general location-- will be a point that gets projected to the surface. So it will show up on the floor those points, and we compare with the other ones to get the minimum distance.

Example, it's a vector, z. So it goes up or down, whatever it needs. Again, another flatten.

Then we have a geometric distance to [INAUDIBLE] compares, where is the column, where is the point I want to check? Which is the minimum I have, to see how far we are from that point. And then we're using a function that is point analysis display by viewpoints and values. So that's really helpful, if you want to check where is the area with less separate from the columns, separate from framings, some other spaces.

This is using the same settings, name, and unit type, length.

So now we move it. We have all the points there. But they haven't shown a value, so we need to use the display settings from the properties. We need to go for where we have the analysis display settings. Now we have one that is called distance to columns that we can change.

And with that, we can configure our display style. With that, we're setting up a grading of four types of colors, depending on a range, to be used as points. We can change values-- have some certain colors of distance, or properties parameters. Set it for OK, apply. I give something like this.

So we can see the areas where the columns are on the purple ones. And the ones that are in red are far having that distance. So it can give us an overview, and you can have a view for different types of elements. So it gives you an idea of how everything is working.