How to Build Effective Assemblies

RUSS NICLOY: This session is called How to Build Effective Assemblies. It's a session that came out of years of working with users and seeing things that could go wrong very easily with people. Just want to get in front of those with people so that they understand how things are supposed to go together, how you can get things to work together, and so forth.

My name is Russ Nicloy. I'm a Civil Solution Specialist at Macer Technologies in Wisconsin. And there is no reason for my face to ever be that large, ever. I actually came from the industry, 10 years of industry experience in JIS survey, engineering drafting, utility work, a little bit of site design. After about 10 years, I switched over to the reseller area. I worked with a reseller out of Wisconsin for 13 years doing support and demonstrations, and things like this, a subject-matter expert, consulting, that type of work.

Just recently I did break away and become my own entity, Macer Technologies, providing CAD services. While I was at the reseller and currently, I am still a consultant member of the Wisconsin DOT's Methods Development Program. I'm working in their training area, so a lot of training videos and working with their users, in particular. So I'm still deeply involved in the transportation industry. But I also do work in the site design, utilities, and several others as well.

So, just what we're going to go through today. First of all, we're to look at why connecting subassemblies is critical. I think this is an important-- it's a basic step but it's a very important step because a lot of users I still run into do not do this correctly and don't realize the trouble it gets them into. I've got an example of one that actually happened, to kind of illuminate why this is such a critical part of how assemblies are going together.

Then we'll look at reuse of design and reusing work. Basically, instead of you don't want to recreate the wheel, you want to use information you've already done. Very often we are going in and doing a lot of data entry on these assemblies and there's really no need to do that. You can reuse the work that's there. Now some of the steps that I'll show you or talk about will seem like, holy cow, that's a lot more steps than I did before. But it's meant for down the road it's going to help out so you don't have as much rework or as much troubleshooting to do. It just saves you time on the downhill slope of your project.

Then we're going to look at techniques for tracking assemblies through a project. Most of the projects in a transportation area, at least, are going to be rather broad, rather lengthy, and a lot of data, a lot of things to keep track of and find. I see people kind of panning and zooming and trying to find things and understand how parts were put together. Heaven forbid, somebody that was working on the big project leaves and takes all the institutional knowledge of what was going on. How can you kind of backtrack and find out where things are?

I personally have a terrible memory, so I have to do that for myself, let alone for somebody else. You get on somebody else's project, how do you find out what they were doing? And then finally, we're going to look at conditional subassemblies. I'm going to look at strengths and weaknesses. Now, my bias is I love conditional subassemblies. But they are not right for every situation. They are things that can help a ton in certain circumstances, but they can also be a complication to a project.

So we're going to look at it warts and all and see what's good and what's bad and where to avoid them and where to focus on them. With that, let's jump into the first section there, the why connecting sub assemblies is critical. And this is only somewhat of a humorous example. This is an actual recreation of one that I ran into with a user. The phone call was, hey, my shoulder is not super elevating with the rest of my road design. And, you know, mind's eye, without seeing the picture there, I thought, well, it's staying at 4% instead of going up into the super elevation area there.

Well, then I got to see the screen and realized that it's not moving at all. The roadway, which looked fine at first, started to super elevate and that shoulder stayed right where it was from the very beginning. Where that comes from is the user did not properly connect the subassembly to the rest of the assembly. This can be very tricky because it's very hard to troubleshoot. You don't know what's gone on. And it can happen without really letting you know until something goes wrong and then you don't know what happened. It's very hard to link back to what caused the problem.

In his case, it was pretty easy. And you know, hey, this isn't connected properly, and so we reconnected it and things went just fine. But while I kind of laugh when I see this picture, it actually happened. This is the kind of thing that you could run into. So what not to do, basically. The way that you connect a subassembly is very important because I'd like to think of them electrically. You want the electrical current to run from one end to the other so that all of that information, the information that each subassembly brings in, is linked up to the assembly.

If they're not linked to the assembly through the different parts that are there, that data gets lost and just doesn't get added in properly, things like OSNAPS. Actually, let me back up a second. My example here is that you would never take two electrical wires and just lay them on top of one another. You might accidentally get current there for a little while, but sure enough, something's going to bump them, and they're going to get loose, and things aren't going to work quite right. We take them, we strap them together, we put a little tape around it and even put that little crimping cap on it to make sure that they stay connected and let that electricity flow through them.

The same idea is true with an assembly. We want to make sure that they're properly connected so that that data can move through unhindered. Now what that means is that we can't use OSNAPS. Now for the base AutoCAD users, I've used AutoCAD way before Civil 3D, back in the 80s even I got my first taste of AutoCAD. We've always used object snaps. Those of you who may venture into the Bently world and into the MicroStation. They use something similar. Its name something different but they've got O snaps as well, or object snaps as well.

The reason is, is you need things to be connected properly. Well, the OSNAPS don't work in the subassembly world, it's not how they're programmed to work. Another tool that the AutoCAD users will have use is move, copy, and mirror. Those commands just don't work in the subassemblies. It's something to do with the programming and all of that data that's underneath. A lot of times we use something that's very data-heavy, but we're using it very lightly, when we connect things correctly and they just work.

Well somebody sat down and really sweated out the programming. Unfortunately, that also means there's some limitations to it. So we can't mirror, copy, or move. That being said, we actually can. There are tools that will allow you to do it, just not the AutoCAD version of these tools. They are Civil 3D specific versions of these tools. And we will be looking at those as we go forward here.

The problem with improperly connected subassembly parts is that they're very difficult to troubleshoot. The image I had before, that was fairly easy, but a lot of times it's just weird things happen, things that you don't expect, surfaces don't get created right. In fact, a lot of things I blame on subassemblies not being connected right, but I can't really prove it. It's just, hey, if you delete that subassembly and put a new one in and snap it correctly on there, how does that work? Oh yeah, it did? That must have been it.

The one thing that is fairly consistent is if you go into the assemblies properties, you will usually not see things in the list of subassemblies that you would normally. A lot of times, assemblies are very right left driven. Their way of, the programmers were able to split things out by separating them by right and left. A lot of times you will only see one side. You won't see the other side in your list, like, well, I clearly have things to the left but they're not in my list, why is that?

Very reasonably, we believe it to be that things were not snapped together properly. They use the AutoCAD mirror command and things didn't go quite the way that they expected. So that's the only fairly consistent one that I can give you. Otherwise, there's just a lot of things that can go wrong, like that super elevation didn't work, or the subassembly, the point codes weren't involved in your assembly, something along those lines.

So with that being said, let's jump over and take a look at an example of that. In my lower left-hand corner there I've got some assemblies. And this one here looks fantastic, right? I mean everything looks decent. But I can tell you that it's hiding underneath here. The ones on the-- I believe it's the ones on the left here-- were not connected correctly. If I go to the assembly properties, I can show you that example in the construction tab. Yeah, I've got some to the right but none to the left. I clearly have ones to the left there.

The problem is that I literally didn't move and do all the things that other users have done to try and break this and make it not work and it came out that way. Now, we might get lucky and have the corridor look correct for a portion of it. But again, some other things might not work as we go forward here. So those are things that we want to fix. I'm going to cancel out of that and show you what this looks like when things are working properly.

This assembly is connected correctly, up to this point. I've got a couple of lanes. I'm going to open up my subassemblies here and grab a shoulder and drop that shoulder in. I going to come in here-- and I want to be very, very clear-- I'm zooming way in for a very good reason. There's a lot of really close data in here. So you want to make sure that you grab the right point code or the right code that you're connecting to. And make sure you grab somewhere out here, not near where it's overlapping.

Because of draw order concerns, a lot of times that circle is actually behind the lane information there, even though, visibly, it looks in front. And you're actually snapping to the lane, instead of that circle. And that might jump at the other locations as well. So you just want to be careful where on that circle you snap. It's worth zooming in and making sure you make a decent connection here. So I'm just going to left click right there. And there is our shoulder assembly.

Now notice I've got a shoulder to the left, but nothing to the right. The only reason I say that is because I'm going to jump into the properties here, so you can see, the left side now has not only lane, but a shoulder as well. So that's what we want it to look like. And keep in mind too, that another thing about assemblies is they are very right and left oriented. Things that you connect to the right, all the things will understand there to the right. There are things that you might want to do flipped over, like a split road design or a Boulevard design, where you've got a right hand set of subassembly, lanes and shoulders, and so forth.

So even though we're on the right group, we want something to go to the left hand side. You'll even get little warnings that say, hey, are you sure you want to do that? And a lot of times, yeah, we do. We're making a choice. It's actually very difficult to run into a situation where that's the case. But just keep that in mind, that if you are on the right hand side of an assembly you might want something that's set to the left, going the opposite direction.

Let me switch back over here. Let's look at the reuse and design instead of-- so that you can reduce work. Like I said, this may include a couple of extra clicks or maybe some extra typing, but down the road it actually is going to help solve issues and prevent you from having a lot of work to do. So this is where we're going to talk about the copy to, move to, and mirror that are in the subassembly tools themselves. There's a lot of things that-- you know, you've got a piece of pavement that has certain depths, or certain widths, certain slopes. Why recreate that every time? Why type that information in to the seven or eight different assemblies that you're using, or 30 or 40 assemblies depending on the size of your project?

If you've got the same type of information, just copy that from one assembly to the next so you skip over all that work. Now using the copy to, you know, that clears you from a whole bunch of problems here because that is meant to be used with the way the programs, the lanes, and shoulders, and so forth are program. So that's perfectly fine to do.

I do want to call out the mirror command, specifically. And in fact, I don't think the AutoCAD mirror command works anymore. Last time I tried it it actually wouldn't do anything. So you're kind of protected there. But the subassembly mirror command does have a little bit of a gotcha, what it is, is it is basically taking the subassembly that you're working with, copies it over to the location, and then flips the side. If you go into the subassembly properties-- if you've got a side, a field for it-- it actually has right or left. It actually just switches that field for you.

The gotcha is that if you have super elevation or some other right side or, you know, side oriented option, it may not switch that over. In fact, in case of super elevation, it doesn't. I've got a left hand shoulder that I'm super elevating. I'm super elevating to the left, outside shoulder of my table. If I flip it over, if I use mirror, the side is now saying to the right but the super elevation still says the left from the last, from the other side. So make sure that if you're mirroring parts or mirroring subassembly parts, that you are double checking that and that you're not leaving things out.

A lot of times I'll end up with a road that's a v instead of a proper super elevation because I didn't double check that out. So keep that in mind. Now, I've been talking a little bit about subassemblies here, we can also copy assemblies. There's really no reason-- if most of your assembly is being used somewhere else, just copy the whole thing down and then go in and tweak the parts that are different. A lot of times I'm using assemblies that, you know, maybe at the beginning of my project this assembly is also being used in this area over here, the exact same measurements, I just copy that whole thing over. Then if you need to, you can tweak it up a little bit.

I do mention on my slide here that, rename by stationing. This is something that I've learned through [INAUDIBLE]. [INAUDIBLE], I don't want to say it's a standard, but it is something that they recommend, is that they have their users, if you're using an exact copy of an assembly, you copy it down and name it by the station range that you're using it in. The reason is twofold. First of all, for navigation, you can find what you're working on very quickly. Hey, we've got a problem here, that's this assembly. The stations are in the name so we can find it very easily.

The other side of it is, what if you make a tweak change to something later on in the project? Well, if I'm using the exact same assembly-- not a copy, but the exact same assembly-- I tweak it here. I'm also tweaking it back here or wherever else it's being used. If you have individual copies of it then you kind of prevent that from being an issue, and from weird, little tweaks being propagated throughout a project where you didn't intend. Some of this is just about avoiding troubleshooting and avoiding getting into trouble. So that's one of the things that you can do to do that.

Another one that I want to talk about is-- and this, I don't see this a lot. And it's something that I use to get away with having one region where I would need two or three. And that is the placing a lane of zero width when I need when I know that I need to grow a lane out, either in a ramp, or sometimes just a turn lane-- my example later will be a turn lane-- I want that lane in there, but I don't want to see it until the very moment that that lane starts to pull away. I'm a big believer in start things a little early, kind of swing through the pitch, don't just start right where the design needs to happen, because then you get kind of weird escarpments and weird things happen.

So I like to start a little bit ahead of time. And if I have a zero lane in there, I've got a lane and a shoulder, and then I can have that shoulder grow out as my target moves away, as I diverge from my main part of the assembly. So hiding a lane in there is one of the ways that you can get away with that. The one trick to that is making sure that people understand that it's there. Because it's not visible, it's hard to tell that the others, there's something in there hiding. Generally, you can backtrack a little through the corridor, but it can be a little bit difficult to find if you're jumping on a project where someone has done that.

So let's go in and take a look at the reuse of some of this. I've got some assemblies here that I'm going to use for my intersection area here. I'm not going to build a whole intersection, that would take you most of the hour, probably. But what I've got here is an assembly up here at the top. What I did was I copied it down and got rid of the shoulders for the through lane, that's the area that's moving through the intersection but doesn't have any curbing gutter or a shoulder on either side. That's the through part of the intersection.

I also copied it down here for what's happening after the road. I have the same measurements, the same materials, the same widths and so forth, same kind of targets. So I just copy the whole assembly down at the bottom there and have that doing that work. Now I'm going to go in and take a look at what I named these. This first assembly is-- and hopefully everybody can see. I'll just zoom in so I'll make sure. I call it main road because this is the main part of my design.

And then I've got the stationing, from 00 or the beginning of my project, two station, two plus 36. I actually measured out where the curb return end was. And that's where this assembly is going to end. It's going to end at 236, now it was 236.35. But I'm not going to get too crazy about it. This is just to let everybody know, hey, in this neighborhood here, we're ending that assembly.

I did the same type of thing for the through lane where it's 236 to 341. So I can tell you right now my intersection is going from 236 to 341. And so I could just pick it up there. And again, users can pop in here and see it immediately. If I have another intersection down the road, I have another through lane that's there and they can search for that one and know to tweak that one instead of this one.

I did not do anything for the day right, day left, I didn't name them. But these are in that what I call the sliver area, where the main road and the through lane-- there's a little section in there where the curb and gutter on the north and the south don't line up quite right, so there's that little sliver area. That's what this one is. All I did was say that this is day left or day right, or some kind of indication for a user so they know what that assembly is doing and what its intent is. Logical names go a very long way. And that's not just about assemblies and subassemblies, I'm talking alignments, and surfaces, and everything. But this is a case where a logical name, for targeting purposes, can really help your users or yourself.

I have one down here, that's my right turn. I zoom in here, you can see that I've got a lane that's going from the curb return up-- or the edge of the shoulder here-- up to crown, and then a shoulder on the outside. The name of that one is right turn. Didn't have to get too fancy with that because I intend to use that right turn assembly in all four quadrants on my right turn, and maybe the three quadrants of my T intersection further down the road, that type of thing. So one assembly is doing the work of lots of them. And again, you might want to copy it off and say, hey, that's the right turn for this particular area, and not others.

And finally this assembly here, I cheated a little with this one and said this is 341 to the end. I didn't have to get too fancy with it because it's just the last assembly that we have here. But something's come up, some little tweak changes happened. So I'm going to grab this last one. I'm going to use the AutoCAD copy, just select on the assembly, right click, basic modified tools copy-- or however you want to do the AutoCAD copy, there's lots of different ways-- I left click and drop that down here. And now on this one, go in that assembly properties, instead of 341, I know that my split is going to be at 5 plus 00.

That's to end and this one-- make sure that I name this. One of the things that I'm a big believer in is stopping and doing the renaming of things as you're doing it. Because nothing is worse than as you're making those changes, you get a phone call or email, somebody stops by your cube and pulls you away from what you're doing, you forget to do it. And then later in the project, like, oh, holy cow, where am I? Which one is this for? That's the kind of thing that it's worth stopping and setting that as soon as you possibly can.

I did want to add in here, I've got this assembly here that I'm actually going to use for our intersection area up there. I'm going to grab a shoulder and stick that in here. Actually, before I do the shoulder I'm going to put in my zero length lane. I want to show an example of that, and again, some of the gotchas that can happen here. Now this feels weird to me. I'm about to copy this lane, because it's the same material, same dimensions and so forth.

I'll come up here to copy two. I'm going to copy it to itself, works just fine. Not a problem there, at least nothing that we found. Notice that it's a zero width lane, but I'm leaving it full width right now, just for the time being. Because I need to attach other things to this and it's very difficult to do if it's zero, if I set it to zero. You might set it to 0.01, I think everybody knows or hopefully you've all run into it at some point, where you put in a zero dimension for something and it gives you the red circle-- and we call it the red slash.

A lot of times it can't figure out a zero measurement. So if you can't do a zero, 0.01 is pretty good. It's as thin as you can get without actually have it go over. So our zero lane has some width right now. I'm going to grab my shoulder and attach that. And now with that in place, I'll select that middle assembly. I'll go to some assembly properties. I'm going to rename this right now. Again, no time like the present. Every time that I ran through this in practice, I forgot to do it, and like, holy cow, which one am I looking at, what am I targeting and so forth.

So this is a ramp lane rt. I try to keep my name short so that they show up and dialog boxes. You know, you've probably run into this where the dialog boxes aren't long enough so you can't see the end of it. The important information up front and then try and keep it as short as possible, short nicknames are a good idea. I'm going to go into the parameters and tell the width to be zero. And I think that's all I need to do there.

I might need to do a super elevation. But there, the lane is in there. It's just kind of stuck in the middle and hidden there. So we will be using that later, but that's what that looks like. If I go into the assembly properties, I still have it listed there. The ramp laying right is right in the middle, right where we put it. The assembly properties, the listing here, is incredibly important. In fact, in the next section, or the conditional subassemblies that we get into, you'll see that it starts at the top and kind of works its way down. And that's important so make sure that you keep track of that.

I've got enough there that I'm going to come back and-- we will use that. I will remind you when I use it. I'll use a targeting situation there in the next section that we look at. So let's look at some techniques for tracking assemblies throughout the project. One of the things I think that gets overlooked a lot is that in the prospector, you have a zoom to option for most objects. In fact, in the way statement there I say this isn't just for assemblies, alignments, especially short alignments. Long alignments you zoom to the whole extent of the alignment-- well, it's the whole projects so that didn't really help.

But a side road, you get a nice short little one, or maybe a curb return alignment. You can zoom to those very, very quickly and find that information without having to pan and zoom through a whole bunch of stuff, takes you right to where you're going. For terms of what we're talking about today, though, the assembly, this is a great way to jump over to a specific assembly. I've looked at transportation projects that had 30, or tens, or maybe even dozens of assemblies for different reasons, in different areas.

People always seem to try and section them off in nice, easy to find ways. And that's great, I want to encourage that kind of behavior. But as I'm looking for something specific, especially if I've used or the user has put in the stationing of an assembly, I can zoom right to that one and not have an issue. Now, there's a real possibility that things are named similar enough that you might zoom to the wrong one, but at least you're kind of in the area. If the names are similar enough then they might be next to each other. So just something that you can use to get around, especially if you've named the assemblies properly.

Now, I also did talk about naming the assemblies, and I did touch on naming the subassemblies. Naming subassemblies, in particular, is incredibly important, especially as we get into the targeting mode of our corridor. If you've got 13 different lanes and they're all named lane, that's not going to help you much. You can count it down and hopefully get the right one. I can't tell you how many times I've counted down said, hey, there's only four, I can figure this out. And I grabbed the wrong one and now my middle lane is targeted back this direction. And things aren't working the way that you intended.

So naming the subassembly names, something unique. Assemblies have to have a unique name. In fact, when you copy them, you may see that there's a little, parenthetical number that pops up at the end, little counter that keeps it unique. I mean, you can have the same exact name with that parenthetical number. Subassemblies can have un-unique or non-unique names. And that can be a challenge because then everything looks the same. You want to have some kind of division out there. So I recommend some sort of unique naming.

You'll see that I don't practice what I preach, I have a lot of lane rights out there. If it's just a regular lane, not a big deal. But my ramp lane, the one that you saw me go to zero with, that when I wanted to make sure that that was very specific, because for targeting, that I know is going to be a targeting issue. And we'll go after that. So like I said, it'll help with troubleshooting. A lot of what I'm talking about is just preventing problems from occurring in the first place. Troubleshooting is one of the hardest things that we have to do because we have to reverse engineer something that, well, it makes sense to us, why is this not working?

Computers are logical to a fault. And they do exactly as they're told, not what the user wants them to do. So you've got to make sure that you kind of backtrack yourself and make sure that troubleshooting can be done easily. I also call out the new users on a project. That's something that you can't bypass either. You get somebody whose-- maybe they know Civil 3D well, but they don't know your way of using Civil 3D. Having very defined way of naming and naming conventions, and so forth, can really help them acclimate to a project and be able to go around and move inside of it much more quickly than if they just get tossed a project with kind of a wild west.

So let's go in and take a look at-- in fact, I'm zoomed in at kind of a weird angle here. I have this bottom window active. I'm just going to come over to the prospector assemblies drop down there and then zoom over to our five to end. And there you see I still have the parenthetical, too, because I forgot to take that out. I'll just right click and zoom to. And that zooms over to that assembly, so a lot easier than having to pan, and zoom, and look at things that look very similar. I can find them by name very quickly in that list.

Now as I do that-- in fact, I think I've already named this one-- I'll go into the subassembly here. And yeah, I named this one lane to crown left, so it's the left hand lane of my right turn assembly so I can find that more easily. And again, for targeting purposes, when we get to the targeting you'll see those names pop up and I'll be able to identify things quickly. So I didn't really have a whole lot to show there, so much as just to make sure that you know where the zoom to option is if you've never used it.

So let's look at the conditional subassembly, strengths and weaknesses. Like I said, I'm biased towards conditional subassemblies. I may use them more often than I should, in fact. A lot of times they aren't needed but I'll throw them in. This may be an example of overuse. I recently saw an example of this where it was not. The user was very adept at it and they were very easily able to navigate around. He has a mind like a computer so, I gave him that.

It actually is to represent one of the first conditional subassembly uses that I ever saw. It was on a highway project in Wisconsin. And the conditional subassemblies were a brand new tool. This guy was all fired up and started throwing things in. In fact, this is about a third of what he actually had. I'd have to zoom out so far you couldn't see it, so I thought I'd just carve it down a little bit. The problem was-- and this was a support call-- he called in and said, hey, I can't see things that are in my conditional subassemblies. The problem is that any of the paths that you take away from the main lanes in the center there, if you say yes to one, it shuts everything else off and only looks at that branch.

So pick your favorite subassembly on the outside edges there, and then backtrack and say, well, if I don't have that condition, I don't get this condition and I don't get this thing. There's a lot of targeting that goes on with these. And you kind of have to-- this is, basically, it's programming. These are if-then statements. If this happens, give me this.

Real quick introduction to the conditional sub assemblies, if you're not familiar with them. You'll see that they're big, long lines. It looks like a big butterfly at this point. Those lines are not geometric to your project. They are if-then statements. Those are just labeling so you know what you've got. As it turns out, the styles that I have-- and I think they're out of the box. I don't think I change this. The ones to the top, you see they have curb and gutter going to them? Those are the not found conditions.

So I've got a line out here that is-- and I'm going to do some driveway work, just kind of showing you where this is going-- driveway work. I don't want curb and gutter inside the driveway. So I've got a line just for the driveway area. The curb and gutter is not found, I'm not found, I'm not found, I've got curb and gutter up to this point, oh, now I'm found. I no longer have curb and gutter. I now switch over to where I have one of the driveway aprons, that's the next lane that's attached there.

So the idea is that those conditional subassemblies are looking for their condition. And if that condition is met, whatever is linked to it will then zip over and properly connect-- and again, going back to the first topic-- properly connect to the rest of your assembly. So that's the how and the why of what's going on there. Now let's talk about some strengths and weaknesses. The first strength that-- oh, actually let me talk one thing-- a case for why I love conditional self assembly so much. The first time I ever saw it used in an actual project-- I mean, I'd knocked around with it a little bit, testing, I think everybody does that when a new tool comes out, tested out a little bit.

A company in South Dakota was building a one-mile stretch of road, so not very long, just a one-mile stretch of road. And the only thing unique about it was it had 13 driveways, you know, right, left, north, and south of the main line. And they said, hey, the conditional sub assemblies, could that help with this? Because right now we have 34 regions for these 13 driveways. They have the curb and gutter on both sides, and then the driveway to the north, and a curb and gutter to the south, and then went back to curb and gutter on both sides. And then it did the driveway to the south and curb and gutter on the north.

The real one was when they had two driveways that overlapped like this. So they've got curb and gutter on both sides. They've got driveway on one side, driveway on both sides, driveway on this side, and then back to normal. So for 13 driveways they had 34 regions. And not that you can't do that, but that's a lot of manipulation and a lot of navigating through a project that you shouldn't have to do, or wouldn't have to do. They did it with one assembly, with the conditional subassemblies.

And it was very, very simple. It wasn't that big, battleship looking thing that I showed before, it was a not found and a found condition on both sides. And that's all they needed. They were able to get through it with one and easily maintain and manage that project with that kind of setup. I was a believer from that moment on. Then I saw the big, butterfly thing where they were all over the place. And like, OK, well, there is a limit here, we've got to kind of back this off.

So the first strength that I want to point out here is that you can replace multiple regions and assemblies with one if you properly structure them. You can also have more than one found condition. Now, this is important. I mean, not found is what it is. I didn't see anything. But found, I could say, well, like I have a park lane. I recently saw a project where there was a park lane going through. And you know how sometimes they'll just widen the road and paint stripes and that's the parking area? Well, as they went along, they had a couple wide areas there. And then they got up to the big circle where the education building was and they wanted some pathing in there.

So they put different lines in for targets. They had one line that was the parking area line. Then another one for the pathway line. And as it went through the found condition looked and said, oh, that's the parking area, we need to do this. And it got up here and said, oh, that's the path, we need to do this other thing. So it's nice, and there again, one assembly could do multiple things throughout the project. They didn't have to manage a whole bunch of other work.

Now, that being said, let's go to some of the weaknesses. The conditionals can get you into some complex targeting issues. In particular, you've got to give targets to all of those things, all of those items. So you do have to kind of baby sit them through the initial phases. I think the downside of that is much better than the long term. But if you put too many of them in, then managing a whole bunch of other stuff besides what you're doing in your project. So you want to kind of keep it short just for your own sake and sanity.

The other thing is-- and this, I have a hard time with this, logically, because you can't prove a negative statement. You can't prove a negative statement. A negative statement is the absence of something. But you do have to target found and not found conditions. I have told people this. I'm sitting next to them and I've told them this, and they still don't target the not found condition. I let them do it so we can show them what happens. And I'll show you guys so you don't have to go through that yourselves.

The problem being, is that if it doesn't have a not found, it's going to put both conditions in that spot. Now you can-- and again, this gets complicated-- you don't necessarily need a not found condition at all, you know, and that's a topic for another day. But if you've got a not found condition, you want something to happen when it doesn't see it, you have to target what it's not seeing. It sounds silly to even say out loud, but that's the case. I will make sure to show what that looks like as we go forward here.

The last one there is both strength and weakness, or maybe neither. It's not a strength nor weakness, it just is. Conditional targets are triggers, not geometric locations-- not necessarily geometric locations, maybe I should say. I've got an example in the demonstration where the driveway line that I'm targeting is not right up where the driveway is, as I pull it way back so that you can see it. And I don't geometrically target it. What it's doing is it's going along, it says, oh, I see that target over there, I need to do this. But it doesn't say that I need to do this out there, it just needs to do whatever you're doing.

So you can have these targets way away from the main body of what you're doing and have them still work. It's more about lining up with your alignment stations than it is anything else. And again, I will show that so that if it doesn't make sense from what I'm describing, you'll see it in vivid color and hopefully that will help explain some things. In fact, let's jump over to that right now. Like I said, I'm going to build the main line of an intersection through here.

You'll notice, first of all, remember when I put in that zero width lane here? That's for this line, up here. This alignment here is going to target that. If I highlight there, you see that I've got a little bit where it overlaps the original location there. Like I said, I like to swing through the pitch. I don't just like to start right at the station. I've seen too many things go wrong in that half a foot or three inches that I want to avoid. So I like to throw in a little example there. And then it'll widen. So that's something that's coming.

Now, more along the lines of what we were just talking about, here's that driveway where the line is off to the side. I brought it out here mainly because I have other lines in line with this. I like to put the driveway line either at the beginning, or the front, or the back of the sidewalk so I can use them as a geometric target. But the one that's kind of hanging out there that I moved to the south, I'm intentionally not going to use that at first so you can see what it looks like first, and then I'll add in the target and make it look better.