Using Dynamo for MEP Analytics

JASON BOEHNING: All right, you guys ready to get going? Everybody hear me all right? All right, good afternoon. Thank you guys for being here.

Welcome to Using Dynamo for MEP Analytics. So man, I can't believe it's already Thursday afternoon. This week is flying. Is anybody, is this your first day at U?

AUDIENCE: First day U.

JASON BOEHNING: First day U? OK, we get a few. Awesome. I hope you guys are having a good week and enjoying it. So hopefully we can have a little fun this afternoon and wrap this thing up and go hang out tonight.

But for those of you that I haven't had a chance to meet, my name is Jason Boehning. I'm now a BIM consultant for Read Thomas. And so that's a fairly new development in my career.

And let me see if we can get this thing going here. So here's the obligatory about me. But I really just want to put my contact info up there. And so follow me on Twitter, connect with me on LinkedIn, and let's keep this conversation going. And so I think that there's a lot of value in this conference. But then there's a lot of value in the conversations afterwards on social media and all the stuff that we keep going on, and so.

Anyways, in terms of introductions, just continuing that. So I have three lab assistants here. And so we have John Pierson. Carl Storms, and Marcello Sgambelluri there in the back. And so there are lab assistants here. If you get stuck along the way, raise your hand, they'll come by and help you out.

But they're also good friends of mine. And I'll share a quick story. So we met around 2012, 2013, and just coming to events like this. And so we were trying to learn Dynamo, trying to figure this thing out. Really didn't have any idea what we were doing. And we just start bouncing stuff off of each other. And just digging into it.

And so I say that because there's value in the information that you learn at these conferences, but there's also tremendous value in the connections that you make. And it's a connection, and then it turns into a friendship, and then the next thing you know, you're just, hey, Marcello, how do you do this. Hey, John, can you help me with this?

And then, so anyways, if you're here and you're like, man, I hadn't really met a lot of people but I've attended a lot of classes, take some time and meet some people and get to know someone. And connect with us on Twitter, and we'll just continue this conversation. So that's what this community is all about.

I love being in the AEC industry at this time. And because, as you guys know, we have some work to do to push this industry forward and to make it better. And so it's awesome to be a part of that.

So as far as today, what we're doing is we're going to use Dynamo to see what we can pull out of Revit. That's big picture what we're trying to do. And so as you guys know, Revit is a large database of information. And sometimes it's hard to get that information out.

And not only get it out, but put it in some type of form that we can understand and make sense of. So that's where we're going today. As far as a general overview, we're going to talk a little bit about analytics. And then I have three specific exercises for us.

We're going to be extracting space-type information. And then we're going to be tracking the loadable family types and instances that are placed in the model. And then we'll wrap up by looking at how we can report the number of duct types used.

And so one thing that I like to say when teaching a Dynamo class is don't focus on the specific examples. So you may be thinking, oh, I have no need for this. But focus on the methods that we use in our graphs and what we do in Dynamo to arrive at our outcome, because those methods that we use can be used for extracting and reporting all kinds of information.

And so I say that because don't get caught up on the specific example. Just focus on those methods that we use.

But with that said, if you're like, wow, this is not what I was expecting, feel free to go to another class. So I know that your time's valuable. And so if this is totally not what you're expecting, you can go find another class. Not going to hurt my feelings.

So let's dig into it. So what are analytics? Do you have to be a genius? Do you have to be a data scientist to be able to understand it and dig into it? No, no.

Sorry, quick side note. So I think Carl and John have both-- we've all used this GIF in our presentation in some form or fashion. But I think they stole it from me, though. They stole that.

So analytics is simply the systematic computational analysis of data or statistics. So to boil it down, it's keeping track of information. And so for those of you that work in Revit on a regular basis, you know that it's important to keep track of the information that we're putting in those models.

As we need to make our models more and more detailed, and they're getting bigger and bigger and compact of that data rich, information, we need to keep track of what we're putting in there. It's extremely important. So that's the direction we're heading.

So like I said, Rabbit Revit is a database of information. But sometimes it can just be a cluster of stuff. And so what we want to do is see what we can pull out and put in some nice charts and graphs to get in a human readable format, if you will. And so that's what we're going to be doing today. So we're going to dig into Dynamo and take a look at.

But so real quick, let me pause. I forgot to ask-- I'm going to ask some questions for you guys, and just by a show of hands-- how many of you would say I use Dynamo every day or even every week at work. A few of you. OK.

So let's go to the other end of the spectrum. How many of you are like, I have no idea what Dynamo is. Or I've opened it a few times, but I really don't have too much information. That's OK. OK, cool.

And then who says, I'm in the middle. I've dabbled with it, I've created a few scripts. OK, good. So we've got a nice mix in this class. And so I think that's good.

We'll cover some basics along the way for those of you that may not be too familiar. But we'll get up to speed and take a look at how we can use it for analytics.

But I want to give you some real-life examples of analytics, just to help us keep putting this in perspective. So I'm sure all of you have some type of mobile phone. We all have a cell phone, a cell phone plan.

And so you can log into your carrier, their website, and keep track of the data that you use. Because if you're limited by data, you've got to keep track of that.

Or you can log in and maybe access some type of chart, like this, where you can see which are your users are using the most data. Or who's sending the most text messages. That's an example of analytics that we use on a week-to-week, month-to-month basis.

What about our electricity bills? This is from my electricity provider from last year, tracking my electricity consumption to the average temperature in Houston, Texas.

So I can look at that chart and quickly see if there's a month that's out of whack, if my AC is broken or something and it's using more electricity. I can look at that quickly and tell if something's going on. But at this point, I know what to expect. I know what to look for.

Last one here. Anybody go to the ATM and you get to do something like this? Or maybe you're in the casino last night and hit a jackpot or something. We're in Vegas.

Not me. That's not that's not what I look. So I've got to keep track of my budget. I've got to keep track of where my money is going.

And so, once again, just another example of everyday analytics at a very simple form. And so that's where we're going today is some analytics from Revit just on a simple form that can make big changes in information. that we can use to make big decisions and keep track of what's going on.

Let's dig into it. So this is a lab obviously. So let's dig in to Revit and to Dynamo. And so you should have Revit open.

And so open up the MEP_Model.rvt. And so there's the Data Sets folder on your desktop. And the class ID is BES 320225. BES 320225.

So if you can navigate to that. And then you'll see, it also has the class name, Using Dynamo for MEP Analytics. And then open up MEP_Model.rvt.

AUDIENCE: Sorry. What was the number again?

JASON BOEHNING: It is BES 320225. So I think you've go to scroll down to the middle there. But this is the most difficult part, finding the corrective exercise files.

Let me read it one more time. So there's a Data Sets folder on the desktop, BES 320225. If you need help, raise your hand. A lab assistant can come by and help you.

So I'm going to jump over to Revit. So this is what the model looks like. So just a quick note on my data sets, I keep them very small, compact, so that we can run them. And it's not a lot of processing time. So they'll be short and simple.

But once you open up Revit and you get this model open, let's open up Dynamo. So if you go to the Manage ribbon, you can click Dynamo. And we'll get that open up.

And then in Dynamo, click Open. And we're going to start with the file called SpaceTypes_begin. SpaceTypes_begin. And that's just a blank file here.

Another note-- if you have the AU app, you can access the handout. And so I have step-by-step instructions on there and the notes that we're using. Obviously, we're going to follow along right here. But if you need to pull that up, you're more than welcome to do that too. That will help.

Anybody not have it open? We got a couple folks over here. I'm going to go ahead and dig into this. And we'll get you guys up to speed here.

So what we're going to do here, you guys keep Dynamo open. I'm going to switch over to Revit real quick. So right here on the Manage ribbon, flag span MEP settings and go to Building Space Type settings.

You can see, I have all the building type information and then all the space type information right here. And so I'm a huge proponent of using spaces. And so because if we can get our space information correct, and we can get all that populated, then we can use Dynamo to start to automate some MEP design. And I've taught some classes here before about that. You can look it up at AU online.

So to get our space information populated, we can start with space types and make sure all that's correct. But how many of you have ever gone in this dialog, and then you sit here like this and you're just going to each one and you're checking, looking at each line. Anybody? Anybody done that before?

Yeah, right? It can be a painful task. So what we're going to do is we're just going to take all that and put it into Excel. That way, we can just view it all right there. And because we all use Excel all the time.

Especially as MEP folks, we're constantly in Excel. So let's utilize that. So that's what we're going to do. We're going to take this information and write it to Excel.

So the first thing we need to do is we need to select all the space types. So let's start by doing that.

So here in Dynamo, over here on the left, there's what's called the Node Library. That's where we can access all of our nodes, for those of you that may not be as familiar. So let's expand Revit. And then expand Selection.

And there's a few ways we can select elements. We can select by family type. We can select by category. But we're going to do what's called selecting by element types. So element types is a way to select system families, but then a lot of background information that we're not normally used to working with in Revit, or interfacing with maybe.

So let's place this element types node. And then all elements of type. And so when you click a listing, it'll place it here in the canvas, from the Node Library to the canvas. And then if you just type H, it'll scroll down here to H. And we want HVAC load space type.

So as you can see here, there's the building types, and then here's the space types. And so we're going to select Space Types. And then we'll connect those up.

And down here in the left, you can see that we're running automatically. That's the default. And so when I hover over this all elements of type node, I can see that there are 125 items. And when I click this pin, it will lock this little fly out here.

And we can see all of the space types in the model. It's pretty clear. That all makes sense? You understand 454126? No, we don't know what that is.

So what we want to do is we want to use a couple of nodes here to start to break this down into some readable information that we're used to. And so we need the element.name and element.parameters nodes so we can start to dig into this.

So back in the Node Library, let's expand. So under Revit, we're going to expand Elements. And just in case I went too fast, you can click one of those subcategories to expand it or collapse it.

So under Elements, we're going to expand Element. And then if we scroll down, you'll see a name and parameters node. So let's click each of those. And we'll place the element.name and element.parameters node. And then we'll simply click the output and the input. And we'll get those connected up.

Now when I hover over, you can see all the stuff we just saw in Revit-- active storage, atrium, audience on, and so forth. And then when I hover over the element.parameters node, you can start to see some of that information.

But let me point something out to you. So when you work in Dynamo, you're typically going to be working with parameter names or parameter values. And then sometimes you'll see something like this, where you'll see the name and the value couple together in one item.

So that's good you can see that. But if we actually want to do something with it, we need to decouple that information. So that's what we're doing next.

Do you guys see that? You can see how you got parameter name and value in the same item there. Does that make sense? I'm assuming by being quiet you've got it.

So now we're going to start to dig into the parameters a little bit. And so back here in the Node Library, let's collapse Element. And then let's come down and expand Parameter.

And we're going to place three nodes here. So scroll toward the bottom there. And we're going to do name, value. And let me get these organized as we're placing them here. So name, value, and then storage type. I'll try to zoom in here so you can see.

So now we're going to connect this element.parameters to each of these nodes. And we're going to get a warning. That's OK.

So basically what we're doing here with the name and value is we're decoupling that information. So now you can see here, I have air changes per hour, area per person. So I basically extracted the parameter name. And then here is where I have my values. Now there's a warning there because, as you can see in this list, there's some null values.

And so it's looking for an actual object here. And so you can see that there's that warning. And so we can start to make a little sense of this with the storage type node here. And you can see that I have some that are double, some are element ID, some are string.

And when I expand the name, we can start to make a little bit more sense of this. You can see that things like air changes per hour and area per person are of the double storage type. Whereas things like category and design option are of the element ID type.

And some of this is a little bit beyond the scope of this class. We're not going to go too much into detail on that. But for the sake of this class, what we're going to do is we're going to filter out those double values. And so the ones that we can actually put some type of value in, like air changes per hour or something.

So what we're going to do next is filter out just that information. So I'm going to unpin those. And what we're going to do here is, first off, we need to-- so a good way to filter stuff is by a Boolean mask. And we'll get to that in just in a second.

But to be able to do that, you have to have some type of Boolean values to work with. And so what we're going to do is we're going to ask it if it contains that double parameter, if that storage type contains that double type.

So now what we're going to do is place the list.contains node. So if you right-click, this another way to place a node. You can right-click and there's a search bar. And so if you just type contains, that's that first node that pops up. And you can click it and we'll place it here in the canvas.

And then the next thing we're going to do is place a code block by double-clicking the canvas. And we're going to enter in double. But we need to do that inside double quotes.

So type quotation mark, "Double," with a capital D. And then we can click outside. And now we have a string value of double. And then we'll connect it up to list.contains.

And when I hover over this, you can see it says true. So now we need to dig in a little bit more. Let's see if we can walk through this. And so right now, let me back up and expand this storage type node here.

So you can see that there are 2,375 items in this overall list. That's a lot of stuff. And I'm saying, does that list contain double. Well, of course, it does. There's 2,000 options there.

But I'm not concerned about if the entire list contains it. I need to know if each individual parameter is of the double type. So now we need to start adjusting what's called the lacing, and even look at list at level.

So I'm going to try to walk you through my thought process because sometimes in Dynamo-- let me back up. Do you ever go to a class and they're just like, well, just try this and try this. And you're like, wait, but give me like a step-by-step way to how to get there.

So that's what I going to try to do. There's a lot of things that are a little bit of a trial and error. But let me try to walk you through the thought process here of trying to check every single item in that list.

So the first thing is I usually change the lacing. So I'm going to change the lacing to cross product. First, everybody understand what lacing is? Everybody have a good idea? Raise your hand.

Who doesn't know what lacing is? A few people. Who's just not raising your hand? You're just like, eh.

How are we doing on time? Can we do a little interaction here? Let's talk about lacing. Can I get five people over here. Just come on up.

How about one, two, three, four, five. You all come over here. And then one, two, three, you all come right here. Let's do a little interaction here. We'll look at what lacing is.

Stand up in a line right here, face each other. Everybody can see, right? So the lacing options are auto, which we don't really know what Dynamo is going to do. So auto, you just got to trust Dynamo.

Or there's shortest, longest, and cross product. So those are really what we need to focus on. So shortest, here's what it's going to do. So it's going to take-- we have two lists here. Just let me set this up just in case you don't understand.

We have one list with five items. We have another list with three items. So if I have something where I'm looking at two lists and I use the shortest lacing, what's going to happen is this gentleman is going to give this gentleman a high five. Go ahead, go ahead.

[HANDS SLAPPING]

You gentlemen are going to give each other a high five.

[HANDS SLAPPING]

And you guys are going to give each other a high five. And you guys are going to be left out.

[LAUGHING]

That's what shortest is. If we go with longest, let's do it again. High five, high five.

[HANDS SLAPPING]

High five.

[HANDS SLAPPING]

High five. And then you're going to give them a high five as well.

[HANDS SLAPPING]

Now it's going to be fun. Cross product, he's going to high five all of them. You got to run, you got to run. We've got to speed this up.

And then you're going to high five all of them. And then you're going to high five all of them. You all got it? That's lacing. Give them a round of applause.

[APPLAUSE]

So in this case, we're thinking, OK, we need to use cross-product lacing because that should get us everything we need. So let's try that.

So if we changed it to cross product, now we have a bunch of true values. But look here, there is 125 items. But over here, there's 2,375.

So I'm still like, hang on, this isn't right. And so let me walk you through the thought process again. Let's see if we can dig into this.

So if I say, let's look at lists again. Let's say each row here is a list. I'm looking to see, does each row contain, let's just say, a male, a man.

And so what I'm doing. I'm saying does it contain double. And so what it's doing right now is it's actually taking the entire row and saying, is there a male on this row. Yes. Is there a male in this row? Yes, yes.

That's why I only have 125 because it's only checking up one level. So I need to dig down one level to where I can check each individual item in the list. Does that make sense?

So now you guys completely understand lacing and lists at level. You all got it. So what we're going to do is we're going to change the list at level. So we can do that by clicking this little arrow here and clicking Use Levels.

So now we're at L2, which is basically the default, because nothing changed. And so what we're going to do is we're going to change that to L1. And now you can see that these numbers start to match. 2,375, 2,375.

But the problem here is that there are 18 items in this list. And then I go to another nested list, 18 items, 18 items. Whereas here, this is just all one list.

So my next thought is, let me maintain the list structure here. So I select this option, Keep List Structure. Now I'm where I need to be. 18 items in a nested list, 18 items in a nested list. Now I have something I can work with. Everybody there? Awesome.

For those of you that are still a little new, hopefully that makes a little more sense. Do you have a question?

AUDIENCE: [INAUDIBLE] code block?

JASON BOEHNING: The code block? Let's see.

AUDIENCE: It's underneath your [INAUDIBLE].

JASON BOEHNING: OK, I'm sorry. I was like, wait, which-- OK, sorry. OK, cool.

So we broke down lacing. We broke down list at level. Looked at keep list structure. Now we got to where we want to be.

One more thing I'll mention. You may be thinking, oh, we could actually do it like this. So sometimes you may take a little bit different approach and you may be able to arrive at the same thing. And that's OK. If you can get to the same end output, you're in good shape.

Now let's pick up the pace here and we'll start to roll through this. So now we've got list.contains. Now we have Boolean values that we can use to filter these out.

So back to that filter by Boolean mask, so right-click and type filter by. And we'll select Filter by Bool Mask. And we need two of these.

So when this node is highlighted in blue, I can simply do a Control-C and Control-V, and I can place two of these. And what I'm going to do is I'm going to take this list.contains node with all those Boolean values, and that's going to be my mask. That's going to control what comes in and out.

In other words, what's true and what's false. If it's true, it's going into the in output. If it's false. It's going into the out output.

And so what I want to filter is all my parameter names and all those parameter values. So I'm going to connect those to those lists inputs. And now I should have what I need here, which is just those parameters that are of the double storage type.

So now we really have the data that we need. Now we just need to format it in a way that we can shoot it to Excel. And so what we're going to do now is we're just basically going to do some list manipulation just to get it in an output that gets us to Excel.

So we'll go through it. And then I'll explain some of it to help you make a little more sense of it.

So right now we just have a bunch of lists here. And so the first thing we want to do is we want to pare down this list. And the reason is because I have several nested lists that just contain the parameter names.

But I don't need to export all of these to Excel. All I need is basically one of those nested lists.

So we're going to use the get item at index node. So right-click and type get item. And we're going to place get item at index. And then I'll double-click. And we'll place it on the code block. And let's type 0.

And then you can place a semicolon. Or if you click out, it'll place it for you. And then remember, we want those true values. And then we want at item 0. And you can really do any of them.

But now I have just the parameter names. And then down here, I have all the parameter values. Now you could probably do something and come up with a long way to just write multiple iterations to Excel. But we're going to combine everything together and send it to Excel all at once.

So we're going to use a bunch of the add item to front nodes. So if you right-click and type add item, you can see there's two nodes here-- add item to end and add item to front.

So we'll click Add Item to Front. And then we'll do a Control-C. And then we'll paste two more of those onto the canvas here.

And then if you can try to arrange them like maybe a triangle, if you will, facing to the right. Because basically what we want to do is we want to add all those parameter names to all of our parameter values.

But the first thing we want to do is we want to add the text space types to all those space types because it makes more sense, put a title in Excel. So let's double-click here above that get item at index node and type "space typed" inside double quotation marks here.

And so this is going to be the item that we're adding. Let me drag this up here. That's going to be my item. And then let me zoom out. Let me handle this carefully here to make sure that we can all see it.

So back over here to the element.name node back at the beginning, you can see active storage, active storage hospital. That's what we need to connect this all the way over here to that list input. So I apologize, I know it's probably small up here on the screen. I'm going to hold it up here for a minute so you can see.

So basically all we're doing is adding that in front just so that we can make more sense of it when we get to Excel. That's all we're doing there.

Next, let's go ahead and connect these up. And then I'll explain what we did here. So let's take our parameter names here and add that to the item input of this one, the list.add item to front node here at the bottom.

And then I want my in values, which is all those parameter values here, and add that to the list input. And then we're going to need to modify the list at level here. Let me keep this open so you can see.

So we're going to enable use levels. And then the first one needs to be at L2. And the second one needs to be at L3. Everybody doing good so far? Everybody tracking with me?

Now we're going to connect these in, all those space types. I'm going to add them to all the parameter names and parameter values. And I also need to use levels.

And the first one's going to be at L1. And the second one's going to be at L2. So let me zoom in here and you can see a little bit.

So as you're doing that, let me explain what we're doing. So when I export information to Excel, each nested list is going to populate to a row in Excel.

So what I want here is I want all my space types and then all the parameters, I want that written to Excel. And so that's why we're working to input it.

And it's really hard to explain. I'll try to zoom in here in a minute. And then this is something you're going to need to dig into at home a little bit afterwards. And it'll make a little bit more sense. But I'll do my best to explain it here.

So here I have space types, and then all those parameter names. That's what's going to go in that top row in Excel. And then here in the second nested list, I have active storage, which is the first space type. And then I have all the values for it. And that's going to go on the second row.

And in the same way. So I have the space type and then all of its parameter. Space type, all the parameters.

And so that's why we had to do some of this manipulation here with our list at level to get it into this format. Because at first, you'd end up with something like all the space types, and then all the parameter values, something like that.

And so when you start to input this in, you've got to know what format you want to get it in. And then you can start to just manipulate these until it gets into the format you want.

The next thing we're going to do is we're going to export this information to Excel. So let's scroll back up here. And we'll collapse Revit. And then expand Import/Export, Data. And then Export Excel.

So we have all the data. Now we just need to get some of this information on which file we want to export. So if you right-click and type file path, we'll place this file path node. And when you click Browse, hopefully it'll open up the Data Sets folder for you. And you can select space types, which is just a blank Excel file that I provided in the exercise files.

So select that and click Open. And then let's place another code block. And we're going to put two lines in this code block.

So what we need to do is type in a quotation mark. And then type sheet 1 with no space. And then add a semicolon, and press Enter. And then type 0, and put another semicolon.

Now real quick. Before we connect these up, I want to point out something. Right now we're still running an automatic mode. So I always like to change this to manual. When I change that to manual, I now have a Run button. And I can choose when it's going to run.

And the reason I like to do that when exporting to Excel is because, sometimes you may connect something up and then it starts exporting and you're like, wait, I wasn't fully ready yet. And you may enter into some infinite loop. And you're going to have to shut it all down.

So let's connect the file path node to file path. And then sheet name is our sheet 1 here. And the start row, start column, we're going to use the 0. And then data is all of our data right here.

Now we can double-check it, make sure we have everything we need. The overwrite input here, we can put a Boolean node here and choose whether or not we want to overwrite data. Right now, it's a blank file. We're not going to worry about it.

So once you have all this connected up, click Run. And Excel should pop up at the bottom. And when we open that up, you should see all of the space types, all those parameter names, and all those parameter values.

Everybody get it? Raise your hand if you got it. Awesome. Is that something you guys could use? No? Anybody?

All right.

AUDIENCE: Inspiring.

JASON BOEHNING: Inspiring. Awesome. So now, let me see if I can just backtrack a little bit. And we're adjusting the list at level so that we could get all of our space types in front of each value.

And that's because, once again, each of these was a nested list in Dynamo. And so now you can see how it output into Excel. Cool.

So you guys now know how to export data to Excel, which is something we do all the time, us MEP folks. So we have a lot of data that we're working with. We want to see it all.

And so another thing that you could do is modify this, and then write it back to Revit. But that's another class. I've covered that before a little bit. And so we're not going to go into that today.

Let's go ahead and close down. So there's a little X here next to space type begin. You can just close that down and click No. We don't want to save it.

So just a quick FYI while you're doing that. I do have the final versions in there for you. And so you're going to get all this. And so there's a final version in there for you.

And so I should have mention that. If you do get stuck along the way, you can just open those up and take a look. So all right, our next exercise-- let me get this up. So same Revit model. We're going to be using the same Revit model the whole time. It's simple, it processes quick.

And then the Dynamo file is PlacedFamilies_begin.

AUDIENCE: Couple questions on how--

JASON BOEHNING: Sorry.

AUDIENCE: How we can extract [INAUDIBLE] making the area [INAUDIBLE] how we can put structures behind the string.

JASON BOEHNING: I'm sorry, can you repeat that one more time?

AUDIENCE: Saying if you a [INAUDIBLE], so on top of the string. So how should we put [INAUDIBLE]

JASON BOEHNING: So I think his question was, if you have a string, how do you tack on like the units on it. There are a few different ways we could do it.

I could show you afterwards. We'll chat about it. So I'll just dig into it.

PlaceFamilies_begin. So I'm going to click that category in the Node Library to collapse it. Now, so what we're doing here is we're going to look at tracking the families that are placed in our model. And we're going to look at a couple of things here.

We're going to look at the number of family types that are being used per category. And then we're going to look at the number of instances per type. And I'll set this up a little bit.

So anybody working in a large team, and all of a sudden, let's say air terminals, for example, or lighting fixtures. And you have these set types that you want to use. And then all of a sudden, all this random stuff starts to show up.

And you're like, where did that come from. Who went and grabbed that family and threw it in the model? Anybody? Nobody's ever had that before, So what we're going to do is create a script that will create a nice little bar chart for us.

And we can just see quick numbers. And so once again, you start to see a spike somewhere. And then that clues you in to, OK, hey, I need to investigate here. So that's where we're going with this one.

So got my handout here. So I can keep track of everything. So once again, we're going to use element types.

So expand Revit. Expand Element. I'm sorry. Expand Revit, expand Selection. And click Element Types. And then All Elements of Type. Now when we expand Element Types, we're looking for family instance. And I'll show you a couple of things here.

So family instance and family symbol are two things that you see here. So I'm going to select Family Instance and connect that up. And so these are all the instances that are actually placed in the model. And you don't have to do this.

Whereas family symbol are all the family types that are loaded in the project. So family instance are instances placed. Family symbols are just family types loaded in the project. Does that make sense?

So just a quick background. This is actually the second year in a row that I've done this class. And I've modified all the examples. And so last year we took a look at an example using family symbol. And so if you're curious about that, just look up the class from last year.

So right now, we, have family instance. So we can see the ones that are actually placed in the model. And now what we want to do is we want to get the category, and we want to start to group it based on the category.

And so we're going to use a node called element.getcategory. So collapse Selection, and then expand Elements. And once again, scroll down to Elements.

And then if you scroll down toward the bottom, there's this get category node. So let's place that over here. And we'll connect this up. And then you can see that we have all these categories here.

But now we need a category.name node. So let's do that. And then I'll explain it real quick. So we'll collapse Element, we'll expand Category, and then we'll select Name.

Sorry, moving a little fast here. So if you look at the outputs, you're like, well, that's the exact same thing. Why do we need that extra node.

And so if you look here, the output here is a category, whereas the output here is a string. And so it's very important with the data type that you're working with. And so right now we want to use a string because we want to group and sort this information. And so therefore we need a string.

And so there are things like category.name, familytype.name, element.name. That's just going to give you a nice little string with that information.

Next, we're going to use a couple of things here. We're going to use the group by key and then the sort by key node. So if you right-click and type group by, there's a group by key. And then let's go ahead and place the sort by key.

Now the key is going to be simply the category name here. That's going to be our keys. And then we need to go back to all elements of type because we want to get those actual elements. That's what we want to work with here.

Let me zoom in here just to make sure you guys can see. So all elements of type, that's all those family instances that are placed. And we're plugging that into the group by key. And we're grouping it by category.

So basically you have all these elements. And we want to group them by category. So we can start to put it in buckets to make sense. And then we're going to sort it after that.

And so we can actually just do a one to one here. All those groups, it's going to be our list here. And then we'll use those same keys. And then we'll start to sort it based on category.

So basically what we're doing here is we're sorting about air terminal, duct fittings, lighting fixtures. So alphabetical order here to get it to match what we see in the project browser.

Now the next thing we're going to do here is we want to start to group it then by family type. So let me move this over here. So I'll tell you what, because this is a familytype.name.

So back in the Node Library, let's expand Family Type. And then once again, here's that familytype.name. And our sorted list is going to go in here into family type.