Refining Revit Standards: Setting Up Model Properties and Mappings

Chris Shafer: So why don't we go ahead and get started with the webinar. To kick things off, we're going to start off with a little housekeeping. This webinar will be recorded and made available on our website and the Guardian YouTube channel shortly afterwards.

We will be monitoring the chat. If you have any questions, please use the chat. Our team is here to answer those as quickly as possible. You may be seeing our team members putting a little...

little symbols on them to kind of claim theirs as they formulate a response. They may be punting some of these to the end. If there are more complex questions or they think it's relevant to the webinar, we'll hold those for the end. So with that being said, is let's go ahead and get into the webinar.

The webinar a little bit further. So our presenters today, myself, I'm Chris Shafer. I'm the Director of Communications and Partnership here at Guardian. And we also have Jake Martin, who is a Senior Product Specialist.

And we're going to go over today's agenda. First, we're going to give a brief overview of model properties and mappings. So there are some nuances that is best to know before we get too far along. Then cleaning an existing model. We're going to demonstrate kind of quickly at high level how to go through that process of making sure your models are perfectly aligned with your standards.

Also, we're going to demonstrate how Guardian can be used for transfer project standards as to make sure that you're only bringing in the standards that you need.

Now, you may be saying, well, you can select, oh, I only want browser organization, or you only want view templates.

But what if you only want one view template? And so Guardian actually allows you to do something like transfer single in that situation. So we'll demonstrate that as well.

We're going to go through the process of cleaning a family on insertion. And we're going to show you really getting in the weeds of the nuances of the interface and how effective Guardian is at cleaning families.

Then we're going to go through that similar process, but this time inserting a Revit detail from another project. And I will just kind of quickly say here is over the years of cleaning a lot of content and cleaning a lot of families and bringing in details, it wasn't until the introduction of Guardian did I really understand how standards within a project is so far out of alignment. And so we'll get into some details there as well.

And lastly, we will conclude with some Q&A.

All right, so we're going to start things off with some definition model properties, so...

We use the term model properties in a couple of different ways, but holistically, model properties is the engine for cleaning and aligning standards within Guardian. Now, model properties is also the dialog and processing, or the dialog and process for cleaning models and families directly within Guardian.

So you have an existing model. And you want to clean that up, or you have an existing family and you want to clean that up. So the model properties dialog is how that happens.

Jake will be demonstrating this in more detail here in a bit.

Incoming properties. So, incoming properties utilizes the model properties engine, but this is specifically for content that's coming into your project in real time. So, when we talk about incoming content, it could be a family that is copy and pasted.

It is inserted from the project, loaded from the family editor. It could be details being loaded. It could be even exploding CAD files. Any way content can come into your model. Guardian can flag that, and that interface is incoming properties.

The next is mapping configurations.

So mapping configurations is the database of mapping rules. And we're going to talk about what a mapping is here in a second. And mapping configurations is also the key to the engine of model properties. So model properties really doesn't run unless mapping configurations are established.

To expand on mapping configurations a little bit further, mapping configurations really associate with...

A firm's particular standard, and you could have multiple firms, or excuse me, multiple standards within your firm, or you can have client standards in which you have that database of mapping rules.

So, what is a mapping? So, a mapping is the conversion of 1 standard or property to another.

So we'll say Times New Roman 3-32” is mapped to Arial Narrow 3-32”. And so once Guardian sees that mapping, it memorizes it forever.

Now, Guardian, and we'll demonstrate the specifics here throughout today's webinar, is there are actually two types of mappings. One is a full mapping, meaning Guardian will memorize that conversion and store that in the mapping configuration. So not only for that given project is it cleaned, but all future projects in which those two properties are recognized, it will be mapped.

There's also another feature, and again, we'll demonstrate this, is called a one-time mapping. So sometimes you just want to clean things up for that specific project, but you don't want Guardian to remember that for other projects. And we'll get into those nuances as we progress today.

One of the things we like to think of model properties being as a firewall to your firm standards. So this is a very simple diagram demonstrating how you have all these standards from different firms, from manufacturers, and when that content comes into your your models, Guardian will identify and clean that content and those standards to match your firms.

So what type of standards? These are going to be annotation styles, line styles, line patterns, fill regions, fill patterns, shared parameters, system and loadable families, and materials.

So really, any way, or any type of those fundamental properties within your model, Guardian can identify and update to your standards. Now, there is a nifty little trick that Guardian does as well. So, what if you have your firm standards established and all your content is cleaned?

Now you have a client comes along and says, well, I understand that you have your standards, but we have our standards. So I want you, when you deliver a model, to deliver that model in our standards.

The way a lot of firms have historically worked says, well, well, we'll set up a new template and we'll convert, we'll make sure everything is converted to that company or that company standards, or they'll use that company standards, their company standards template.

Now, the process of doing that seems pretty straightforward from a technical perspective, from a Revit perspective. But when you think about the change management involved, where we had to get everyone to learn that new standard, it becomes a lot of work.

So what some firms are doing nowadays is actually completing those projects using their templates, their content, and whatnot. And then before delivering that model, they're actually converting by running Guardian in reverse, converting their standards to that client standards. So this allows everyone on the project to just maintain those processes, those standards that they know, but then the client gets things exactly the way they want it.

The other thing I'd like to highlight here is, I think it was the last, it was May of 2025, we did a webinar on the content car wash. This utilizes the same things we're going to be talking about today, but this was really geared towards what if you have a very comprehensive Revit family library or even details, how do you go about cleaning them up and aligning them with your standards to ensure that every content or every piece of content you're providing your teams are in perfect alignment with those standards?

So if I could ask one of my teammates here to paste a link to that webinar, I would really appreciate that.

So if you have any more questions about that, feel free to ask in the chat or reach out to us separately.

All right, with that being said, I'm going to hand it over to Jake, and he's going to start diving into how to clean your models. Take it away, Jake.

Jake Martin: Awesome, thanks Chris.

All right, so yeah, the first thing we're going to talk about is the engine that Chris was referring to, the mapping configurations and the model properties.

I want to first start by pointing out this sheet here that I have. This sheet here just kind of visually lays out all of the standards in this model. So this model is, this is our Guardian consistency cafe model. So this is just basically all of the standard properties, in this case, we're gonna be focusing on text styles. So all of these text styles here with our company prefixes, they're nice and neat.

This does two things. One, it helps people visualize all of these things on a sheet in a view.

But it also creates an instance and a usage of these. So when we use the model properties dialog and we scan for usage, we know exactly what's in here. And when we're looking to map towards something, we have something tangible in place.

All right.

So another thing I want to point out, especially if you're new to Guardian, looking here at the ribbon, you'll notice that my model properties button is actually grayed out, and that's because I do not have the key in the ignition, so to speak.

So the mapping configuration is the key that drives this engine. So the first thing I want to do, and this can be automated as well. Most firms do automate the assignment of a mapping configuration to a model when it's registered.

But I just want to show you this menu here. So the mapping configuration menu here, this is just simply a list of all of these different mapping configurations within my company's account. This is where you could create different mapping configurations for those different clients that Chris was referring to so you could map your standards to somebody else's or map somebody else's standards to yours.

In this case, we're going to start with a clean slate. And I've also, well, it's not too clean. I did a couple of things today, but at any rate, there's not very many mapping rules associated with this configuration I'm about to activate. And so once I activate it, you'll see this button become accessible.

So I want to go into my model properties.

So this is really the engine that drives all of the work here. So this in essence is just a consolidated menu of all the properties within this model.

You can see there's tabs for all sorts of things, materials, patterns, shared parameters, system family types. Since we're going to be focusing on text styles today, we're going to go to our system families tab and then open up our annotation symbols where we will find our text styles.

So if we take a look closer here, we can see the text styles in this sheet behind us. We've got these Guardian prefixes. We also have some prefixes to identify the use case. So presentation, text styles, QA, QC text styles for red lines, those types of things.

But we can also see a lot of text styles representing maybe outdated standards or other people's standards. So the goal here really is then to identify, okay, how do we clean this up? How do we map these outdated standards to our current?

So, it's really quite simple. The first thing that we want to do is we want to determine, okay, we can see, we can infer that the names are quite similar, but we really want to be sure when we do these mappings, so we can scan for duplication. And Guardian's going to take a look at all these properties.

It's going to compare all of the variables that these text styles consist of and make sure that one for one, they actually consist of the same exact properties. They just have different names.

So this is a very straightforward and simple example, but we'll see after this completes the scan in the duplicate columns here, it's going to register

Okay, which of these text styles are in fact the same? And that's going to be the key here. It's going to be the instructions really, so that we know what to map towards.

All right, so you can see we have, pretty much everything has a one for one duplicate, and that is pretty much all these outdated standards have a one-to-one duplicate to our current standard.

So if I select one of these hyperlinks here in the duplicates column for the number two, that's indicating that there are two properties that are exactly the same in this model. In this case, it's the heading 2 1/8” bold text style. So we have our proper prefix here identifying our standard. We also have this old one.

So the workflow here is to select the property that you no longer want and then select this icon here, which is a two arrows converging, representing the mapping. We'll go ahead and select that. And because we've already scanned for duplication, Guardian is letting us know, you know, this is a very simple conversion. We're just going to select the destination. So we have the original and then the duplicate, which is our destination.

We'll press OK.

And...

What we've done here is we've just created a rule. We've told Guardian, old should be mapped to the GDN prefix. We haven't actually committed this change to this model yet. We've simply created a rule that's been stored to that database. The beauty of that is I can actually close this menu and save that. I can open up any other model, go to my model properties, and process it within that different environment.

Additionally, the mapping configuration, now that we've told Guardian what to do, it's going to use this as a filter or a firewall, as Chris said. So as content's being loaded in, so if somebody has an old outdated version of a model on their desktop or wherever, they use it as a source material, they're looking for a detail or a drafting view, they bring it into this model, Guardian's going to say, hey, we recognize old, let's map it to Guardian or GDN.

So we've done that here. And the workflow would be to simply just go through these and identify and create this rule.

In order to actually commit this change, what I want to do is review the change. That's going to scan for usage of this. And then it's going to say, okay, hey, we're going to do this. This gives us one more opportunity to make any changes. Currently, this is a rule, so this is a mapping rule.

If we take a step back, Chris earlier mentioned there's two types of mappings. There's the rule, which this is, and there's the one-time mapping, which would make this change only in the model that we're in. And you can make that change on the fly here by toggling this arrow here.

So a mapping arrow with a one little integer there. That represents that this is a one-time conversion. It's only going to happen here. It's also not going to be stored to that database of rules. But we want this to be perpetual, so we're going to go ahead and change that back to a rule. We're going to process it.

And Guardian has removed that old one and in the process replaced it if it were used anywhere with this new one.

You can extrapolate this to any other tab within this environment. I think line styles is a great example of how useful this is, especially as you get these import patterns that originate from CAD files. This is a great example of mapping something where you might not want to create a rule because often import patterns and styles originate from a very unique naming convention based on the file they came from.

So the usefulness of a rule really doesn't make sense because we may never encounter that exact same naming convention again. So let's go ahead and map this as a one-time scan for duplication, see if there's anything that can easily be identified. There isn't an exact duplicate, so I'm just going to use my best judgment to map that to a simple dash pattern.

This one looks close enough, so we're going to go ahead and map that. But I'm going to do a one-time mapping because I may never see dash 005 ever again.

Chris Shafer: One thing I'd like to add here is, is you may not see this. Sometimes it's kind of no harm, no foul. So it's really up to you. And I think the important things here is Jake is highlighting this, so you're aware of the one-time mappings. But there are sometimes you're just like, let's do it.

And I, and especially when it comes to CAD imports, as he was demonstrating, sometimes you're just like...

Someone's going to do something somewhere in the future. I don't care what that is in the future. I just want to make it that correct one automatically.

Jake Martin: Mhm.

Chris Shafer: Thanks Jake.

Jake Martin: Yeah, thanks, Chris, and because this is all stored to this, this database, so to speak, where we keep referring to as the mapping configuration, you can always review the mapping configuration and remove mapping rules if they no longer are applicable.

So I'm going to go ahead and close out of this, and I'm going to come back to the mapping configuration menu, where we'll see the history of anything that I've just done.

So you can see these three rules, two of which pre-existed our session here today, but this one here, or rather this one here was done just today. So if I don't know, if I don't want that any longer, I can simply remove it. Or if I had saved that import pattern line pattern mapping as a rule. I could always remove it later. At any rate, you can just kind of use your best judgment and do this as you see fit.

Cool, yeah, I just noticed Paige's question. Yeah, we can answer that here at the end.

All right.

All right, let's move on to the transferring of project standards.

So to lay some context here, when Guardian is scanning incoming content, and so in this case, the incoming content would be the standards from another model.

It's utilizing what we call a transaction, a monitored transaction. This is Guardian's way of essentially paying attention to that particular incoming content. And in a default state, so if we were to create a new project configuration from scratch, it would be generated from an out-of-the-box default.

And this is important to point out is because in its default state.

May have live demos are always interesting. May have spoke too soon. But at any rate, we'll go ahead and go back to the one we were using.

Typically, in a default state, transfer project standards is the only one of these transactions where the user experience defaults to show dialogs. And this is by design, because for most transactions, you want the end user experience to be silent and passive, so there's no decisions to be made on behalf of the end user. Guardian just does all of the scanning for them, with the exception of project standards.

Because in order to identify which of the properties we want to hone in on, in this case, transferring a single view template, we want to be able to show all of that incoming content to the end user.

So, and with that being said, let's go ahead and transfer some standards.

Here's a great example of a command message. In this case, it's referring to the use of the tool for transferring project standards. And really, we're just conveying some best practices, things like that.

And yeah, nothing really to do here. Just kind of read this. I can comment. Maybe I want to tell my BIM manager that I'm just transferring a single view template.

And then we start the process as you would typically with Revit. So I'm going to transfer view templates, but like Chris said, I don't want all of them. It's kind of a pain in the butt. Otherwise, you know, you would have to create a blank project, transfer view templates into there, and then remove all of the ones you don't want and then transfer from that so you can have that single one.

But with Guardian, I can actually review.

But you know what? Let's go ahead and...

I think I was doing.

So I'm transferring beforehand, so all this stuff's already in my model. Let's see here.

Let's do that again.

There we go. So Guardian's going to scan that incoming content. It's thinking right now and it's going to present me with the dialog, the full dialog, so that I can see exactly what's incoming.

So I'm just going to go ahead and collapse all these other properties that are coming in with the view templates. But.

Let's focus on our view templates here, so we can see all the different view types, the view templates associated with them. And one thing to note here, and the key to this is why we show this to the end user regarding its main functionalities, is to purge unused properties at the point of entry for most transactions.

This is perfect, but with view templates, by the very nature of them having no usage at this point, because we're only transferring the singular view template, Guardian's basically slating them for removal. So the kind of trick here is then to then select the view templates we want to bring in.

So if I only want to bring in this half inch building section, all I need to do is select it.

And now that is the only view template that's being brought into my model.

So you can see there's a lot here.

This lets you be very selective on exactly what you want to bring in.

And I have to admit, I don't even remember what it was called. Chris, do you?

Chris Shafer: Yeah.

Jake Martin: Oh, half-inch building section. There it is.

Chris Shafer: Yes, half inch because it doesn't meet the naming standards of right.

Jake Martin: That's right. Yep, there it is and that's the that's the only one I brought in.

Chris, is there anything you would like to add? Yeah, go ahead.

Chris Shafer: One thing I...

Yeah, one thing I want to highlight there is...

It wasn't until I started using Guardian, and I mentioned this maybe earlier, was did I start to realize how much stuff comes in with things like transfer project standards or insert views with another project or, you know, any basic family stuff that just isn't used, and...

Without Guardian, all those properties, those standards, just come into your models.

And really, we've heard this time and time again since the beginning of Revit, that Revit can't produce good-looking drawings. And honestly, Revit can produce as good-looking drawings as any other medium before whether it was hand drawing with pen or pencil or even AutoCAD.

The problem was with Revit, you've never been able to control the properties that control the graphic output of Revit. And so Guardian really kind of solves that problem, ensuring that your your models aren't just overloaded with kind of junk and bloat.

And ultimately, the reason why firms have given up on that graphical quality is the amount of effort it takes to, one, clean it manually, and two is for teams, especially younger users who are utilizing Revit, when they go into, say, text types or dimension types, there's a whole list of those in there. And they're like, which one am I supposed to use? I don't know. I've been here for two weeks. I'm just picking the one that I think it should be. And that's where the standards start to go awry.

So utilizing Guardian, especially from day one on a project, that it becomes a very important firewall, making sure that the standards that we're seeing here on the screen now are the ones that are maintained throughout the duration of the project.

So there is very little confusion for those users. And again, those graphic standards are really perfected.

Jake, nice work. Anything else to add there?

Jake Martin: No, I appreciate the context there. Really is the best way to go about it. Start from inception, protect it from the get-go.

Chris Shafer: Yeah.

Yeah, and I want to answer Paige's question later in the webinar, but I think there's some understanding when to process project properties and how frequent kind of ties into Paige's question as well that we can address later in the webinar.

All right, cool. So if you don't mind, Jake, I'm going to take the screen.

Jake Martin: Yep.

Chris Shafer: And...

Hopefully everyone can see my Revit. So what I'm going to do now is I'm going to demonstrate the inserting of a Revit family. So over here on, oops, let's go over here.

is over here on a different monitor. I have a family ready to go. Now, it's a door family and it is 5 megabytes. So this is sort of getting into like sort of a worst case scenario here.

And so now that I've placed it, Revit is going to go ahead and start to process.

Process the family now.

This is, as I mentioned, this is a relatively large family of five megabytes, and there is many nested families within, so...

For an admin, they will get this dialog. The first option to remove new properties that are not used. Think of this as sort of a super purge on use for for those families. So as Jake was demonstrating earlier, the items that not being used in a in a inserting a family, Guardian will just clean those out automatically for you. In addition, any known mappings, Guardian will go ahead and process as well.

Now, there are times you'd want to do this for, and if we go back to the transactions that Jake was referring to in silent mode, basically in silent mode for those end users, they're getting option number one here.

So, as an admin, we recommend always choosing, let me choose which properties to keep.

So here you can see all the properties that are coming in with this given family or these given families, I should say, because these are a lot of nested families. And so the idea here is for you to scroll through each of these and update them to the appropriate property within each category.

So one of the things I want to highlight here is up top here you can see that you have the name of this nested panel and you can see it was originally named nested wrong 2 and then it's grayed out with a mapping already applied. This is pulling from that mapping configuration.

So this is how Guardian starts applying these mappings to all future instances where these, whether it's the family names or, you know, we'll get into like shared parameters and whatnot. So the more you use Guardian, the more you're using.

model properties and incoming properties, again up here in the left where it says incoming properties, the more intelligent Guardian gets.

So really the purpose of this is to go through and make sure from a family's perspective that all your families meet your naming conventions. So if I say F here and if I wanted to rename this flush panel.

Now, Guardian would always remember that. Simple things like...

You can see the conversion of an old naming to a new naming, where here nested was at the end and want to move nested forward if I want to update my nested door pull to be that.

Now I've updated it and forever it will be fixed.

You can even use it for simple things like here we have this interior single, where the type here is just the family name. And as you're aware, that usually isn't the correct way of doing it, or maybe your standards. So we can rename this to say 36.

oops.

36” W x 72” H

I don't know what it actually is here, but for demonstration purposes. As you can see here, when you get into even this ADA clearance.

We can even merge these to those existing ones. So now we only have one type if you need to. If there are multiple types, they're all the same. As you're aware, as content comes into models and new families come in, but sometimes the types are adding up pretty quickly as well.

So coming down here, obviously we could get into annotation symbols. Your arrowheads really doesn't apply when it comes to families.

But how about shared parameters? So here you can see you have your not the correct scheduled frame type, and I want to update. Oops.

And if I want to say frame type, scheduled frame type, now I've updated it. In each of these cases, I have the before and after GUIDs by just using the tool tips. So.

This ensures if you have old family that was made with old families made with old shared parameters and they come into a model, this gives you the ability to even clean up those shared parameters.

Guardian will even go through, ensure all the formulas are intact. In addition, if those shared parameters are linked between nested families, it'll keep those links. So.

I'll kind of quickly kind of go through these, but really the process here is just, as Jake demonstrated earlier, is just go through and update these old standards or the do not use to your given standards.

And as Jake may have mentioned earlier, is Guardian makes the assumption that the project you're working in is your source of truth, and that if a project is starting with your template that you have used Guardian to clean to begin with, making sure everything is perfected, everything coming in will always need to be what's already in that project.

So those standards are already available. So you can see we were, you know, trying to have a little fun here, not aligned, aligning line and whatnot. You just go through and start picking these. Who draws the center line like this, you pick center line.

Also to highlight here is there's a little preview in a lot of these, so you know exactly

exactly what you're choosing and what they look like. So even little things here like not correct line styles. The idea here is just to kind of go through, do this.

And you may be thinking, well, this may take a while.

But again, the more you use Guardian, the quicker this process gets. So.

In this case, I just want, I know clearance zone is my standard.

And I don't, and...

I can map, sometimes you can see these, this clearance zones is not being used, and clearance is not being used. So in these situations, sometimes all you want to do is go ahead and map them, because the goal here isn't necessarily to isn't necessarily to maybe clean this, because Guardian's going to clean it anyways. The idea is to be able to teach Guardian that rule. So when you have your opportunity to see it.

take advantage of it and make that a teaching moment.

So now that I've done that, I can even come down here. And I would actually, this, sorry. My time spending cleaning content just doesn't allow me to skip over cleaning the content. So I can even come in here if I want to make these.

These, excuse me, drafting patterns and turn them into model patterns, I can do that as well.

And it will go through and update them accordingly.

So with that being said, I can go ahead and now process this. Actually, I skipped a part that was going to demonstrate right there. There's a little button there that allows you to save that family back to that original source.

And so this is a great way if you're updating your content and you have everything stored in a file or folder location, Guardian will go ahead and write back to that location.

And as you can see here, even being for a 5 MB family.

That went fairly quickly. It felt like a long time in a webinar setting, but when you're cleaning a lot of families, this is even for five megs, you know, this is relatively quick.

Now that I open up this family.

And...

We can go through and we can start to see, you know, simple things like...

Your scheduled frame type, uh, I believe it's under where did it go.

A second.

Right here you can see it's been updated accordingly.

So, you can come in here to your manage and go to your object styles, and we can see now.

All that has been cleaned, and it's been cleaned throughout the entire family.

All right, cool. So, that's the loading of a family, but what about a detail? So, a lot of firms spend a lot of time, a lot of investment into creating standard detail libraries.

But sometimes from a Revit properties perspective, those details, if not cleaned, can actually cause more, I want to say more problems. It will cause your standards to go off alignment when they're brought into your projects.

So having Guardian and the ability to say, hey, we've created this library, but we've also perfected it to our standards. Well, another way to help firms really see the value of Guardian and the value of the details that you've created. The last thing you want is, once you've gone through that effort, is for people to be like, "Yeah, but every time I..."

I insert a detail from the library, it brings all this junk with it. It brings outdated families, it brings object styles that just, I have to spend a lot of time cleaning up in my view templates and so on and so forth. So what I'm gonna do is, let's go ahead and insert view from file here, and I'm gonna quickly...

Copy that path.

So I'm going to go ahead and insert this. Open up this family, or excuse me, this project, and I'm going to insert this sheet.

And, as you can see...

Revit is already starting to look at those, and now Guardian is actually going to work here.

And what's really fun about this is once you go through the incoming properties dialog, you can see Guardian actually working and updating your details. If I had just brought in the detail itself and we saw a full picture or it was the extents of the screen, you would see things just cleaning up in real time.

So here again, Guardian is going through the process of cleaning up that detail.

And you can see how many, how many families are in here.

and then going through a lot of...

Going through a lot of the individual, just like fill patterns, filled regions, and whatnot as well, and then, as you saw there, it was also detecting duplicates. Guardian can automatically merge those duplicates, and what we mean by that is duplicate families.

So, as you may be aware, as families that already exist in your model come into your model or come into your model from another location. Revit wants to say, well, I don't know if those are the same. And I'll put the ones and twos and threes behind that. So here again, we're going to select, let me choose which properties to keep.

And. As you can see here over in the left, there is just a whole list of detail items coming in.

So a couple neat tricks here is first I want to start with the title block.

So what if you're pulling from an old project?

Or an old library, and you want to make sure that that title block is automatically updated with your current title block. So, here I can come in here and I can update it with, or I should say, to the Guardian title block.

And now I'm teaching Guardian what that standard is.

One thing to note, when it comes to mapping families, you also need to map the family types. So in this case, the family types are the same, so that gave me that there was no nothing to map.

In addition...

When you bring in views, you're also bringing in the titles and the callouts and everything else. And so here again, you can go through and start teaching Guardian all of your standards. So here I'm showing here with the view title. I'm going through the individual types on each of these.

And it is a pretty quick process once you're used to Guardian, and you can make quick work of all this. So now, whenever anyone in your firm pulls from...

Pulls from old projects.

Guardian will do this work for them.

I think it was Liz earlier asked about the circular references. So as you can see, this isn't necessarily a circular reference, but there were old standards that were converted to less old standards, and now I'm converting those to even newer standards. And so Guardian will maintain that logic throughout.

In addition, we can see here with the one, I can come in here and let's select the...

Cold form metal framing.

and I can map those.

So you see there's a series of these. Here's the old gypsum sheathing.

And how many times, and just out of curiosity, raise of hands here, is how many times have you gone into a project and you've just seen just endless family types of GWB?

And everyone's like, I don't know which one to use. I'm just going to pick one. And then again, your standards are completely off the rails.

The other things I want to highlight here, we could spend all day in the families and cleaning them up. I'm going to have to get over my OCD here and kind of move on. Here you could even get into your system families and making sure that those system families are properly mapped as well. And those are updated, even your viewports.

So these are the subtle ways in which you are, I guess we don't have a half size. In this case, if we don't have a half size, we can always just rename this and just be GDN View title - Half size.

So now that is updated accordingly. Even my...

Drafting views, all that can be updated. And here again, you're getting your shared parameters, you're getting your materials. By clicking here, I can see my material is actually in the title block. I don't know why title block, or excuse me, materials are in title blocks, but I can go ahead and remove this. This is a good opportunity to

Say, do not remember, because you know that material might be in an actual 3D family that you may want to use, but let's go ahead and remove that.

And then, as you can see, we start getting into view filters and object styles and subcategories, so all this can be cleaned up. And what's always surprising, and I mentioned this earlier, is the amount of bloat, the amount of non-standards or...

The amount of infected standards that come in your project, and something as simple as inserting a single detail can bring, and you wonder why firms struggle to keep their standards in alignment, struggle to be maintaining a high quality graphical output of Revit. And this is why this gives you a good demonstration of just how much and how complex Revit is in maintaining this where Guardian kind of perfects that process.

So I'm going to go ahead and let this process.

And since we have 9 minutes to go, I think now is a good time to open the Q&A.

I first want to address Paige's question in the chat there is, what is the appropriate, if I recall here, I can't see the chat while I'm presenting here, but if I recall,

Is what is the appropriate amount of properties to process at a given time? So, this is really dependent on a lot of factors. So, let's first say if you're going through and cleaning up a handful or cleaning up families that you just want to drag and drop, like I did into a model and you want to clean those families up.

I would say...

The primary factor is the file size of each of those families. And typically when I've gone through large cleanup processes, there's a couple things to note there. Say if I was doing doors, and I would say from my experience and from my previous firm,

We had about 75, 80 door families. What I would do is I would take maybe like four or five door families, go ahead and drag and drop them into Revit and let Guardian clean them. And that would capture probably about 90% of all the properties in the other door, all the door families.

And then I would just go ahead and do the mappings, because actually the longest part of that sometimes is going through and mainly knowing what is this, what is the standard in the family, and how do I make it the current standard. Once I would go through those four or five families, then I would do maybe families in chunks of 25 and let them kind of roll at that rate.

Now if I was doing something like detail items, I may do 100 detail items at a given time. Do 100, go through the mappings and then let Guardian spin and do its job there.

Now, a lot of times I would do this maybe on a virtual machine. So I would be utilizing the resources, especially the high speed capability of a virtual machine versus my machine. And so Guardian could just be off doing this job while I can continue to work there.

Now, when it comes to, say, you have a model, and this is something that...

That Jake was demonstrating earlier, where if you're not using Guardian from the very beginning, the stuff accumulates. And the longer you go, the longer it's going to take Guardian to process that, right? So.

Our recommendation there would be maybe just do a single tab at a time, or maybe 1/2 a tab, within that model properties dialog, because trying to do it all at once will take a while, maybe an hour or two, but this really reinforces the need of utilizing Guardian from day one, and even going back maybe once a week, going into model properties to just clean that model. If you do it once a week, you're probably talking 10, 15 minutes to go through that process, and that's sort of a worst case scenario.

All right, cool.

Gonna look to my teammates. Any other questions in the chat?

Josh Kennedy: We did have a few, Chris.

I was answering a couple in the Q&A section, the formal Q&A section. Let me go back and find, I think there was two or three more.

There's 2 longer questions in a row.

I don't know if it's easiest for me to read them out or for you to just scroll up a little bit. I pinned them both. The first one's by Randy Groff and the second one's by Pierre.

Chris Shafer: All right, let me see if I can find those.

Josh Kennedy: If I can, I can read them.

Chris Shafer: Yeah, how about if you go ahead and read those?

Josh Kennedy: Yeah, the first one's from Randy. It reads, Guardian guards a project and what comes in, but since it contains all of our standards, can we have it push these different BIM standards into a starter project? We are dealing with multiple BIM standards for different states and entities with template, that are constantly changing, consistently changing.

It would be nice to not have to use transfer standards and have Guardian set up the file with our client's BIM standards. There are several programs out there with pieces of all these features, but I haven't ran across one to do all of what we needed to do.

Chris Shafer: Yeah, that's a great question. Is we have actually a feature called all.

Guardian cloud properties. So the idea here, and to set this up properly, you'll notice that here under cloud.

Under the line here, you have fill patterns, line patterns, line styles, shared parameters, system family types, and view filters. And then over here, under model properties, you'll see the same thing. And so Guardian can host these properties in the Guardian cloud.

So under model properties, this shows you everything that's in your given project.

And so from here, if I come down to text styles.

This shows me everything that's currently in the cloud. And what I can do, I can see this Guardian Note 3/32”, which is the most fundamental standard here. I can select upload and sync.

Really what it's telling me here that there's a version of there in the cloud, but it doesn't match. And I can keep those synchronized.

And now it's actually showing me where that difference is. One is transparent, the other one is opaque. So if I want the one in the project to be opaque, I can just hit OK. And now you can see.

You can see not only this is in the cloud, I also have the link icon, meaning that.

This has been pushed to the cloud and if a change is made, Guardian will identify that. So if I need to change that standard.

If I come back over to text.

And if I click here, and I'm going to just change this to whatever. Maybe I want to make it that. If I hit Apply Changes, I can now see that is not the same in the model.

And so, if I click here, I can fix that relationship, and then I can update what's in the model with what's in the cloud. So, this is a way that Guardian can to address exactly what you need is take all those properties in the cloud and distribute it down to any project model. There's ways to even set Guardian up to do this automatically. Right now, I should kind of demonstrate the manual process. Great question there.

And this whole cloud properties is something that we didn't get into today.

Great, Josh, you said there was a second question.

Josh Kennedy: There was, and some keep coming in. I know we're up against the clock here in a few minutes, but we'll answer as many as we can here and follow up with anyone else. But Pierre’s question, I'll read off here. How would the project team with 50 odd consultants in a single project manage the parameters of the project? Set the parameter standards and share a set of parameters for each discipline? Do a global swap out, replace the parameters, are grouped the same, and all the attributes the same? Scheduling is incredibly complex when having multiple parameters with the same purpose/intent?

Could this be a batch? Could this be a batch for this project to ensure handover, O&M assets are cohesive? Can Guardian do that? Or what combo might solve this?

Chris Shafer: So ultimately, when you talk about the parameters, you're really referring to the shared parameters, because this is really what gets out of alignment here, right? So here again, just like I demonstrated with the text, you can do that with shared parameters.

So, say on this given project with 50 different consultants, if they all have Guardian, Guardian will work as a firewall. So as soon as someone brings in a schedule, they can then start updating that schedule to the actual project shared parameters.

So that was actually a really good question because we talked about, you know, inserting views, but what if you insert a schedule? That's where the shared parameters become pretty important.

So yeah, Guardian can handle that on a shared parameter, or excuse me, on a scheduled basis, but then also, you know, host those shared parameters to the cloud, and then make sure every, you know, every team within that project is updated accordingly. Good question, Pierre.

Jake Martin: Chris, there was one in the Q&A that I mentioned that we could demo really quick. The question was from Margarito. They asked, is there any way to merge mapping configurations?

Chris Shafer: Yes, and so if you come over to mapping configurations.

We can see here we have the company standard and we have the test. And so if I actually come down here to merge and select company standards, Guardian will merge them.

Now, if you run into a situation where, where, not sure why that didn't work the way I expected it, but anyways, is if you run to a situation where there are conflicts for circular...

circular mappings, Guardian will identify those for you and walk you through making sure you clean those and then select the appropriate mappings in those conditions.

Good question.

Jake, Josh.

Josh Kennedy: I was just going to close the loop. I think we've gotten to all the questions at this point.

Chris Shafer: Awesome. Great.

Well, I want to thank everyone for attending today's webinar. I know we went really, really in depth into how Guardian works and how it gets into every little nook and cranny of families, details, and models.

So ultimately, the goal here is to making sure that your content and your projects are really perfectly aligned with those standards.

So with that being said, I want to just again, thank you everyone for attending. And if you have any more questions, please reach out to us or check us out on our website.

Thanks, everyone.

‍