Leveraging Civil 3D Property Sets for Design and Collaboration

STEPHEN WALZ: All right, welcome, everybody, to my class, Leveraging Civil 3D Property Sets for Design and Collaboration Purposes. Quick safe harbor statement. Wanted to just make it a point that I'm going to be talking about some things that are currently in production, currently being developed right now. So I'll make some forward-looking statements as it relates to some of the things we're being worked on behind the scenes related to property sets and some other things going on.

Just really want to bring light to these things, let you know that things are being worked on behind the scenes. If you visit the Autodesk Infrastructure Futures website, you could certainly join them and test out some of the products, the tools that are currently under development that are in alpha and beta form. But definitely, they're looking for feedback on these tools and looking for testers to go out, check this stuff out. There's a lot of cool things out there being developed.

But really, just want to make it a point that do not make any purchasing decisions based on what I'm going to be saying. There's no guarantee that these are going to be integrated in future releases. But they are being developed and being worked on for potential release.

Quick introduction about myself. I'm Steve Walz, OK? Seventh time attending AU in person. Obviously the past two years, we had the virtual. But this is my seventh time attending in person. And this is my first time as an Autodesk speaker.

I work at HDR as a civil infrastructure digital design lead. And in that role, I work, collaborate with business group and technical leadership covering all of our major market sectors, supporting all our major market sectors. And we evaluate existing technology, look at the new things coming out, look to the future, and try to make sure we are establishing a good foundation to adopt new technology solutions.

We look at things about adoption strategies for the new tools, developing standards, workflow documentation. And right now, we're very heavily focused on developing a data strategy. And that's what spurred the interest in developing this presentation around property sets because it's all around the data being plugged into our design models.

I also sit on the buildingSMART International US chapter within their Education and Professional Certification Committee. And I've also sat in previous years on their international awards as a jury member looking at all the new cool things that are going on around the globe, all the submissions that are around open BIM and open data standards and applying them within our daily workflows.

buildingSMART International, for those that are fully aware of who they are-- they're a non-profit organization. And they're really paving the way for open BIM and open data migration standards that are being adopted and pushed out across the industry. I also want to make it a point that I'm not a programmer. There are some things that I'm going to be talking about related to automation. But I do want to let it be known that I don't have much of a programming background, but I know enough to be dangerous.

So the focus areas we're going to be covering today, we're going to do a quick introduction on Property Sets. We'll talk about property set values and how to automate within the Civil 3D platform itself. And then we'll jump into ways to automate using Dynamo.

And then we'll talk about how we could leverage the property sets outside of the design environment. What is the value, the great value of plugging this information into our design if we can't leverage it outside of that design environment? So we'll talk about ways that we can leverage it outside of that design environment.

I do want to point out that I'm using Civil 3D 2022 in my demonstrations. I understand with '23, there's some slightly different user interfaces. But everything that's going to be covered today is forward-compatible to 2023.

All right, so Property Sets introduction. What are they? So in a model if I were to select a pipe, we get access to some basic information around the color, the layer assignments, the styles. We get some data reference information, the alignments of surfaces and so on. We get some basic geometric information.

If I were to select that pipe and right-click in my model space, I'd be able to gain access to the pipe properties, which would give me all the metadata-- which would list out all the metadata associated with that pipe. So it's a little more expansive than what's available within the Properties dialog box. But as it relates to property sets, if I were to click on the extended Data tab, we get this section where we can apply custom attributes-- custom metadata to our objects. Whether it be 2D or 3D geometry, we are able to extend the metadata association with our objects.

Quick high level of some of the terminology. I'm going to be tossing around some of these names. So just want to give that level set real quick. Property sets were going to be covered within this demonstration. And within the property sets, we have property definitions, which we will be creating on the fly in our demonstrations and the values that are associated with them. So we have the property values assigned to the property definitions all contained within the property sets.

So quick high-level benefits and caveats and pros and cons about property sets. Obviously as I mentioned, it allows for the ability to add some additional customized metadata to your objects, associate that with your objects. You can also leverage it for labeling, tabling, and reporting purposes. So if you want to extract that information for labeling or even reporting out to a Word file or an Excel file, whatever it may be, you could certainly leverage the metadata, the property set data for those purposes.

It also allows for quick referencing and linking to pertinent details. So say we're designing a pressure network, a water line that has a gate value that we want to link out within the custom attributes within the property sets to, say, a cut sheet or a manufacturer website. We could certainly add that type of linking to it as well.

All of these property sets-- it's important to note-- are supported through IFC conversion. So as I mentioned with buildingSMART International, they're really paving the way for open BIM and open data standards through IFC formatted files so we could export our models now from the Civil 3D environment to IFC. And it could be carried into construction management solutions and asset management solution as well. So we're essentially preparing our models for construction and asset management purposes as well.

Some cons. Right off the bat, get this out of the way. There is some manual configuration still initially. There are ways to streamline some of these workflows.

So once we set these up, the property sets, within our drawing environment within Civil 3D, we could certainly save those into our drawing templates, which we could use to create new drawings moving forward so we have all those being carried over from drawing to drawing. They could be project specific or company specific depending on which route you want to go. But there is still that manual configuration, which can be quite time consuming and quite laborious of a task.

Manual input. Manual property definition is one thing we're going to be covering today, although, manual-- most aspects of the manual are manual input. There are ways still even within that manual definition to automate it. And I'll talk about that in a little bit. And it's also important to note that not all platforms will recognize the custom definitions if the design is referenced in native format DWG formatted file.

So when we jump into ways to automate, later on in the presentation, I'm going to be showing how we can embed formulas and tap into the Civil 3D APIs. Those APIs aren't necessarily read in some of the collaboration tools that we're going to be referencing our DWG files into. So there are ways around it, and I'll show you what those look like.

It's also important to note that we have Dynamo, and we have a Standardized Data Tool that will certainly help. Standardized Data Tool, as I mentioned earlier, is available on the Autodesk Infrastructure Futures site. It's currently in beta. Go ahead, test it out, go sign up, and test it out. They'd love your feedback. And the Standardized Data Tool will streamline a lot of those workflows to integrate and carry over property sets, and create those on the fly, just streamlining a lot of the workflows associated with property sets.

So the three major property definitions we're going to focus on today are the manual, the automatic, and the formula. These are really the major property definitions that are supported within the civil-- on the civil infrastructure side of the house. You'll notice that when you jump into this when you start creating property sets and getting yourself familiar with it, there are some additional property definitions available to us. But those are really more supported on the MEP and architecture side.

Manual, automatic, and formula are ones we're going to focus on because they're fully supported within the civil infrastructure workflows we're going to be discussing today. Also, the last time we were in person, wanted to point out that Jo and Andrew led a great presentation called Dynamo and Civil 3D Introduction-- Unlocking the Mystery of Scripting where they dove a little further into the formula where they included plus-COM API and .NET automation aspects as they relate to property sets. So additional ways to automate.

Go ahead on the AU classes from previous years and check that out-- definitely some great resources out there. But I will note that the Standardized Data Tool that I just mentioned also that's in beta does cover a lot of what was discussed during that presentation, as well, and incorporates a lot of those workflows. So it's just getting a little easier for us and less manual labor and time-consuming tasks.

So what does that workflow look like for creating and assigning property sets? We got that introduction of property sets. Let's look at that workflow. What does that look like? So if we were to type at our command line, PROPERTYSETDEFINE to gain access to our style manager, we could also type style manager. And I'll show you what that looks like. But for the purposes of this demo, I just want to keep things simple.

So we type propertysetdefine at the command line. We gain access to the Style Manager dialog box. We've got our property sets listed out. We're going to go ahead and right-click on Property Set Definitions, create New. And we're going to call this AU Demo to keep things consistent because this is a demonstration for AU.

We're going to switch over to the Applies To tab once it's created. And we need to define or associate-- we need to define where the objects, the types of objects that we want to associate the property sets to. So we could either select All. As you can see, this list is quite extensive. It covers all 2D, 3D, objects, but we're going to select Pipe for now.

We just want to focus on some of our gravity pipe networks. And we'll give it a description, always good practice to give it a description. This isn't a great description, but there it is. So if we hit OK, we've created our property set. We select the Pipe. We get our properties. As you can see, we've got that great basic information about it. If we switch over to the Extended Data tab, we'll click on the Add Property Set. And we get a dialog box to add the property sets.

We only want to assign the AU Demo at this point. So we'll check that box, hit OK. And if we pull up the properties again of that selected object, you see it's not listed. And that's because we haven't added any actual definitions to it. So we've got the property set created. Now, we need to create some definitions so it will show up in our model.

So let's type propertysetdefine one more time to pull up the Style Manager dialog box, go up to our AU demo, and switch over to the Definition tab this time. And for starters, we're just going to start very simple, create a manual property definition. The name we're going to give it is Manual_PS for property set. We'll hit OK. The type is a text, which allows us to manually type a text value to this definition.

And if we pull up the properties, you can see the AU demo is now listed because we have the definition. Let's give the value to it, Manual Property Set. And there you go. It's as simple as that. So now we've created a property set that contains a property definition and a property value and associated with an object.

Like I said, we're just going to keep these demonstrations real simple, straightforward to give you an idea of what the process looks like. Obviously based on what you guys are going to be trying to assign or associate with your objects, this list of definitions could become quite cumbersome and quite expensive. But definitely try to work it out so that you're minimizing what you do from a initial setup standpoint, an initial configuration standpoint.

So let's jump into ways how we could automate it. Let's understand-- try to incorporate some automation into our workflows as it relates to property sets. So we just talked about the Manual Property Set definition. And as I mentioned earlier, there are ways to automate it even by using that manual. So within the manual, we assigned it as a text type. We could also apply it as an auto increment character, which is essentially a, b, c, d, e and so on.

And this, as we assign or associate these property sets to the objects, it will automatically increment based on character or based on integer. So 1, 2, 3, 4, 5-- it's a whole number. We have the opportunity to apply an integer, which is a manual input, which again, is a whole number. No opportunity for decimal placement.

The next option is List, which is accessed through the STYLEMANAGER. And I'll show what that workflow looks like later. I mentioned earlier there were two ways to access that STYLEMANAGER dialog box. One was the Property Set Define command. The other is by typing STYLEMANAGER. And then by typing STYLEMANAGER, you get access to the List Definitions. And that essentially is defining a preset-- a predetermined list of values that you want to assign or associate to your property definitions.

Real is an actual number. So this actually allows for decimal placement, but this is also a manual input. Text is what we just showed in the previous demonstration. And then we have a Boolean, a true/false. So that's the Manual Property Set definition. And those are all the opportunities-- the value options that we have that could be applied.

Next, we're going to be discussing the Automatic. So with the Automatic, these are automatically populated directly from the object itself. So if we have a color assignment of cyan applied to pipe, this will automatically populate in that field in the value associated with it. Same thing with Layer. If it's on C Domestic Water or something like that, we'll automatically pick that up, recognize it, and assign it.

The one thing that we're going to be focusing on for the purposes of this demonstration is the Handle. The Handle is essentially a GUID number or an object ID number that Autodesk assigns each object as they're created behind the scenes without us even knowing. And we need a way to tie and identify the object that we're going to assign some formulas to.

So the formula real quick-- this is going to be about the most extensive coding example I'm going to show you. And a lot of this is copy and paste. Like I mentioned before, I know enough to be dangerous. But I'm not too fancy. I don't get too-- I try not to get too fancy with it, I guess.

Essentially everything highlighted in yellow is a copy and paste from coding from lines of code that I've seen before and is available on Autodesk Knowledge Network and several other sites that I'll mention later. But one thing to note is everything highlighted in green. These need to be looked at, identified, and potentially replaced. So this one right here, this crazy-looking one, this is the Civil 3D API Library that we're going to be assigning, pulling information from.

This 10.5 refers to the version of Civil 3D we're currently using. This one refers to 10.5 as Civil 3D 2016. I hope nobody's on 2016 right now. But in any event, I do have these listed out, these version values and associated with their versions. And then we have another line of code that includes the handle, which refers back to that Automatic that I just discussed, that Automatic property set definition, and then the object's StartStructure Name.

So in the instance that we're assigning this to a pipe, we're going to pull this Civil 3D API, which is the starting structure of the pipe, to automatically be populated in that value. This is available and listed out within that library. And I have resources-- links to resources available later on. So it's pretty much plug and play.

This Civil 3D API is found in this library. This is the version we're using. And this is the automatic, the object, the tieback to the object so we know which object we're referring to. So for the purposes of this workflow that I'm going to be showing shortly, I switched it up a little bit. So we're going to be using obj.Length3D.

Again, going back to this library, we're using 13.3 version and tying back to the handle. So what does that workflow look like? Let's type PROPERTYSETDEFINE at the command line. We'll go to our AU Demo, go to the Definition tab. And we're going to create that automatic property definition here.

And as I mentioned, we're going to be tying it to the-- we're going to be adding the handle, which is that GUID number, the object ID. We'll hit OK. We'll select that object again, that Pipe, go to our properties. And we see that handle, that object ID automatically being populated. So it's already recognizing which is great.

Now, let's jump back into the Style Manager using the PROPERTYSETDEFINE command, go back to our AU demo, and now, we're going to add that formula property definition. And then the formula, like I mentioned before, it's just a copy and paste with some minor replacement. So let's copy from Word into the formula field.

We see over here, Sample Result. That's a dash dash. That means that it's not going to work. So this handle needs to be tied back. So we double-click on Handle under the Insert Property Definitions here. And we see that sample result automatically populate. So we know we're on track. We're on the right track, at least.

So let's hit OK. And then we'll go select that object again, go to Properties. And we see now that value automatically being populated because it recognizes that object. So we're tying it all into that GUID number, which is great.

But next thing we want to do is we want to give this a proper name. We don't want to leave this his name. So we'll call it Formula_PS_3DLength. Make it a little more intuitive for us, for the average person looking at this information. And then if we select that, you could see everything automatically update in this property set. So it's being listed there.

So that's a quick high level. How we could tie into Civil 3D APIs-- leverage Civil 3D APIs through formulas using the automatic assignments or association of the objects. So real high level. Like I mentioned, there's a lot of great resources out there. Here's a quick list. These are also available in my handout.

But these are the libraries that I mentioned earlier, which has all the Civil 3D APIs listed out. And it's really just a matter of identifying what you want to-- the information you want to extract and assign and plug in for that value. And it's just a matter of plug in and play and moving things around.

There's also a lot of great blog posts about this information out there. This is definitely how I got started. I was introduced to some of these blogs. And I saw some of the great things other people were doing. Some of them are attending this class, actually.

So really appreciate all the assistance, all the guidance. And as everyone else who's watching this or attending this class jumps into property sets and understanding how this works, I'm sure you guys are going to be posting a lot of information about it as well. So obviously there's more to come. So some great resources to check out.

So we talked about how we can leverage or incorporate automation in Civil 3D by leveraging automatic and formula property definitions. Let's take a look at Dynamo and see how we could leverage Dynamo to automate some of these tasks. What is Dynamo? Just a quick level set, it's a visual programming tool for those that aren't as familiar with it.

It's a visual programming tool. So things unlike, I guess, .NET, C#, and so on, some of those other visual coding programs, this is very workflow-oriented. So it's not looking at a whole bunch of lines of code and trying to decipher what's what. It's really just understanding the workflow. And really, I was able to pick this up relatively easily because I understand what that design workflow and progression of design actually looks like.

And that's really, in my opinion, the major experience that you need to start picking up Dynamo and understanding it a little bit. So like I mentioned, the design progression, understanding that design progression. So if you want to create a corridor, that's your end goal, right? You know that to create that corridor, you'd start with an alignment.

You need to reference surfaces. You create your profile view, your vertical geometry. Then you have a subassembly or an assembly composed of many subassemblies. And then you can create your corridor. So understanding what that design progression looks like within Civil 3D. Those types of concepts can be applied within Dynamo.

Important to note that it was introduced in Civil 3D 2020. Unfortunately, anyone who's using a version that predates 2020 will not be able to access Dynamo for Civil 3D. But if you do have 2020 or newer releases, you could certainly access it.

And then behind the code-- behind the workflows, like I mentioned, it's a visual programming tool that is workflow-oriented. But behind these workflows is Python coding. So if you do understand coding, you could certainly develop custom nodes, custom workflows using Python coding language.

So how to access it within the Civil 3D environment, we would go to the Manage tab. And then we'd go to the Visual Programming panel where we have Dynamo and Dynamo Player. Dynamo Player is essentially the equivalent to clicking the Easy button. So if we have a bunch of Dynamo scripts that we've already created, we want to apply them or run them on our current file.

We can just pull up Dynamo Player, get that list available in our library. We had play, play, play, play, play, and it runs. If we click Dynamo, we get the program itself. On the left side, we're seeing some recently activated or recently worked-on scripts. We can create a new one. On the right, we've got a bunch of resources. And I have these links to the resources later on.

If we click New, we jump into the program itself, or we could start building out our script. Up at the top, we've got some pull downs. On the left side, we've got our Library. We've got our out-of-the-box functionality, the basic functionality that comes with Dynamo installations. As we click on these arrows, it'll expand. So Civil 3D. If we were to expand that, we'd get Civil 3D functionality and workflows.

We have the ability to search. So if we know exactly what we want to do, we, like, say we want to do something around alignments. We would just type alignment in the search box, and we get a preset list of all the workflows and nodes that are associated with alignments.

And then the Add-on section down on the bottom here is, like I mentioned, the Python coding is behind the workflows. There's a lot of great people out there that are building these custom nodes and workflows and making them available for free. So these are all those add-on packages, which are accessible through this packages pulldown. So definitely go ahead and check those out. And I'll be pointing some good ones out and right now.

So packages and workflows and things I wanted to-- some packages I've really wanted to highlight and that have helped my day-to-day processes. CivilConnection is unfortunately only available in Revit. But it does allow communication between Civil 3D and Revit and back. This is really more focused on extracting, say, like linear objects, like a corridor model. So you have a retaining wall applied to your corridor model.

You can use CivilConnection to extract that information, bring it into Revit through your structural detail, design, and analysis rebarring whatever you may want to apply to it, and then push that information back into Civil 3D. These last four are available within Civil 3D-- Dynamo for Civil 3D. The Civil3DToolkit leverages a Civil 3D API. So really extends the capabilities of out-of-the-box functionality within Dynamo.

Camber has hundreds of nodes that utilize the AutoCAD and Civil 3D .NET APIs. So not just the Civil 3D objects but also basic AutoCAD geometry. BumbleBee is one that I've used quite often in the past. It communicates between Dynamo and Excel, great for developing custom reports. And then there's AMR Sheet Set Manager, which allows for creation, editing, and customizations as it relates to Sheet Set Manager within the Dynamo environment.

All right, so Property Set Automation with Dynamo. So what does that look like? We talked about ways to automate within Civil 3D. Let's talk about ways we could automate with Dynamo. So if we select the Pipe, we see that there's no property set information assigned to it. So let's pick up Dynamo, open this up, and work through that process of creating a script to assign property sets to our objects using Dynamo.

So about 90% of your scripts are going to start with this document current node. Because we're working in the current document, we need to make sure that we're applying things to that document. So we're tying it back to that. We're also setting this to Automatic so we could see these lists populate automatically on the fly. And we're pulling up our add-ons.

The Civil3DToolkit, which I mentioned, which extends the capabilities, this is a custom installation package that's available. And what we want to do-- like I said, we're going to add property sets to our objects. So we need to understand what that progression looks like. So we're starting with the current document. And then we're going to filter down to the pipe networks. We want to identify all the pipe networks that are in our current document. And then we want to identify the objects within contained within our pipe networks. So we want to get the pipes and structures.

So it's working through that progression, right? You've got to work down to the objects themselves. And on the left side of these nodes, these workflows, that's the output. And the input is on the left side of these nodes. So we're just essentially making connections to develop that workflow. And as you can see since I have automatic set, we see these lists being pre-populated, which shows that we're on a good track. These lists are exactly what we want to see. We want to see all of these filtered down to the pipes and structures, now, the objects themselves.

So now if we leverage the search, we type propertyset. We get a preset list of nodes and workflows that are associated with property sets. We're going to want to add the property set to the object. So we're going to call up that node. And as we hover over these, we get great descriptions. We get some basic information about the inputs and outputs.

We saw that the input for property set definition name is string. String is a manual input that we need to apply. And that's the property set name. So we're going to call this string a U demo because that's the property set that we created already within our file. So we'll just simply type a demo, connect the output to the input of the object add property set. And then we're going to connect the pipes to the object. That is the object that we want to assign these property sets to.

And as you can see down on the bottom, it says Run completed. We get a list of 17 objects here. All the pipes are listed out. So if we jump back into our file and start looking at our pipes, we see all the information. The property assets being assigned to it. So we're obviously on the right track.

So what happens if you want to assign the property set to multiple objects? To do so, we need to generate a combined list. So we use the List.Join node. And we connect the pipes and structures output to that to make one consolidated list, connect that to the input of the object. We'll hit Run, and we see this list number grow to 36 objects.

Jumping back in our file, we'll select some objects just to make sure everything's checking out. We see that that's assigned. We see this pipe is assigned that information. And even the structure now is assigned. But if you see the handle, that's a question mark. And that's because that's the automatic that we assigned to only pipes.

So now pulling up the Style Manager, we'll jump back into our Property Set Definitions, go to the AU Demo. We see the source for Handle. It's just listed as pipe.handle. And we only see Pipe as an option. So we need to add that to the Applies To tab. We need to add the structures to the Applies To because right up here, we're only seeing Pipe.

So if we check the box next to Structure, we see that populated. And now, if we hit Apply and go back to the Definitions tab, click on the ellipsis, we now have the Structure section here. So we'll check the box next to Handle. Under Structure, hit OK, Apply and OK. And now if we select that structure again within our environment within Civil 3D, we see that handle, that object ID being automatically populated, that value.

So that's a quick way to demonstrate how we could leverage Dynamo to assign property sets. And you could do this on a bigger scale. Again, this is very simplistic version-- simplistic workflow that I just reviewed. But if you think about how many objects you may be potentially assigning these things to instead of manually selecting and highlighting and assigning, we could start developing scripts that would automatically generate this and assign an associate all this great metadata-- customized metadata with your objects moving forward.

So what does it look like if we want to extract this information and create an Excel report? Say you want to share this with a project manager or an engineer, you definitely don't want them jumping into your Civil 3D environment if they don't know what they're doing within Civil 3D. So preferred practice is to create a report so they could actually look at this information and then make their updates. And you push it back in. So we'll talk about that workflow using Dynamo to export all the metadata to an Excel report.

So jumping back into Civil 3D, we're going to type stylemanager so we could access the List option, the Multi-Purpose Objects and really just want to start showing you real quick how we can continue to build this out on the fly. And then we'll work on the extraction. So if we expand the multipurpose objects, we get the list definitions. And we have the status of asset. And this is that predefined list that I've already created of values that we could assign to the Manual Property Definition.

So showing you what this looks like, as well, we'll jump over to the Property Set Definitions. We'll create a new property set manual property definition. We'll give it a name, call it Status_Of_Asset just to keep things consistent with the list definitions name itself.

You could start with something that's already created, or you could just start with the default. For now, we're just going to-- it's automatically defaulting to text for the type. We need to change that to List. And then we get some different options over here. For the source, we obviously want to pull up the status of asset list.

And the default, if you know like, 80% of your objects are going to be assigned one specific predetermined value, you could certainly set up some defaults. In this case, we'll just apply Unknown to everything for now. We could certainly overwrite them individually or change that value individually later on down the road in our Civil 3D environment.

But also important to note is that we're not limited to the order in which we create these property definitions either. There is the Order column, which we can reorganize, reshuffle some things around. So if we want that status of asset to show up in the number two spot, we could certainly do that here.

So Status_Of_Asset shows up as number two there if we select the Pipe here in our environment, go to our Properties tab, our Extended Data tab. We see that Status_Of_Asset in the number two spot now. So all these updates that we make in that Style Manager in the Property Set Define are being applied here live within our environment.

So let's pull up Dynamo again and talk through the process of extracting the metadata and creating an Excel report. So let's open up our previously created one, the attached property sets. Let's start there, and we'll work through that progression. So understanding-- well, first off, let's do a Save As. We don't overwrite this.

We'll call this PropertySetsExport. And then we want to go further from these objects. We've already assigned or added the property sets to these objects. So we're just going to delete these for now. And we want to continue to build this out. So thinking about that progression, we've identified the objects within the pipe networks.

Now, we want to extract the properties, the property set data from those objects. So continuing to just work through that progression, we're connecting the pipe object, which we're just going to focus on pipes for now, connect the pipes to the objects for the object property sets. We'll call up the properties of the property set.

And then we're going to call the property name, which in Dynamo, it's called the property name. But in Civil 3D's property definition, don't get too confused. It's just the way they call it, the property Name and then property Value. At least that's consistent.

So we're going to make those connections. So we're identifying building a list of the names and the values. And for the names, when we export this to Excel, we want to have the names listed only once as the column headers. So we need to identify just the unique items. There's a couple of different ways we could do that. We could do the unique items. We could do the first or the last list from the property names. But we obviously don't want status of assets, status of asset in each of the rows.

So we want those as the column headers and then all the values associated with the objects listed within. So what we're going to do is make these connections. We're going to recombine them using that List.Join. So we have all our-- we have our consolidated list of data now. And now we're going to pull up the Excel-- Export to Excel node.

So we'll make a connection, the List.Join to the data. We're going to create a Boolean-- add a Boolean, a True/False statement to the overwrite. So if it actually exists, if this file exists, we want to overwrite it. The starting row and starting column is essentially we want to start in the top left of our Excel. Typical common practice is to do so.

So we'll set that as zero for the integer input. And then the sheet name requires a string. This is our AU demo. We're going to call this AU Demo just to keep things consistent. But essentially, this sheet name is that tab in Excel. And then we need the file path. So making all these connections, pretty straightforward. We're going to define where we want to save it, the file name we want to save it as, and we're going to override it.

So making those connections, and then we're going to click Run. But before we do that, let's clean it up because we just threw a whole bunch of workflow nodes out there. We could select everything and either hit Control-L or go up to the Edit Cleanup node. And it will reorganize, reshuffle things around to make things a little cleaner, crisper, especially if you're going to be sharing it, it's definitely good practice to do so.

And as you can see, this Excel report is created now. It's got all the information. We have our headers. The definition-- the property definitions is the headers and all the values listed within it. So it's great. We've exported this information. We've extracted it from our Civil 3D model. We've exported it to an Excel report. And now we're going to share it with our project manager-- project manager, client, whoever it may be.

So how do we get the updates pushed back into Civil 3D? Let's select one of these objects, check out the properties. And we see that the Manual_PS does not have a value associated with any of these. So let's focus on the Manual_PS first.

For the purposes of this demo, we're going to pretend like we're the project manager now. So in this Manual_PS column, we're going to start typing some values that we want to push back into our environment. So we'll do testing 1, 2, 3, 4, 5, 6, 7, 8. We're going to save it. And that project manager's going to send it back to you for you to incorporate back into your model.

So if we pull up Dynamo again-- I'll review the script in a second, but I want to show you how this works. So if we click Run, we see "Run completed," So let's check things out in our model. So now if we were to select one of these objects, go to the Properties. We see the Manual_PS has a value of 3 tied to the handle 33E.

If we were to pull up that report just to do some quick spot checking just to make sure things are actually being assigned right, we see the Handle, 33E with the Manual_PS value of 3. Let's make sure that's not a fluke. So we'll select one more pipe. We have a handle of 446 with a Manual_PS value of 7, 446 and 7.

So things are checking out. So I think we're good. We're in good shape. So we've now successfully imported our updates back into our model and applied it and associated with those objects. So what does that workflow look like, the Dynamo strip? So before, we were ending with the Excel. Now, we're ending with the update property set. We're starting with the importing Excel. So it's understanding what that workflow looks like.

So we need to first grab the data from the Excel file, which you're seeing right here. We're making all these connections. And as you can see, it's reading column or rows. It's reading by rows. So we need to invert that by using the List Transpose. And we just want to focus on the Manual_PS column right now because that's all we were doing, right? Those are the only values we were going to be focused on.

So this reorganizes the List Transpose from reading horizontal to vertical. And then we want to list just that first item. So we go from 40 items to 10 items. And we're only seeing that Manual_PS column now. Inputs required for updating the properties require strings. It's important to note that the lists are identified as objects within the Dynamo environment.

So we need to convert that, the object to an actual string that can be pushed into the input of our update property. So now we're seeing that list being convert it to a string. And we're using the List.Deconstruct, which gives the first item as one list, and the rest of them, which are the values, that we're going to plug into using the outputs, the first and rest into the property name and property value.

Property Set Name is going to be that AU demo. That's the property that we created from the get go. And that's being tied into the sheet name, as well as the Property Set Name. Then the object is going back to the document current. So we're working on the current document, the PipeNetworks. We're finding the pipes, and we're creating a list, and tying that back into the object. So it's that progression.

So that's it. So now we've successfully updated our property set values for all of our definitions contained within our property sets.

Some additional resources are available online, like I mentioned, right at the beginning of this section. On the right side when you launch Dynamo, you've got some great resources out there. And these are a lot of those. One important resource that I want to point out is the discussion forum. There's a lot of great people in this community, a lot of great people willing to help.

You work through your issues, work through whatever roadblocks you're up against. I know I've gotten here many, many times, definitely check this out, do a quick search because I'm sure somebody is actually experienced whatever you're up against, the roadblock you're up against. But there's a lot of great people out there willing to help.

So it's great. We've got all this great information. We're understanding the value of property sets. We're understanding the ways we could automate some of these workflows so it's not as daunting of a task as it was many years ago. But how can we leverage that data outside of the design environment? So what does this look like outside of that?

Taking a quick high-level look at that data progression timeline, way back when, we started out. 2D plans obviously in early days of CAD, even manual drafting-- hand drafting. We relied on call outs, notes, tables, keynotes, whatever it may be to convey a lot of the information that we're now plugging into our models.