Design roadway assemblies

00:04

In the previous segment, we created roadway alignments and profiles for a theoretical roadway project.

00:10

In this session, we'll get into the assemblies and briefly look at the subassembly composer.

00:16

For this project, we have about five typical sections that we want to model.

00:20

To begin with, we'll choose the Assembly function in the Home tab and provide the name, a few display settings,

00:28

and choose where we want to build our assembly on our screen.

00:32

When creating an assembly, it's best to bring up the Properties window and the Subassemblies window.

00:36

For this roadway, we want to create a separated median.

00:40

Using the advanced parameters, we can determine the width of the median, the slope, and the pavement details.

00:47

Next, we can add our lanes.

00:49

Now, we will calculate super elevation.

00:51

We need to choose LaneSuperelevationAOR for our lanes.

00:56

Once we provide the lane parameters, we can add as many lanes as we need to.

01:01

Now, in this case, we will add two lanes in each direction.

01:05

One detail that we want to do here is to give each lane a unique name.

01:10

This will be very beneficial when we create the corridor model.

01:14

And so, we'll call these lanes RT Lane 1 and RT Lane 2.

01:20

Then, we can add the shoulder to match the design width and match the pavement section of the lanes.

01:28

Finally, we'll add a daylight condition.

01:32

For the cut condition, we want to add a ditch.

01:34

So, in the properties, we can specify the slope and size of the ditch section.

01:41

So, we'll have a small roadside ditch when we are in cut, and we'll use the default parameters for the fill condition.

01:48

For the other side of the assembly, we want to add the same lane configuration we've just set up.

01:53

We’ll do this by selecting the assemblies that we’ve already created and use the mirror command.

01:59

Then, we'll select the point where the mirrored subassemblies will be inserted.

02:02

This just helps to save us time, since we've already defined these elements.

02:06

We will give the lanes on the left side a unique name as well.

02:11

Now, this assembly looks to be ready.

02:14

Previously, we created offset alignments and profiles for this area where we have turn lanes that overlap the center alignment.

02:23

We also have a raised medium that we want to model.

02:26

The offset alignments are placed where we want them in planned view.

02:29

So, let's go to the assembly now.

02:31

We set up the lanes and the curb similar to the previous section, but there are a few key elements that we want to consider.

02:38

The target will be based on the offset alignment, and we want a similar section for the other side of the roadway.

02:46

We'll need to be able to target the northbound side of the road as well.

02:50

We’ll do this by using a link offset and elevation assembly.

02:56

This will allow us to find the alignment and profile of the other alignment in the corridor.

03:01

And so, we'll set the value at –20, and this is so it will go to the left side, then place the line.

03:09

Then, we can mirror all the subassembly elements to the other side, based on the northbound alignment point.

03:17

Next, we want to draw a line connecting the top of the curves, and since this line will be variable,

03:23

we need to create a point that will connect these two elements.

03:26

We create a markpoint, and we'll call it Median.

03:30

Then, we add an element called LinktoMarkPoint.

03:33

Here, we can just identify the point that we are connecting to.

03:37

In this case, it was a point called Median.

03:40

One last thing we need to consider is the turn lane.

03:43

We can see in plan view that the lane is variable in width.

03:47

We want to be able to use an alignment or polyline to control the width of the lane.

03:52

In the assembly, we want to use a median lane in place of the inside lane.

03:58

So, we can choose LaneFromTaperedMedian1, then choose Replace in the command line.

04:04

Then, we choose the lane we want to replace.

04:07

The standard lanes are identified with the markers, so we can see that this assembly has been updated.

04:14

We’ll do the same thing on the other side.

04:17

Once again, we'll provide names for these lanes to make it easier when we create the corridor.

04:25

We've created additional assemblies for the other alignments, based on their typical sections.

04:30

In this assembly, we've actually included retaining walls.

04:34

These elements work well both in cut and in fill conditions.

04:39

Then, we would create any other assemblies for any other types of typical sections that we have in our project.

04:46

In the next part of the video, we'll take a look at the subassembly composer.

04:50

This allows us to create a custom subassembly based on our specific project needs.

04:55

In this case, we want to create a monolithic lane and curb that are connected.

05:01

The subassembly composer is comprised of points, links and shapes,

05:05

and we can drag and drop these items into a workflow space to determine the draw order.

05:12

We can also specify the relationship of each point with each other, and it can be based on offset values, slopes and distances.

05:19

When the relationship is identified between points, a link is automatically created.

05:26

A shape can also be created for any closed areas that are drawn with the composer.

05:33

The subassemblies can be drawn with hard-coded values so that when they're placed, the subassembly is always the same shape.

05:40

They can also be drawn with variable values that can be modified in the Properties menus by the user.

05:51

Subassemblies can also be drawn to target alignments or profiles,

05:55

then we can test the subassembly by modifying the target points and see how it reacts.

06:02

It looks to be in good order in this case.

06:05

The variable values give us greater flexibility in our design.

06:10

We can also assign materials to the shapes, and this gives us better control when we define our subassembly.

06:19

Once the subassembly is complete, we can save the item so that we can import it into our drawing.

06:25

Here, we want to add that monolithic lane and curb to the assembly that we just created.

06:31

We can right-click on our subassembly window to add a tab to the library, provide a name, then we can import our new subassembly.

06:45

We'll copy another assembly and then remove some of the elements that we can add our custom parts.

06:51

Now, since we've created several variable values, we can define those before placing it, but those look to be in pretty good order.

06:59

So, we'll place it as we previously defined.

07:02

That looks to be in pretty good shape.

07:04

Now, we can actually copy elements from another assembly and add it to this one.

07:09

Here, we want to add the sidewalk and the daylight subassemblies.

07:12

So, we'll select the assemblies that we want, select, copy, and then define the insertion point.

07:20

We can do the same thing on the other side by removing the unwanted points and mirroring the monolithic lane, curb and sidewalk.

07:29

However, when we insert that part, we can see that it didn't come in quite the way that we wanted.

07:35

So here, we'll select the custom subassembly and change the values so that it reflects the left side of our assembly marker.

07:44

Now we need to provide negative input values.

07:47

Then, we'll do the same thing with the curve as well.

07:51

We can view our final results.

07:54

This gives us an overview of setting up assemblies and subassemblies.

07:59

There are some very powerful elements that can really help define our project the way that we need to.