Building Reusable Subassemblies

ERIC CYLWIK: Anyways, my name is Eric Cylwik, and I am a virtual construction engineer at Sundt Construction. How many people are familiar with Sundt or have heard the name before? Not many? A few of you guys. Okay, so some of the content that I'm going to be showing today I've shown before, but we'll cover that stuff briefly. And I must say I'm really excited to be here and just to see how many people have showed up and signed up for this class. The last time I did a class on subassemblies I think there was maybe 30 or 40 people. And so it seems like the concept is growing within the civil 3D user base, and it's really great to see. I think there's a lot of power behind those tools. And I'm talking about some of that power today.

So the class is titled-- Building reusable subassemblies-- and the whole idea behind this is creating, in this case, a single subassembly that allows you to go in and engineer your project. And it removes a lot of overhead associated with managing subassembly libraries and managing how all of your assemblies come together. So there's a lot of downstream benefits, and it reduces a lot of QA/QC that might go into building a subassembly library and then tweaking things from project to project.

I've noticed that when I go in and try to do something really detailed and hammer out a specific problem, I end up having to remake that for literally every single project. And since I'm a construction company, I work for multiple owners, right? And so even a TxDOT project will look just a little different than the past one. And so then I have to go in and rebuild the subassembly and tweak it a little bit and make it meet that project's needs.

And so we've really started to look at ways to take those subassemblies and make them parametric and completely flexible that allow us to reuse them on more and more projects. The goal ultimately being able to create content that's easy, quick, and ultimately brings the value that we need it to bring.

So today we're going to be talking about how to create a custom subassembly. In this particular case, we're going to be focusing on what I'll call a quadrilateral four-sided shape. A lot of the concepts that I'll be talking about today were actually created by a guy that works in our virtual construction department. And he is by trade a mathematician, so he thinks about things a little bit differently than I would like to think about them. But they're very different ways to solve a problem. They're almost formulaic in the way that he thinks about creating these models and maybe the most efficient way to do so.

So we'll be creating that quadrilateral as well as one other subassembly. We'll talk about how to properly handle subassembly targets, utilize input and output parameters, and weeded throughout this hour is going to be how does parametrize the subassemblies for reuse. So I'm going to start off talking a little bit about Sundt's background and how we got to where we are.

We are a construction company, which is quite odd that a construction company is using civil 3D and creating corridors of design content. I don't know too many other out there that are doing that particular approach. We're going to then create the custom subassemblies. We're going to talk about input and output parameters, targets, and ultimately again show how those are re-used. So based on the audience in here, I'm thinking that's probably about nap time, and I think that's it will look like in here in about 30 minutes. So Sundt's VDC background-- and this is a picture of a project that Sundt worked on in the Dallas-fort Worth area, and it was a really unique project. And we'll dive into that and why I chose this particular picture here in just a second.

But the Sundt's venture down this idea started in 2007. Our CEO went to an AGC conference and saw somebody present on BIM. And it was clash detection, right? What the commercial and vertical guys love, like, Oh, that's so cool. We got all this crap that we're trying to fit into the ceiling. Well, infrastructure is very different, right?

And so in between 2007 and 2010, we really figured out on our commercial and vertical sides, how to use that technology and where it was beneficial for us to use it. And then in 2010, they said, OK, we're going to take one of those guys and put them in Heavy Civil. And whether that group wants them or not, they're going to be there. And their job is to figure out how to make this technology work. And as Sundt started to do that, we really started to focus on taking those concepts of building information modeling on the vertical side and making them apply on the civil side, where are areas that we can identify where we're doing a lot of data re-entry or areas where we can create content once and use it throughout the entire life of the project.

And then in 2011, we started to get involved with Federal Highway Works Every Day Counts initiatives. How many people are familiar with those? A few of you guys. So there's actually some really, really great content out there from the Federal Highway Works Administration here in the US, and it's a program called Every Day Counts. And they select specific technology-focused initiatives. And they really create a lot of training content. They'll create template libraries. They'll raise awareness about it.

But one of their focuses for the past two Every Day Counts rounds has been 3D modeling, or what they're terming 3D models, in Engineered 3D Models for Construction. And the idea is they want to look at, holistically, how a data model can be used on a infrastructure site throughout the life of that structure, so from early design all the way through demolition. And they have a whole bunch of webinars that you can stream at any point in time. I'd highly recommend those. And Sundt was involved with those as well as some of the regional presentations. And it seemed to be quite a way to kind of generate some attention and drum up some noise about this topic.

So here's an example of one of Sundt's projects. This is from 2011, I believe. And this is the Sellwood Bridge in Portland, Oregon. Is anyone here from the Oregon area? One guy. What's that?

AUDIENCE: I work right under that bridge.

ERIC CYLWIK: Oh, it's a beautiful bridge, huh? So this bridge has a crazy background. When the last time they went around and rated the structural integrity of all the bridges in the US, they gave it a scale of 0 to 100-- 0 being your bridge's falling over at the moment, 100 being your bridge is brand new and perfect and well-suited for its environments. And when they rated this bridge, it received 2 out of 100.

There were spots on this bridge where there was a pedestrian walkway underneath, and they literally had metal band-aids on the bridge holding the concrete together. This bridge was failing immediately, and it was because they built it in the mid-1920s. And soon after, they realized that there was a landslide on the west bank, and so the entire life of the bridge the thing had been crunching. And so it was to the point where it's failing. They limited the gross vehicle weight to 10,000 pounds. And so if you had a heart attack on the other side of the river, and there was an ambulance right across this bridge, they had to go about four miles in either direction.

And on top of that, the people in Portland, for whatever reason, love their bridges. And I don't know if this is a thing. I'm from Arizona, so we don't really know what water is or what bridges to do. Maybe it's just because I'm from there, and I don't have a love for bridges. But in Portland, they have a crazy bookstore called Powell's Books, and they love that store. And in that store, they have a shirt with all the bridges from Portland on it. And it's like, wow, you guys love your bridges.

And one of those bridges on there is the Sellwood Bridge. And so this bridge is an iconic structure for them, and they know they needed to replace it. But it's also the only way to cross the bridge within a few miles. So Sundt, they actually won an alternative project delivery method called CMGC, where that's a qualifications-based process for the contractor.

So some put together a bid, and we did a whole bunch of homework. We actually went out and paid a subcontractor to create a 3D laser scan of the area, created a point cloud, and then from that we modeled the existing structures-- over here in the red and some of these colored objects, the point cloud in this image on the left is in white and black over there on the right. But it allowed us to sit in our office in Phoenix, Arizona and come up with a construction plan that we knew would work because we knew the exact spatial dimensions that they sat out there while we were planning the work. So when it came time to propose this to the owner, we created a semi-photorealistic environment on top of that point cloud and then use that to express our construction intent.

So if the superintendent was talking about, well, we're going to take your bridge that was built in the mid-1920s. We know it got a 2 out of 100 on its last rating. But we're actually going to disconnected from its substructure, and we're just going to move it. That way we can build a new bridge. We think that's a lot easier. It'll save a lot of time. And if you have somebody talking about that who's from Arizona, you're going to think, this guy's an idiot. He's never seen a bridge before in his life. You can't move a bridge like that.

So we put together this environment in an animation. And we're going to build a new approach bridge over here. This is the west side where the landslide is actually happening. We're going to build a new approach bridge, and then we install some temporary shoring and then a translation beam. And we actually disconnected the entire 1100 foot long steel structure from its supports and then moved it 30-60 feet to the north. And then we created this animation that pauses shows traffic phasing at every single major phase of the project and how they were going to move through that.

And ultimately, after we were selected for this project, the project manager narrated a version of this, and it ended up on YouTube. So that way all the residents can be aware of what's going on in their neighborhood. And this was huge for the owner. And this was huge for Sundt. The ability to get in and use technology like this and explore options and validate qualitatively and quantitatively what we wanted to do with this process was huge. And so it went over really well. And they started to say, well, maybe this BIM stuff is actually pretty good for Heavy Civil environments.

And so we started to dive deeper into the technology. And we're at the point now where we're trying to figure out how to solve some more specific engineering tasks. We've discovered pretty early on it's great at solving these macro concepts of, well, how are we going to move this bridge? But some of the more specific things, that's where it gets really tricky.

So that was the pre-visualization of the bridge slide. And this is the actual time-lapse of the bridge slide. It only took 8 hours to move 60 feet. So we presented it on that in about January of 2011, and I think the bridge slide happened in about January of 2012. I believe. It was a pretty cool day and a great project to be able to explore this kind of technology in this kind of use.

Then from there, we started to explore. Well, now that we've got this kind of technology, what can we do with Civil 3D? This is a highway project. We have a whole bunch of roadway structures, started to go in and make some utilities to see what that look like. We started to make some parametric MSE walls, which was the class that I had previously presented on subassembly composer. And we started to get in and do all of these things-- started to pull out information for automated machine guidance, started to review some design documents this way, and really started to look at some of the detailed questions that we run into during construction and use the technology to solve those answers.

Another early example that we got into is the original picture that I had up here, where there is some arches on a bridge. And this is a peeled back version of that. We have the concrete here. It's very transparent.

But the structure of this arch was designed to be an extremely long span and to be pre-cast about half a mile away from the actual location where this arch was going to land. And so it was a pre-cast post-tension network arch bridge, and to the knowledge of the engineer, I believe this was the first of its kind anywhere in the world. And it was a really unique structure. And it was a hard bid project.

So Sundt really needed to ensure that we weren't over extending our risk-taking by saying we could actually build this structure. It's not like we go to a historical cost database that we have and figure out what our production rate for this kind of an arch is, right? And so we went in and created and modeled every single bit of rebar in there, every single embed, and all the post-tensioning as well. And so this model that we're looking at is a mash up of Revit, Civil 3D, and then we're looking at it Navisworks, and some other components as well.

But it really allowed us to get in and say, well, instead of having an S1 stir up from point A to point B, they had S1, S2, S3, S4, all the way up S25. And oh, by the way, S5 is rotated 4.76 v I mean, this stuff was so exact and so precise because it needed to be in organic shape and be able to span this huge river that they had in the middle. And as a result of this design in the engineering, they needed no false work for this entire bridge, would cast the columns in place and then essentially just set the arches on those.

And so as much as I would like to say we thought we would bend everything on this project to reduce our risk, we didn't think about bending this guy. So about a week after these arches open, they're 163 feet long, about 45 feet tall, and they're 4 and 1/2 feet thick. And this BMX daredevil guy got up there and rode the arches, which was definitely not something that we had built into the model. So we weren't able to analyze his risk and build in proper contingency.

So you can kind of see the river down here. I think the river is about 100 feet wide. And it's probably up in the air about 160 feet here. So as much as I will say that we like to use technology to the fullest, we still don't capture everything. So don't let me misguide you here. If you guys Google 7th Street Bridge BMX, you can watch this full video, and there is definitely some police action at the end.

Anyway, so getting into the meat and potatoes of this class, we are going to start to go in and build a custom subassembly. And one thing that I will note before we really get into this is class was marked as intermediate, and so my kind of expectation of the audience is that you guys have at least opened up some assembly composer, you're familiar with how to use it, what the Workflow Designer looks like, and some of the parts and pieces. So I'm not necessarily going to explain every single step, but I will king of go through things.

And if you guys have a specific question or missed something, I am happy to answer questions as I'm presenting. Although it seems like you guys have to have believed everything that I've told you so far. So I think we're off on a good start. So let me open up subassembly composer. Any questions so far?

AUDIENCE: What software did you use for the animation?

ERIC CYLWIK: For the BMX?

AUDIENCE: The animation you showed of the phasing from the bridge?

ERIC CYLWIK: So the first phasing where we showed the traffic and stuff? So the question was, what software did you use for the Sellwood Bridge phasing animation? And that was a weird mash up 3D Studio Max for some of the structure and site components, Revit Structure for some of the bridge components, Civil 3D for some of the roadway, and then Navisworks for the actual time-- for the portion of it, and that was link to a P6 schedule that P&M and created. So it ends here.

OK, perfect. And then some of the arrows and stuff were put on afterwards in After Effects Those components are a little bit tricky and not very 3D friendly. Any other questions? Perfect, we'll get rolling.

So the first thing we're going to do is create this quadrilateral shape. And again, it's a really basic way to create a four-sided object that can respond to different parameters. So we'll call this AU Quad Basic to start with. So I'm just naming the subassembly on the packet settings tab, and I'm going to change its default value to write. I have had issues if I don't give it a default value on the side parameter. Sometimes I have some issues downstream with that.

So I'm going to go through and create all my parameters first. I would like to say that this is the ideal workflow, but obviously, you don't know how many parameters you're going to need sometimes until you get into it. But in this case, I cheated and built a shape already. So we're going to call this one top slope. And one thing that I will note as well is, one of the bugs in some assembly composer, if you name an input parameter or an output parameter and then later change its type to something else, it does rename it. So soon as I click off of slope, it renamed it the parameter 7. So as you guys are working on this kind of content, please note that will happen.

So we want a top slope. We're going to need a top width for this quadrilateral. And we're going to need an inside height. And I will explain inside vs outside and all that fun stuff in just a second. This guy is going to be a slope.

So I'm just creating all the different parameters that we're going to need in order to make this one shape truly parametric. An outside slope, and then we're also going to need a bottom slope.

One other thing you'll learn is never delete parameters unless you've saved it recently. Subassembly composer does crash quite often when you're deleting a parameter. So I'm going to add a sequence to my workflow flowchart here. I'm going to open it and start to add points. I'm going to add also two more parameters over here I'm going to change in the string.

One thing that I found extremely beneficial is to always create string parameters for any codes that you're going to pass to shape links or points. If you hard code it, they are extremely difficult to remove, and you end up having to mess around with a lot of your styles in Civil 3D. So I always make a parameter so that way if I don't want the shape code to show for some reason, I can just change the parameter in Civil 3D live and have it as a no-display.

So I'm also going to do a points code, a links code, and then a shape code. For the points code, we're just going to call it basic for right now. The links code will be pave. And the shape code will be pave. We're going to change the top width to 12 feet, the average width of a lane here in the US. And the inside height, we're going to change it to 0.5 feet.

So this 0.1 in this point code's field, I'm going to type in points code. So that way I have the ability to again change that point code later live in Civil 3D. For this point, too, I'm going to change it to a slope and delta X, so that way it's going to start from 0.1 and go the width of I've identified as top width. And then we're going to change the-- we want this top one as top slope for the slope, and then for the delta X we're going to do top width.

After that I'm going to hit fit-to-screen. And what did I do here? Top slope, I'm going to change this to a negative 2%. As well as the bottom slope, I'm going change to a negative 2%.

So now we have 0.1 and then 0.2 is delta X of what I've entered for the top width, and the slope is being driven by that top slope parameter. I'm going to add another point, and this time I'm going to choose slope and delta Y. And I'm going to go from 0.1. And for this I'm going to go for inside slope. And then the delta Y is going to be the negative of the inside height value. I'm going to change this inside slope to negative as well.

And for whatever reason, on this inside slope, I've noticed that sometimes if you have a 0-1 slope entered and you have a negative value in your inside height, sometimes Civil 3D throws an error, saying that they both need to either be positive or negative. So if you change your inside slope to a positive value-- I just entered one-- and then you change it back to zero, it clears that error. So I don't know exactly why or specifically when, sometimes that works sometimes it doesn't.

So I just change that to a 1, and then I'm going to change it back to his 0. So that way we have a completely vertical face on the inside. And then I'm going to add the intersection point as the 0.4. And again, I'm going to give this points code for the code. And I'm going to do that for the other ones that I forgot here.

And then this one is going to be intersection 2 points in slope. And so I'm going to say start from 0.2 and then go at a slope that I've identified in the parameters, or the user has identified in the parameters as outside slope. And then I'm going to say start the other intersection line from 0.3 and go at a slope of bottom slope. And then here, we need to tell it to extend slope 1, slope 2, and then reverse slope 1. And so now it's started to create 0.4, which is the intersection of this 0.3 and 0.2 at those slopes.

And so I will say right now, if you guys are completely lost and have no idea what I'm doing in subassembly composer, I would encourage you to spend a little more time in there. But I would also encourage you after this class-- they are recording this. And there are some classes in previous years by, I believe her last name is pronounced Mercer, Katy Mercer, as well as Peter Funk on some of the more basic functions of subassembly composer and exactly how to use these features that I'm using. And they start off with a much more basic example of how to get into that. And again, since we had this class marked as intermediate, I'm assuming that everybody had some sort of familiarity with it. But there is a way to kind of catch up and watch some other free content from AU. So now we have those four points in there. If I go in and I change the top slope from a negative 2% percent or a negative 50 and we'll say positive 2%, 0.2 updates. And then 0.4 stays the same. But then if I go in and I change the outside slope from zero to one to one to one, you can see that those points are kind of responding respectively to those parameters.

So I'm going to go in now and start to add links. And a lot of people will use the automatic link creation. When you add a new point, there's an option to automatically add a link to the previous one. Once you get into some of the more complicated subassemblies, it's a much better approach due to some kind of buggy-ness in the corridor modeling if your links are all connected from start to finish, if that makes sense.

So if you have a closed shape in Subassembly Composer and it's an advanced shape, you will want to start and either work clockwise or counterclockwise all the way around your points. So I tend not to use the automatic link creation because of that fact. Once something crosses the base line, for example, it'll explode and be a lot more obtrusive in your viewport if you don't follow that method. Yeah--

AUDIENCE: Is that just for the links, or also for the points?

ERIC CYLWIK: So the question is, is that just for the links or also the points? And that is just for the links. There's really nothing you can do when you cross the base line and the actual feature lines kind of scatter a little bit. But you can complicate it when it's following a link across the center line by having them in a non-linear order.

So I'm going to go in and add these links now. And I'm going to again put in the link codes area. I'm going to call that parameter Links Code. And I'm going to start out at 0.1, go 0.2. My next link is going to go from 0.2 to 0.4. And I'm going to give it that proper code-- and from 0.4 to point 0.3, and then from 0.3 to 0.1, and Links Code.

And then I'm going to add the shape in here. And I'm going to give you the code of Shape Code. And I'm going to add the four links.

And so now we have this quadrilateral, again, a really mathematical way to approach a four-sided shape. And as we get in, we can start to mess around with some of these parameters and say, switch this back to a negative 2%. Or we can change what we're calling the inside height from 0.5 to 2. And that shape expands.

Let me make this a little bit larger here. As far as some of these names that we've started to use, the point of origin is always going to be what we call the top inside point. The top link extending outward from there is going to be your top, which contains the top slope and the top width.

And then after that, this down to 0.4, that 0.4 is determined again by the outside slope, which is the far outside of that subassembly and then also the bottom slope. And that bottom slope is labeled as such. And then the inside, that is controlled by the inside height as well as the inside slope.

So if you think about this, we have top. Top is top. Outside is the furthest point away from the origin. The inside is the closest point to the origin of the subassembly.

And we can go in and mess around with any of those. So if we want to have an inside slope of one or even three as well, it would start to kind of do that and respond to that. So it's a really great way to get in and make a pretty parametric part kind of quickly off the bat.

So I'm going to save this. And then we're going to import it into Civil 3D. So I'm jumping over to Civil 3D 2016.

And I'm just in a brand new drawing. I'm going to make a new assembly. And for the code set style, I'm going to make sure it's all codes. And I'm going to place that assembly.

I'm going to make a new pallet over here on the tool palette. How many people are familiar with this to a pallet on the left? All right, perfect-- just wanted to make sure before I get into this and start pressing buttons around here.

So we'll call this one Class. And I'm going to import that subassembly. Yes, based on the name of those other folders, it did take me to test runs to figure out exactly how to make this not crash during the demo. And now that I've said that, it's probably going to crash.

So one thing that I've found really helpful is as soon as I import something into the tool palette, I usually right click on it and hit Refresh. Because until you hit that Refresh and actually have it generate that image, it doesn't pull in that packet file and import it. So as soon as you hit that Refresh button, it runs through that process. And if you going to have issues placing your subassembly, it'll actually notify you then through the Event Viewer.

So now I'm going to place this subassembly. And I'm going to place it four times for a roadway section that is a TxDOT favorite. So this first one, I'm going to call this AC01 the first lift of AC. I'm going to leave the shape code as Pave. I'm going to change the inside height from 0.5 to two inches. And I'm going to change the outside slope to zero.

And so again, this is four copies of that same subassembly that we just created. And on this one, I'm going to change the shape code to Pave1. And you'll see that shape code update in real time. I'm going to change that outside slope to zero. And I'm going to change the inside height to four inches, giving us a total AC thickness of six inches and two lifts.

I'm going to click on this third one down. I'm going to call the shape code Base. And again, that color will update live in the view port. The outside slope I'm going to leave at a one to one. I'm going to change the inside height to one and a quarter foot. And for the top width, we're going to make it 12.5.

And so one thing that's in the standard that this is kind of typical assembly is based on is that from the top right outside corner of the AC, they'd project an imaginary slope down at a one to one to figure out where the top of this flex base material is. So that's why I have an extra 0.5 width on this particular material.

And then again, that outside slope is one to one, which is perfect for this particular material. And this bottom one, we're going to call Sub-base. And I am going to change the inside height to 0.5, which is perfect.

And now since we don't have the full on version of the subassemblies yet, the easiest way to figure this out is to measure the total width of this bottom layer, which is 13.7755.

AUDIENCE: [INAUDIBLE].

ERIC CYLWIK: What was that? Oh.

AUDIENCE: You [INAUDIBLE].

ERIC CYLWIK: Oh, yeah. I was going just for the x there. And then I'm going to change the outside slope to zero. And so now with a single subassembly, we have something that looks pretty parametric from the viewport, right?

And Civil 3D does have some components built into it that have similar behavior to this, right? This will be a little bit more flexible than that. But what we're going to start to do now is explore this idea of what makes these much more usable and can make them much more usable than what's stock inside Civil 3D.

And so to give you some examples of how we've used them at Sundt, this is the project that kind of inspired this particular subassembly and again, was created by Ryan Haines, the individual that was modeling this project.

And so this is the full width of the subassembly up here. This is for an airfield project. And it's about 230 feet wide, I believe. And then over here on the left side, we have an under drain that's going to run along the runway.

But everything in this one subassembly is that same quadrilateral that we are building right now. And then to look at, again, these are all that same subassembly. So the mathematician created a single problem that solves everything. So kind of that theory of everything, right, that movie-- this is what that subassembly's hope was to accomplish, right?

And so you can kind of see where he used multiple versions or multiple instances of the subassembly where you had a material that had just a little extra width for whatever reason. So he'd go in and have this stick out just a little bit. And then he has these three instances of that same subassembly to help answer some of these questions as far as what that shape looks like.

So if you start to think about subassemblies as kind of a tangram approach, it sometimes takes a little bit longer to build the assembly the first time. But troubleshooting after that is a million times easier, right? We now have one subassembly that drives literally everything on this project for the proposed content.

AUDIENCE: So for something this complicated, there would be so many subassemblies, you must keep very good track of the name of them.

ERIC CYLWIK: The actual names in the property? Yes, absolutely. Yeah. So he has a very clear name of, you know, this is the GCABC Part One, this is the GCABC Part Two, and that kind of stuff.

And that, we'll also kind of hound in on that a little bit later. Because one of the things that's really great about these is these sections are all parametric. So if he changes a slope up at the top, this whole thing raises with it. And the widths will change. And he's constrained it by some of these outside slopes. So he's got a lot of information automatically built into this.

And so how many people are familiar with subassembly targets? I'll come back to you in just a second. Is anybody not familiar with subassembly targets? OK, so one, or two, or 10 people. All right, this guy had a quick question, though. Sorry.

AUDIENCE: If you've got different subassemblies but they have the same color and the same reaction, does that mean that's the same material?

ERIC CYLWIK: So yeah, these ones will represent that same material, in this case what's called a--

AUDIENCE: But those are multiple subassemblies to represent that same material.

ERIC CYLWIK: Absolutely. And that's a huge advantage as to why I never hard code codes, hard wire codes into the subassembly shapes. Because I did that really early on. And then my standards changed, and I went to update them. And I kept on having these white, solid shapes where my subassemblies were.

And I was like, what the heck? I don't have any styles in here for this. I duh-duh-duh. And then I went back into the Subassembly Composer. File and opened it. And I had manually typed in engineer fill. And there was no shape code style for engineered fill, so it just dropped a white box in there.

And so because of this, he uses that same subassembly and then in that Properties window, just changes the name of the code.

AUDIENCE: So when you calculate quantities with this, will it group all the same material together? Or does it give you a different volume for each one of the subassemblies?

ERIC CYLWIK: So the question was, if we ran a quantity report on this, would it group all of the same subassembly shape codes together and spit out a single report, or would it generate reports per subassembly? And the answer is per material. So it would automatically group all those things together and spit out--

AUDIENCE: So it knows it's the same material.

ERIC CYLWIK: Correct-- it doesn't know it's the same material. And then it also allows you to do a lot more flexible things with your styles and the way things are displayed. Any other questions so far? Perfect.

So then some assembly targets are the idea-- I had this really cool video that I'm going to show in just a second. But before that, I want to preface this. I don't know if you guys know Angel Espinoza. He's been around the Civil 3D community for a long time, very brilliant guy.

And I was telling him about this cool video. And he was like, yeah, I saw that. And he was like, well, when I explain that concept, I just take a bungee cord. He's like, and if you think about a subassembly target, it's kind of like taking a bungee cord.

And so we identified a width of 12 for our width of this lane. And he said, if you think about it, you can tell the bungee cord it's normally 12. But you can stretch it horizontally, and it makes it larger. Or you can shrink it, and it kind of curls up on itself. And then you can also would manually override the elevation. And so the idea of targets is that you can have a standard, and then it can deviate from that standard when it's fed that information.

And so this is a video of a recent research project where they're calling it face mapping. So we have a guy who's up here talking or making facial gestures. And then you have a guy down here. And they're using a Microsoft Kinect to build a 3D model. And they're projecting his motion onto this guy's 3D model. So even though he's not talking, it looks like he is, right?

And so my idea behind this is that even though you have a subassembly that is a perfect square, you can override it so that maybe that shoulder changes its slope as it approaches an intersection. You can do that. You can take one thing and kind of make it look like the other if you feed it the right information.

So we're going to go back into the demo now. We're going to add those target override potentials into our subassembly. So this is that same subassembly we were just in. And this next part is actually pretty easy.

So we're going to go to the Target Parameters tab in Subassembly Composer. And before I do that, I'm going to go into the packet settings and give this a new name. Call this one Targets, and save it as a new subassembly.

And then I'm going to go to the Target Parameters tab. And I'm going to make two targets. One of them is going to be an elevation, and one of them is going to be an offset.

And as soon as I do that, you'll notice that in the preview window, there are now these little things that if you click and drag on them, you can move them. And it also updates the preview value down here. So I'm going to name them Quad Elevations. That way I kind of what target I'm looking at. And then also this one's going to be Quad Offset.

And so right now they're not linked up to any of my geometry. So the offset can do whatever it wants. But the geometry is not going to respect that.

So what I'm going to do is I'm going to go to 0.2. And one approach-- so as much parametrics as I would like to build into this, you have to lock it down at some point so that way there's some sort of consistency.

And so we decided that the only target you would be able to use would be the top outside corner. So that way you would kind of drive that top slope. And then you can kind of-- there's some other features you could build into this to kind of drive the bottom slope as well.

But we stuck with that top outside slope. So we're going to specify that the 0.2, which is again a slope and delta x option-- we're going to change the offset target, which overrides the delta x to this Quad Offset parameter that I just created. And then immediately underneath that, we're going to tell it that the elevation can be overridden by the Quad Elevation.

So now as I come in and move this Quad Offset, that lane width automatically changes. And the distance where that P4 is, technically the elevation of P4 is changing slightly here. And as I come in and start to move around the Quad Elevation, you see how the shape starts to distort. And it respects those things that we've told it to do and also kind of keeps all of that stuff in line.

And as somebody pointed out earlier, this is always going to be able to generate quantities, pull out automated machine guidance services, and all that kind of fun stuff as well. So I'm going to make these look a little bit more close to what we had it looking like earlier. And then I'm going to save this again. And then we're going to jump over to Civil.

And in the same file, I'm going to make a new assembly. And I am going to import that new subassembly that I created. And I'm going to tell it to refresh the image. And then I'm going to run through really quick and rebuild it to make it look like exactly the previous assembly that we had built.

AUDIENCE: The refresh image thing, is that new in 2016?

ERIC CYLWIK: No, that's in the least all versions since 2013 that I know of. Mhm. So again, I'm going to call this first top one AC01. And I'm going to give it the outside slope of zero to one. And I'm going to change the shape. The shape code's find at Pave. And I'm going to change it to two inches.

This guy, I'm going to change it to Pave1 for the shape code. The inside height, I'm going to tell it four inches, yielding a total height of six inches on this AC. The outside slope is a zero to one.

And then this guy, I'm going to make this a base. Outside slope, leave it at one to one. I'm going to change this 12.5. And for the height, I'm going to change it to 1.25.

And then this is going to be sub-base. And the top width was 13.7755. And then we're going to go outside slope of zero.

And so now we have that same subassembly. But what we're going to do now is I'm going to create a sample alignment. And we are going to show how that target allows you to flex things.

I create my profile view, so that way you can create a profile to actually be able to create a corridor. OK, and then I'm also going to add some offset alignments to this. So I'm going to say a 12 foot offset on each side. And then I am also going to come in and add an area where there's a linear transition that overrides what the default width is for this particular case.

So then we have the roadway. And these white lines are going to represent where that 12 foot, which is the default width of this particular assembly. And then where it's overridden here, that should extend out for a bus lane or what have you. And then it's going to come back in.