User’s Guide

Subassembly Studio
User’s Guide

Table of Contents

User Interface

General

The main application window is designed to feel familiar to AutoCAD and AutoCAD Civil 3D users. It consists of several components that have similar counterparts in the AutoCAD/AutoCAD Civil 3D user interface, including

Project Explorer

Properties Explorer

Command Line

Command History

Status Bar

Tool Tray

Viewport

Toolbars

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML412cc364.PNG

Project Explorer

The Project Explorer window contains a hierarchical view of the subassemblies in the current Subassembly Catalog Project file. You can use it to switch the active subassembly (by clicking on the subassembly name, or on any of its child items). When a subassembly is selected, it is automatically viewed in the Viewport, and the camera is zoomed to the extents of the graphics. Selecting an item in the Project Explorer causes the Property Explorer to show the item’s available properties. Context menus are available for the items displayed in this window.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML412d6d68.PNG

If a selected object contains a detectable error, such as a missing required property value, you will be shown a glyph next to the header of the object(s) containing the error(s). The errors will also be shown in a tooltip window if you let the cursor hover over an item with an error.

If the keyboard focus gets stuck in the Project Explorer, press the escape key to return focus to the Command Line.

Property Explorer

The Property Explorer shows the available properties for the item currently selected in the Project Explorer. Changes made in this window are immediately reflected in both the Project Explorer and the Viewport.

If the keyboard focus gets stuck in the Property Explorer, press the escape key to return focus to the Command Line.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML3cbc89f.PNG

Command Line

The command line works very much like the AutoCAD/AutoCAD Civil 3D command line. It allows you to type commands rather than use the menus/context menus. The command line also provides a mechanism for responding to prompts when running a command that does not have a user interface.

Pressing the space bar or enter key will execute the command or commit the prompt response you have typed.

Pressing the escape key will cancel a command or command stack.

Commands are not case sensitive.

Commands are echoed to the Command History, as are notification messages, prompt messages, and responses to prompts.

System commands are prefixed with a backslash character ( \ ). Some useful system commands include:

  • \ClearHistory Clears the Command History window
  • \ResetViewport Resets the viewport to its default coordinates/zoom scale.
  • \ResetLabels Resets all subassembly component labels to the default state. There is no ‘undo’ for this operation.
  • \Activate Deactivates the current license and triggers reactivation

There is a Command Line Button control located to the immediate right of the command line:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML412f2754.PNG

If you click on this button, the ListCommands command will be invoked, which will cause the List Commands dialog to be shown:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML3d01a76.PNG

In this dialog, you can see all available commands, including all aliases, and if desired, you can invoke the command directly. The List Commands dialog only shows non-system commands.

Note that certain commands are only valid when certain data is selected.

Viewport

The Viewport is where the graphical elements representing your custom subassemblies are drawn. When a graphical element is selected by clicking in the Viewport, that item is automatically selected in the Project Explorer, and its properties are shown in the Property Explorer (if applicable). Right-clicking in the viewport will bring up a context menu for the Subassembly Catalog, or, if you right-click on a graphic element, an appropriate context menu will be shown allowing you to interact with the targeted object.

Navigation in the viewport is simple:

  • Panning: Press and hold down either the center mouse button (or both the left and right mouse buttons) and simply drag the mouse in the direction you want to move your model. Panning is accelerated, so the model will appear to move faster than the cursor.
  • Zoom: The mouse wheel zooms in and out, centered on the cursor. Move the wheel forward to zoom in, and move it backward to zoom out. Press and hold the LEFT CONTROL button on your keyboard while operating your mouse wheel to zoom at an accelerated rate; simultaneously press and hold the LEFT CONTROL and the LEFT SHIFT buttons while operating the mouse wheel to zoom at a decelerated rate.

If you have a 3D mouse from 3DConnexion (such as their SpacePilot®), you can also use it for panning and/or zooming. Using it is as simple as plugging it in and configuring the axis inversions, etc. as desired using the driver utility/configuration application shipped with the hardware. Pan and zoom operations are supported; rotate operations are currently disabled in Subassembly Studio.

Menus and Toolbars

Application menus

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML3d36da4.PNG

File: The File menu contains commands for saving/loading, creating new, and for exporting Subassembly Catalog Projects. It also includes a command for closing the application.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML3d420bd.PNG

Catalog: The Catalog menu contains commands for creating new subassemblies, importing subassemblies from other Subassembly Catalog Projects, modifying the Codes, XRecord Keys, and Enumerations defined in the current Subassembly Catalog Project.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4825b12.PNG

Subassembly: The Subassembly menu contains commands for copying, modifying, and removing subassemblies in your Subassembly Catalog Project. Subassembly modification may include adding, removing, or resetting Logical or Geometric Components, or modifying Variables and/or Parameters. If no subassembly is active, these commands will do nothing if invoked.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4857c09.PNG

View: The View menu contains commands for manipulating the camera/viewport:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4896de6.PNG

Tools: The Tools menu contains ‘tool’ or utility commands that allow you to list available commands, export an image of the subassembly, export a ‘help file’ template (which serves as a starting point for creating a help file for the active subassembly), deactivate or activate your license, and re-enable the startup window if you had previously disabled it.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML49f13e5.PNG

Help: The Help menu contains commands that access the help documentation and product information, including licensing information (via the About command):

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4a1439c.PNG

Toolbars

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML41341ba1.PNG

File: The File toolbar contains the following command icons:

D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\NewCatalog.png New Catalog D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\Open.png Open Catalog D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\Save.png Save D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\SaveAs.png Save As… D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\ExportCatalog.png Export Catalog

Project: The Project toolbar contains the following command icons:

D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\NewSubassembly2.png New Subassembly D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\DeleteSubassembly.png Delete Subassembly D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\CopySubassembly.png Copy Subassembly

D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\ResetSubassemblyGeometry.png Reset Geometry D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\EditParameters.png Edit Parameters D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\EditVariables.png Edit Variables

D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\EditCodeList.png Edit Code List D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\EditXRecordKeyList.png Edit XRecord Keys D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\NewPointComponent.png Add Point/Complex

D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\NewLinkComponent.png Add Link Geometry D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\NewShapeComponent.png Add Shape Geometry D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\NewLogicalFlowComponent.png Add Logical Component

D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\EditGeometryProperties.png Edit Selected Geom. D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\EditLabels.png Edit Labels D:\UserDataRepository\Documents\Expression\Expression Design\SaSIcons\SaSIcons_files\EditAllLabels.png Edit All Labels

View: The View toolbar contains the following command icons:

Zoom Extents Regen

Context Menus – Main UI

Subassembly Catalog: The Subassembly Catalog Context Menu is accessed by right-clicking on the Subassembly Catalog item in the Project Explorer.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4adfc8f.PNG

Active Subassembly: The Active Subassembly Context Menu is accessed by right-clicking in an empty region of the Viewport, or by right-clicking on the Active Subassembly in the Project Explorer.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4ae797b.PNG

Subassembly Geometry: The Subassembly Geometry Context Menu is accessed by right-clicking on the Geometry item for the Active Subassembly in the Project Explorer.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4af2257.PNG

Edit Geometry: The Edit Geometry Context Menu is accessed either by right-clicking on the Geometry Component items for the Active Subassembly in the Project Explorer, or by right-clicking on the graphics elements in the Viewport. For Origin components, you will only be given an option to Edit both the origin component and its labels – you cannot delete the Origin component. For other Geometric and/or Logical Component types, you will see both an Edit and a Delete option.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4af8618.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4b16df7.PNG

 

Edit Variables: The EditVariables Context Menu is accessed by right-clicking on the Internal Variables item for the Active Subassembly in the Project Explorer.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4b2bb1c.PNG

 

Edit Parameters: The EditParameters Context Menu is accessed by right-clicking on the Subassembly Parameters item for the Active Subassembly in the Project Explorer.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4b2322f.PNG

Dialogs

New Subassembly

The new subassembly dialog appears whenever you invoke the NewSubassembly command. In this dialog, you must enter a subassembly name that is unique to the current catalog project and conforms to the Subassembly Naming Conventions. The description field is optional. You will be able to modify this information at any time using the Property Explorer. The Include In Catalog option will modify the subassembly property of the same name (accessible in the Property Explorer when the subassembly is selected in the Project Explorer).

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML413676ab.PNG

Edit Codes

The Edit Codes dialog is used to create and maintain a list of standard codes, shared between your subassembly points, links, and shapes. It is shown when you invoke the EditCodes command, and from within certain other dialogs. You are in no way restricted to using just the standard codes in your codes list. The codes list is simply provided as a means of quickly adding standard codes to your subassembly components while avoiding typographical errors.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4b7be57.PNG

Edit Subassembly Parameters

The Edit Subassembly Parameters dialog is shown when the EditSubassemblyParameters command is invoked. This dialog allows you to create and maintain the parameters that are shown in AutoCAD Civil 3D when your subassembly is inserted or modified in a DWG.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4bc4293.PNG

Subassembly parameters may be classified as Input Parameters, Output Parameters, Target, Auto Target, Multi-Target, or Auto Multi-Target Parameters.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4b9cedb.PNG

Input Parameters are shown to the AutoCAD Civil 3D user any time they access the subassembly properties. These are generally used to enable the user to provide input to determine the size, shape, and behavior of your subassembly. These parameters may be used in either layout mode or as the corridor model is being built (‘design’ mode). Input parameter definitions must include a data type specification to let Subassembly Studio and AutoCAD Civil 3D know what sort of data will be held by that parameter. The data type of a parameter is used when determining which parameters might be appropriate selections to map to a Geometric or Logical Component property.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4bd44b5.PNG

Output Parameters are used to enable a subassembly to return data for use by other subassemblies (as input). You can create Output Parameters for Point offset, elevation, and code properties. You can also create an Output Parameter for slope (calculated between a point and its reference point), or any other information you need to return when the subassembly finishes executing. Like Input Parameters, Output Parameters also have a data type property that must be set properly.

Target Parameters are used to allow the AutoCAD Civil 3D user to target objects such as alignments, profiles, and surfaces in the Civil 3D model in order to determine the offset or elevation of the object or to determine an intersection with the object. These parameters are only shown to the Civil 3D user via the Civil 3D Corridor Properties dialog, and are applied as the corridor is being built (they are never applied in layout mode). Unlike Input and Output Parameters, Target Parameters do not have a data type property. Instead, there is a ParamLogicalNameType property which must be set to specify the type of object that will be targeted. This setting is used when determining which target parameters might be appropriate selections to map to a Geometric or Logical Component ‘target’ property

Auto Target Parameters are used to allow AutoCAD Civil 3D to automatically target objects such as alignments, profiles, and surfaces in the AutoCAD Civil 3D model in order to determine the offset or elevation of the object or to determine an intersection with the object. These parameters are not shown to the AutoCAD Civil 3D user via the AutoCAD Civil 3D Corridor Properties dialog; instead they are evaluated automatically and applied as the corridor is being built (they are never applied in layout mode). A TargetProperty and a MatchPattern field are used to form a query condition, which is used to determine whether an object is a potential match. The first matched object found is used. Offset Targets must be alignments (unless the ParamLogicalNameType property is set to OffsetTargetPipe, in which case pipe objects will be selected instead); profile objects must be defined for the current baseline. Feature lines, polylines, etc are not currently supported for Auto-Targets. The MatchPattern field should be a Regular Expression defining the pattern to be matched (e.g. all alphanumeric values comprising at least one character would be “.+”) and may be mapped to a string input parameter to allow the user to modify the match pattern when inserting the subassembly in AutoCAD Civil 3D.

Multi-Target Parameters are used to allow the AutoCAD Civil 3D user to target multiple objects of the same type such as alignments, profiles, and surfaces in the AutoCAD Civil 3D model in order to determine the offset or elevation of the object or to determine an intersection with the object. These parameters are only shown to the AutoCAD Civil 3D user via the AutoCAD Civil 3D Corridor Properties dialog, and are applied as the corridor is being built (these are never applied in layout mode). These parameters require a static value for the number of targets to be presented to the user in AutoCAD Civil 3D. The individual target parameters created in AutoCAD Civil 3D are named using an alphanumeric prefix and a numeric suffix (e.g. Offset0, Offset1, etc.). You may specify Base-0 or Base-1 numbering for the suffix (via the Base1 Property). In Subassembly Studio, these parameters are manipulated as a single entity containing a collection of individual target parameters. The individual targets can be referenced using an index in any property field expecting a regular target parameter, or, in certain new geometric/logical components, the entire collection of targets is referenced at once (no index is specified). Note that the Base1 property only applies to the name displayed in AutoCAD Civil 3D during target mapping; regardless of the value of this property, the individual targets may only be referenced inside Subassembly Studio using Base-0 indexing (the first item is number ‘0’, the second ‘1’, and so forth).

Auto Multi-Target Parameters are multi-target parameters where the individual targets are found automatically, just as with the single entity ‘Auto Target Parameters’, and follow all of the same rules as the single entity version except that ALL matching targets are returned (up to the maximum number of targets, which you specify).

Select Pre-defined Parameter

Clicking in the Name field in the parameter properties will cause a button labeled with an ellipses (“…”) to appear on the right side of the field. Click on this button to invoke the Select Pre-defined Parameter dialog.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4cba6c2.PNG

The Select Pre-defined Parameter dialog allows you to choose a parameter configuration from a list of pre-defined parameters. The selected configuration is used to populate the settings of the actual parameter you are editing (i.e. the name, description, data type, and default value are all set from the pre-defined configuration).

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4ca244b.PNG

Right-clicking on an entry in this list will open a context menu which will allow you to remove the selected item from the list:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4cb2592.PNG

To add a new item to the pre-defined parameters list, simply right-click on the header for the parameter in the Edit Subassembly Parameters dialog:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4d062a2.PNG

Edit Internal Variables

The Edit Internal Variables dialog is shown when the EditInternalVariables command is invoked. Internal Variables work just like subassembly parameters, except that they are not exposed to the AutoCAD Civil 3D user. Instead, they are used internally to store the results of calculations, etc. Internal Variables may also be used to specify a value in one location and reference it from several subassembly components (e.g. you might want to hard-code the ‘default slope’ and not allow the user to change this, but reference the value in several locations in the subassembly) – this way, if you need to change the value, you only have to change it in one location in order to update the entire subassembly model. Internal Variables are restricted to be Input Parameters only.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4ce835b.PNG

Just like in the Edit Subassembly Parameters dialog, clicking in the Name field in the variable properties will cause a button labeled with an ellipses (“…”) to appear on the right side of the field. Click on this button to invoke the Select Pre-defined Parameter dialog.

Subassembly – Add/Edit Geometry

The Subassembly- Add/Edit Geometry dialog is shown when the following commands are invoked:

  • AddPoint
  • AddLink
  • AddShape
  • AddFlow[1]
  • EditGeometry

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML26d9b64f.PNG

This dialog allows you to configure the properties of the Geometric or Logical Component you are adding/editing. You are able to switch component types when alternate component types are available (within the context of the Geometry Component Category for which the command was invoked – e.g. if you are adding/editing a ‘point/complex’ geometry component, you will be able to change the component type to any other ‘point/complex’ geometry component type, but you will not be able to change it to a Link, Shape, or Logical Component).

Some properties are read-only and cannot be edited. These are set by the application and are shown for informational purposes. Read-only properties are shown as disabled, or gray items in the property grid.

Several properties may be assigned references to Subassembly Parameters, Internal Variables, or to properties of other points in the subassembly model. Other properties accept lists of items. In either case, you will see a button containing an ellipsis (“…”) on the right side of the property’s value field when you click on the property. Click on this button to invoke the appropriate dialog for assigning a value to this property: if the expected property value is a ‘string’ data type, the Code List Editor dialog will be shown; if the property accepts a point, link, or shape id, the Select Entity dialog will be shown; otherwise the Pick Value/Reference dialog will be shown. Alternately, if you want to hard-code a value for that property into the subassembly, you can simply type in an appropriate value. You may also type in (or copy/paste) a reference string manually, but be very careful to adhere to the proper syntax if you choose to do so.

If you click on the button in the lower left corner (labeled with an ellipsis), you will be able to edit either the Subassembly Parameters or the Internal Variables collections for the current subassembly. Right-click on this button to access a context menu in order to choose which collection to edit.

This dialog also contains a ‘Favorites’ pane which allows you to create a readily accessible list of components that you use most often.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML26dab21b.PNG

To add a component to the list, select it through the normal means using the menu or context menu, and then press the ‘+’ button on the favorites pane toolbar; to remove an item from the list, click on the item to select it and press the ‘x’ button to delete. To switch the current component to the selected item from the favorites list, use the arrow button.

 

Code List Editor

The Code List Editor dialog allows you to build a list of codes for the subassembly point, link, or shape using the list of pre-defined standard codes stored in your Subassembly Catalog.

The …Edit button is used to access the Code List via the Edit Codes dialog for maintenance.

When editing codes for some properties, you will see a Set From Reference button. This button will bring up the Pick Value/Reference dialog that will allow you to reference a Subassembly Parameter, Internal Variable, an RPN Expression, or a Point Reference. If you set a reference, it will override any values in the code list (upper right list box). Any modification of the code list will remove the reference and replace it with the code list.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4ddf040.PNG

Select Entity/Entities Dialog

The Select Entity/Entities dialog allows you to either select a single entity id, or build a list of entity ids , depending on the context in which the dialog is being shown (i.e. for a single entity reference, you can choose one id; for a list reference you can choose multiple ids). At this time, ids and id lists cannot be set from a reference to a variable or parameter.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4e067b1.PNG

Pick Value/Reference

The Pick Value/Reference dialog is invoked from the property fields in the Subassembly- Add/Edit Geometry dialog, or from the Code List Editor dialog. It allows you to select a reference to a Subassembly Parameter, Internal Variable, an RPN Expression, a Point property, or a Global Reference (which is used to extract information from the corridor model/baseline such as current station or current baseline radius). You will only be shown values that are potentially appropriate for the type of property you are editing. For example, if you are editing a code property, you will only see choices that produce a String value.

This dialog is also used for selecting values for Superelevation properties in the Subassembly- Add/Edit Geometry dialog. In this case, you will see the parameter type set to Superelevation and will be able to choose a value using the drop down list for the Parameter/Value field.

When working with numeric parameters (including Superelevations), you can apply a modifier to the property value. This enables you to apply a function or operation to the referenced item’s value prior to using it. If you right-click in the modifier field, you will see a context menu that will allow you to insert this function into the field.

For information re manually entering references please refer to the reference syntax portion of this document.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4e519ef.PNG C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4e62516.PNG
C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4e57fb3.PNG

Edit Test Cases

The Edit Test Cases dialog is invoked from the TestCase or TestCases property field in the Subassembly- Add/Edit Geometry dialog. These are only presented when you are editing a Conditional or Case Component.

When editing a Test Case for a Conditional Component, you will be limited to a single Test Case; when editing Test Cases for a Case Component, you will be able to add multiple Test Cases.

Each Test Case must contain one or more Conditions. Each Condition performs a discrete comparison operation using the specified Comparator method.

The comparison is performed with Value0 on the Left side of the Comparator and Value1 on the Right:

<Value0> [Comparator] <Value1>

There is also a Tolerance value that may be applied to numeric comparisons. This value will be ignored for string comparisons. Note that all numeric comparisons are made using double-precision floating point numbers, even if the referenced parameter or hard coded value is an integer.

If the Like comparator is selected, <Value1> should be a Regular Expression.

All Conditions for a given Test Case are evaluated separately and logically combined in order using the method proscribed by the Operator property for each of the individual Test Cases. The result of evaluating the Conditions for a Test Case is either True or False.

List of Commands

The List of Commands dialog is shown when the ListCommands command is invoked. It is also shown when you press the Command Line Button in the main application window. It shows you all of the non-system commands (including all command aliases) available in the application, sorted in increasing alphabetical order. To execute a command, simply select the command from the list and press the Execute button.

Export Options

The Export Options dialog is shown when the ExportCatalog command is invoked. It allows you to customize the actions taken when your Custom Subassembly Catalog is exported. For more information about exporting subassembly catalogs please refer to the Exporting the Subassembly Catalog section of this document.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML4138f730.PNG

Edit Label Properties

The Edit Label Properties dialog allows you to set/override label properties including text height, color, whether there is a leader, the color of the leader, and the label position. You can also set a comment that is appended to the default label text – this is useful when you need to add a note or reminder to a particular object when constructing your subassembly logic/geometry.

Select Color…

The Select Color dialog allows you to specify a color in ARGB format via an HSL Color Wheel, a Luminance slider, and an Opacity slider, or by directly typing in the A (alpha/transparency), R (Red), G (Green), and B(Blue) values, which are all integers ranging from 0 to 255.

Debug Subassembly

The Debug Subassembly dialog allows you to ‘break’ in the middle of building your subassembly geometry and look at the internal state of the subassembly at the break point. For example, let’s say you need to check the result of a computation that occurs at a component with a geometry id of 25. You could set a ‘break point’ at the subsequent component and then look at the value of the variable or parameter that the result was stored in.

To access the Debug Subassembly dialog, enter the command ‘\debug’ at the command prompt:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML87332ee.PNG

To set a breakpoint, type the geometry id of the component you want to break at in the field in the upper right corner, and press the ‘Break @’ button. The breakpoint will be hit immediately before the component with that id is run.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML875cccc.PNG

To cause the subassembly to rebuild, thus enabling the breakpoint to be reached, click the ‘Regen’ button.

When the breakpoint is reached, the ‘state’ of the subassembly will be shown in a hierarchical ‘tree view’, thus allowing you to see a categorized listing all of the subassembly geometry at that point in time, plus the actual ‘runtime’ values of the parameters and variables.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML879e480.PNG

You can also ‘break @ terminus’ to see the state of the subassembly immediately after the last component is executed.

To ‘step’ to the next geometry component without explicitly setting another breakpoint, click the ‘Step’ button. To run to the next breakpoint, click the ‘Resume’ button.

After the subassembly finishes executing, the breakpoints are cleared automatically.

About Subassembly Studio

The About Subassembly Studio dialog allows you to determine the product version and whether you have a valid license. It also displays your ‘Master Key’

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML413a197f.PNG

Right clicking on the master key field will bring up a context menu that will allow you to copy your master key to the Windows clipboard:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML413b8ab8.PNG

Custom Subassembly Terms and Definitions

General

Catalog: This is the main project file that is used to contain the custom subassemblies you build. Certain common parameters are stored at the catalog level, including the list of standard point, link, and shape codes. The catalog corresponds with the subassembly/tool catalogs used in the AutoCAD Civil 3D content browser.

Subassembly: This corresponds with a subassembly in AutoCAD Civil 3D. In Subassembly Studio, you will be able to add and modify all aspects of the custom subassembly.

Intellassembly: This is a special type of complex custom subassembly that is optional in Subassembly Studio – Ultimate Edition. It essentially serves as half of an assembly which is dynamically generated at runtime. Intellassemblies may be purely logical, or may contain both logical and geometric components, but must contain both an IntellassemblyOrigin and either a Case or IntellassemblyEvents component. The Intellassembly Events are logical conditions which must be satisfied in order to invoke a certain subassembly or subassemblies. In response to the Intellassembly Events, calculations may be performed and other subassemblies invoked.

At runtime, the Intellassembly begins by establishing the first target, optionally executes a pre-process loop which behaves the same as the main loop except that the target is not advanced, then enters the main loop where an iteration is executed for each target starting at the first and ending one iteration after the last target is processed in the direction the Intellassembly is inserted. For each iteration, the entire logical tree of the Intellassembly is executed, after which the current target is advanced and the process repeated.

Insertion Point: The insertion point for your subassembly is the Origin of the subassembly. It is sometimes referred to as the Anchor Point for the subassembly. This is the base point from which all other subassembly geometry is determined. All offset and elevation values (not including values calculated at runtime from Target parameters) are relative to this location.

Anchor Point: Refer to Insertion Point (above).

Attachment Point: The attachment point for your subassembly represents the last point created by your subassembly and is intended to be the point where additional subassemblies may be attached to your custom subassembly in AutoCAD Civil 3D. By default, it is inserted automatically (inferred as the last point actually created by your subassembly). You may override this behavior using a SetAttachmentPoint logical component.

 

Codes: The Subassembly Studio maintains an arbitrary list of codes that are shared among points, links, and shapes (see below). This enables you to build code lists for your geometry using a selection tool rather than by explicitly typing the list every time. The code list is stored at the catalog level and is therefore shared between all subassemblies in a given catalog.

Point: Defined in the Subassembly Components section (below).

Link: Defined in the Subassembly Components section (below).

Shape: Defined in the Subassembly Components section (below).

Parameter: Defined in the Subassembly Components section (below).

Intellassembly Target: This refers to a linear CAD object that has been associated with the executing corridor, and has been decorated with various attributes, including a code, options for overriding corridor frequencies for special station insertion, optional extended attributes, etc. When an Intellassembly executes, the subassembly loops through each target at the current station moving in the same direction as the subassembly insertion side, and evaluates the Intellassembly logic separately for each target.

Intellassembly Preprocess Loop: This refers to the first loop iteration executed in an Intellassembly. The current target is not advanced automatically in this iteration.

Intellassembly Main Loop: This refers to each of the iterations of Intellassembly execution where the Intellassembly logical tree is evaluated against the current target, after which the current target is automatically advanced by one in the direction the Intellassembly is inserted in. After all available targets have been exhausted, the Intellassembly Main Loop executes one additional time with no current target, which allows you to add in cleanup logic to properly complete your subassembly geometry.

Intellassembly Virtual Loop: This refers to a variant of the Intellassembly Main Loop which may optionally occur when an Intellassembly is invoked from within another Intellassembly. In the Intellassembly Virtual Loop, the targets are an exact copy of the targets in the main Intellassembly and are therefore incremented/advanced independently (the Virtual Loop does not affect the current target pointer in the main Intellassembly), but is otherwise treated the same as an Intellassembly Main Loop.

Subassembly Components

Subassembly components include both the subassembly geometry and the parameters used to control the dimensions of the geometry. Definitions for each component type are given below, and will be explained in more detail later in this document.

Subassembly Parameters

Subassembly Parameters are the parameters that are shown to the AutoCAD Civil 3D user when your subassembly is either inserted into a drawing or modified. These can include both layout mode parameters and Target Parameters. Subassembly Parameters are used only within the context of the subassembly in which they are defined. Subassembly Parameters have an associated data type that will be used to determine where the parameter may be used (see below for a description of data types). Target Parameters have an additional property that determines the type of logical name target the parameter should accept. Multi-Target Parameters have additional properties used to control how the individual target parameters contained in the multi-target parameter are named, and to allow the user to specify the maximum size of the collection.

Internal Variables

Internal Variables are used in a similar manner as the subassembly parameters, except that they are not exposed to the end user in AutoCAD Civil 3D and may not be used as a Target Parameter or as a Multi- Target Parameter. Their purpose is to allow you to store a value in one location (where it is easily changed) and re-use that value in multiple locations via a reference. Internal variables are used only within the context of the subassembly in which they are defined. Internal variables, like Subassembly Parameters, have an associated data type that will be used to determine where the parameter may be used (see below for a description of data types).

Geometry

The Geometry collection is a collection of COGO commands (referred to as Geometry Components) that define the geometry of a custom subassembly. All subassembly geometry elements created by a Geometry Component have an Id property, which is simply an integer value (whole number) that uniquely identifies the element. The Geometry Component also has a Geometry Id property, which is similar to the geometry element Id properties and uniquely identifies the Geometry Component in the Subassembly.

There are five categories of Geometry Components, each of which will be explained in more detail later:

Origin: This is the Insertion or Anchor Point for the subassembly. It will be created automatically when you create a new subassembly. It cannot be deleted, and you cannot add additional Origins of any type, but you may switch between Origin types if you are using Subassembly Studio – Ultimate Edition or any other license level for which Intellassembly is enabled.

Point/Complex: Point/Complex geometry components allow you to create a new point, or some combination of points, links, and/or shapes, located relative to and dependent on an existing reference point (valid reference points are all prior points in the subassembly, including the origin). There are many methods that can be selected to define the point location relative to its reference point, including various combinations of slopes, changes in offsets, and changes in elevations. This category also includes marked points, pipe and daylight components.

Link: A link is a linear element connecting one point with another. Links typically represent a surface in the corridor model. Traditionally, links in subassemblies have been limited to straight line segments from one point to another. Subassembly Studio implements the concept of a Complex Link where a link may also contain midpoints, thus making possible the approximation of curves, surface profiles, etc. and simplifying the modeling of polygons. Complex links are similar to the concept of a ‘line string’, or a ‘polyline’ that contains only straight segments. Regardless of whether a link is simple or complex, it still is referenced using one and only one Id value, making shape creation far easier to accomplish.

Shape: A shape is a component that is defined from several links that, when grouped together, form a polygon. A shape in cross section is an area, and is typically used to represent a volume when extended to 3d in a corridor model. Shapes may be statically or dynamically determined (i.e. you may define shapes as being bounded between certain links, or shapes may be automatically calculated by intersecting collections of links).

Logical: Logical components are used to define the runtime logic for (or “flow” of) the subassembly, to perform calculations, interact with certain subassembly properties, affect layout mode positioning of geometric components, invoke other subassemblies, and to interact with the AutoCAD Civil 3D model. These components allow you to implement ‘visual programs’ to govern the behavior of your subassemblies.

Subassembly Parameters and Internal Variables

Subassembly Parameters and Internal Variables (which are similar to Subassembly Parameters, except that they are flagged for internal use only) are used to control dimensions and other attributes of the subassembly Geometry Components. There are different types of parameters, and depending on the Parameter Type, the properties presented for the parameter may change. If you are using Subassembly Studio – Ultimate Edition and are editing parameters or variables for an Intellassembly, you have the option of making the parameter or variable Transitive, which, if set to True, causes the value to be reset at the beginning of each Intellassembly Loop; if the parameter or variables is not in an Intellassembly, this setting is ignored.

Parameter Types

Input: This is data that will be used by the subassembly. Both Subassembly Parameters and Internal Variables may use Input Parameters.

Output: This is data that will be returned when the subassembly finishes executing. This is currently not used.

Target: This is used to allow the user to assign target objects (for offsets, elevations, and surfaces) via logical name mapping in the corridor properties in Civil 3D. Only Subassembly Parameters may make use of Target Parameters.

Auto Target: This is similar to regular target parameters, except that Civil 3D automatically assigns target objects (for offsets, elevations, and surfaces), so the user is no longer required to manually set the target via logical name mapping in the corridor properties. Only Subassembly Parameters may make use of Target Parameters.

Multi-Target: This is used as a collection of target parameters which is manipulated as a single entity. It is usable directly in component properties which expect a multi-target parameter reference as input, or in a property expecting a single target reference provided a specific element in the collection is addressed using its zero-based index within the collection (i.e. the first element has an index of 0, the second has an index of 1 and so forth). Only Subassembly Parameters may make use of Target Parameters.

Auto Multi-Target: This is similar to the Multi-Target parameters defined above, except that each individual target entity is automatically found by Civil 3D at runtime as in the case of the single-entity Auto Target parameter defined above.

Parameter Logical Name Types

The Parameter Logical Name Type property is only shown for Target Parameters. It is used to determine what type or category of AutoCAD Civil 3D object the parameter will target.

None: Do not use. This specifies that the parameter will not accept logical name targets of any type and is for internal use only.

Surface: This indicates that only Surface targets will be accepted.

Alignment: This indicates that only Alignment targets will be accepted. This target type is used for retrieving offsets.

Profile: This indicates that only Profile targets will be accepted. This target type is used for retrieving elevations. For all Auto Target parameters (both single and multiple), the profile MUST be defined for the current baseline alignment.

OffsetTarget: This indicates that any valid offset targets will be accepted. For all Auto Target parameters (both single and multiple), only Alignments are used as offset targets.

ElevationTarget: This indicates that any valid elevation target will be accepted. For all Auto Target parameters (both single and multiple), only profiles are used as Elevation Targets, and the profile MUST be defined for the current baseline alignment.

OffsetTargetPipe: This indicates that only pipe objects will be accepted for determining offsets.

ElevationTargetPipe: This indicates that only pipe objects will be accepted for determining elevations.

Parameter Data Types

Input and output parameters will present a Parameter Data Type property. This property will describe the nature of the data the parameter will hold and will affect where the parameter may be used. For example, a parameter with a type of String may be used for codes, but not for a dimension. A parameter with a numeric type (such as Double) may be used as a distance or elevation. The types listed below are the major types/type categories. When setting the parameter type, you will also see several subtypes listed for certain major types/type categories. These used to represent subsets or variants of the major type/type category value set. For example, numeric types may be limited to positive values only, or may be flagged for use in certain types of situations only (e.g. as a Grade or as a Distance). The nature of the subtype may be inferred directly from the name.

String: String data is plain text. It can consist of any character, including punctuation and numeric characters. Numeric characters are evaluated as plain text, even if no alphabetic or punctuation characters are included. There are no subtypes for String data.

Bool: Bool is an abbreviation for ‘Boolean’. Bool data may be one of two values: a ‘true’ value or a ‘false’ value. There are several subtypes of Bool data that use different names for the ‘true’ and ‘false’ values, as defined in the table below. Note that when you are checking the value of a Boolean value in a Test Case, compare the value to the literal string value taken from the table below (case-sensitive).

Data Type True Value False Value
Bool True False
BoolYesNo Yes No
BoolEnabledDisabled Enabled Disabled
BoolOnOff On Off
BoolRightLeft Off Left

Int: Intl is an abbreviation for ‘Integer’. This means any whole number, including negatives and zero. Integer values may not contain a decimal or fractional component. There are several subtypes of integers available that limit the input value to negative only, positive only, etc.

Double: Double data is numeric data that may contain a decimal or fractional component. Any real number is acceptable. There are several subtypes of Double data that limit the input value to positive only, negative only, etc. There are also several ‘special’ categories of Double data that are associated with a particular use of the parameter value, e.g. data can be flagged as a slope, a distance, etc.

Superelevation: Superelevation is an enumerated data type that allows the user to choose from one of several pre-defined value choices. In Civil 3D and the Subassembly Studio alike, the user will be presented with a drop-down list of values to choose from when he attempts to modify a Superelevation value. There are no subtypes for Superelevation data.

Geometry Component Categories

Origin

Origin geometry components are used to define the insertion point for the subassembly. Each subassembly must have one and only one IntellassemblyOrigin or Origin, which is automatically created for you when you create the subassembly. The Origin will always be located at the local coordinates (0,0). The only properties you may set for the Origin are its PointCodes and IsHidden property. The origin is always assigned a Point Id of (1).

IntellassemblyOrigin

IntellassemblyOrigin geometry components are used to define the insertion point for an Intellassembly. Each subassembly must have one and only one IntellassemblyOrigin or Origin, which is automatically created for you when you create the subassembly. The IntellassemblyOrigin will always be located at the local coordinates (0,0). The IntellassemblyOrigin component has several settings beyond those defined for the standard Origin component, including:

  • Layout delta offset/elevation to locate the optional Pre-Process Loop Point
  • Reset Target Pointer On Virtual Loop: Causes the internal pointer to the current target to be re-calculated based on the current insertion point position for an invoked Intellassembly IF the Use Virtual Loop When Invoked option is enabled.
  • Use Preprocess Loop: If enabled, a Preprocess Loop Point will be created at Point Id (2), and at runtime a Preprocess Loop will be executed.
  • Use Virtual Loop When Invoked: If enabled, the Intellassembly will use the Virtual Loop mode where each remaining Intellassembly Target is evaluated as if the invoked Intellassembly were in a regular Main Loop, but the current Target Pointer in the main Intellassembly (from which the Intellassembly running in Virtual Loop mode was invoked) will not be affected. If disabled, the invoked Intellassembly executes only one loop iteration (for the current target), and does not increment the Target Pointer (this task is left to the main Intellassembly to perform).

The Main Loop Origin Point is always assigned a Point Id of (1); the Pre-Process Loop Point is always assigned a Point Id of (2) if used.

Points/Complex

Point geometry components are used to create a new point, or some combination of points, links, and/or shapes, relative to another (previously created) referenced subassembly point. Note that as a convenience, Link Geometry Components are optionally created when inserting most of the basic Point Geometry Components.

There are many options for locating the new point(s), as shown below:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5bdf4a8.PNG

DeltaElevDeltaOffset

DeltaElevDeltaOffset geometry components locate a point at a specified horizontal and vertical distance relative to the Reference Point.

ElevDeltaOffset

ElevDeltaOffset geometry components locate a point at a specified horizontal distance relative to the Reference Point and vertical distance relative to the Origin point. Please note that the Origin point is the insertion point for the subassembly, and most likely does not correspond with its local coordinates of (0,0) in the corridor model. There is no visual difference between ElevDeltaOffset points and any those created by any other point geometry component other with the exception of Daylight components.

OffsetDeltaElev

OffsetDeltaElev geometry components locate a point at a specified horizontal distance relative to the Origin point and vertical distance relative to the Reference Point. Please note that the Origin point is the insertion point for the subassembly, and most likely does not correspond with its local coordinates of (0,0) in the corridor model. There is no visual difference between OffsetDeltaElev points and any those created by any other point geometry component other with the exception of Daylight components.

OffsetElev

OffsetElev geometry components locate a point at a specified horizontal and vertical distance relative to the Origin. Please note that the Origin point is the insertion point for the subassembly, and most likely does not correspond with its local coordinates of (0,0) in the corridor model. There is no visual difference between OffsetElev points and any those created by any other point geometry component other with the exception of Daylight components.

AngleOffset

AngleOffset geometry components are used to create a point at a specified angle (in degrees, measures positive CCW from the +x axis) at a specified offset measured from the Origin.

AngleDeltaOffset

AngleDeltaOffset geometry components are used to create a point at a specified angle and horizontal distance measured from the Reference Point.

AngleElev

AngleElev geometry components are used to create a point at a specified angle at a specified elevation measured from the Origin.

AngleDeltaElev

AngleDeltaElev geometry components are used to create a point at a specified angle and vertical distance measured from the Reference Point.

AngleDistance

AngleDistance geometry components are used to create a point at a specified angle and distance measured from the Reference Point.

DeltaAngleDistance

DeltaAngleDistance geometry components are used to create a point at a specified angle, measured relative to the Reference Point and a Slope Reference Point, relative to and at a distance measured from the Reference Point.

DeflectionAngleDistance

DeflectionAngleDistance geometry components are used to create a point at a specified angle, measured relative to the portion of the imaginary line formed by extending a ray from a Slope Reference Point through the Reference Point that is beyond the Reference Point, relative to and at a distance measured from the Reference Point.

SlopeDeltaElev

SlopeDeltaElev geometry components are used to create a point at a specified slope and vertical distance measured from the Reference Point.

SlopeElev

SlopeElev geometry components are used to create a point at a specified slope from the Reference Point, targeting an elevation calculated at a vertical distance measured from the Origin.

SlopeDeltaOffset

SlopeDeltaOffset geometry components are used to create a point at a specified slope and horizontal distance measured from the Reference Point.

SlopeOffset

SlopeOffset geometry components are used to create a point at a specified slope from the Reference Point, targeting an offset calculated at a horizontal distance measured from the Origin.

SlopeDistance

SlopeDistance geometry components are used to create a point at a specified slope and distance measured from the Reference Point.

SlopeToSurface

SlopeToSurface geometry components are used to create a point at the intersection of the specified slope and a target surface, measured from the Reference Point. This component uses a delta offset property to control layout mode geometry.

SlopeToSurface2

SlopeToSurface geometry components are used to create a point at the intersection of the specified slope and a target surface, measured from the Reference Point. This component uses a delta elevation property to control layout mode geometry.

MidPoint

MidPoint geometry components allow you to create a point exactly halfway between the Reference Point and a target point.

InterpolatedPoint

InterpolatedPoint geometry components allow you to create a point between the Reference Point and a Target Point. The point is created using a percent distance property which is used to determine the distance of the created point from the Reference Point along the line segment between the Reference and Target Points.

MarkedPointGet

MarkedPointSet geometry components are used to retrieve the location of a Marked Point in the assembly and sets a new point at that location.

MarkedPointSet

MarkedPointSet geometry components are used to set the location of a new Marked Point in the subassembly at the coordinates of the Reference Point.

NearVertical

NearVertical geometry components are used to create a point almost directly above or below Reference Point at a specified distance. The point is offset slightly from the Reference Point in order to facilitate corridor surface creation. There is virtually no difference between a NearVertical and a DeltaElevDeltaOffset component. NearVertical components are included for convenience and to encourage the user to consider proper surface creation when designing and constructing their custom subassemblies.

Vertical

Vertical geometry components are used to create a point directly above or below Reference Point at a specified distance.

Perpendicular

Perpendicular geometry components are used to create a point at a specified distance from the Reference Point measured perpendicular to a line between the Reference Point and a second referenced point. A positive distance value locates the point to the right of the line defined as starting at the second reference point and ending at the first; a negative distance locates the point to the left of this line.

StripSurface

StripSurface geometry components create two points and a complex link. The points are created at the Reference Point offset and at a specified delta offset, measured from the Reference Point, with the elevation of both points set to the (required) target surface elevation plus a delta elevation value. The complex link is created between these two points and follows the target surface elevations plus the delta elevation value. The complex link is assigned a single LinkId and is usable for defining shape boundaries. In layout mode, the elevation is determined based on the Reference Point rather than the target surface, and the complex link appears as a simple link between the two points.

Daylight

Daylight geometry components are designed to intersect a surface at a specified slope, or at a targeted offset. Daylight geometry components create three points: a Cut Point, a Fill Point, and a Daylight Point. The Daylight Point is always created at the intersection with the surface, if found. The Cut and Fill points are used in layout mode to attach additional geometry components that will only be built in the corridor model if the daylight component is in either cut or fill. This is a shortcut that allows you to customize the behavior of your subassembly model without inserting a Conditional Component (a type of Flow Component). In addition to creating the three points, a link will also be added automatically between the insertion point and the Cut/Fill points (at layout, two links will be created, one for cut and one for fill; when the corridor model is built, only a single appropriately coded link will be built between the Reference Point and the Daylight Point).

BenchedDaylight

BenchedDaylight geometry components are similar to daylight components except that they also include an option to construct a bench if the slope height exceeds a certain threshold measured from the last bench or the origin (top or toe) of the slope.

OffsetOnSurface

OffsetOnSurface geometry components are used to locate a point on a required target surface at a specified offset, measured from the subassembly origin.

DeltaOffsetOnSurface

DeltaOffsetOnSurface geometry components are used to locate a point on a required target surface at a specified offset, measured from the Reference Point.

IntersectAngles

IntersectAngles geometry components are used to locate a point at the intersection of two lines, each defined by an angle and located at from a Reference Point. The first angle is specified looking ‘right’ from the second Reference Point; the second is defined looking ‘left’ from the second Reference Point (the second angle is automatically multiplied by -1.0 to accomplish this). Automatic link creation is optional.

IntersectSlopes

IntersectSlopes geometry components function identically to IntersectAngles components, except that the intersected lines are defined using slopes instead of angles.

IntersectSlopesFromPoints

IntersectSlopesFromPoints geometry components are used to locate a point at the intersection between two lines, each defined from a Start and End Reference Point. Automatic link creation is optional.

Ditch

Ditch geometry components function similarly to IntersectSlopes components, however, instead of intersecting at a single point, a Ditch Width parameter is used to locate a horizontal link between the two slopes.

Pipe

Pipe geometry components construct a representation of a pipe from a targeted pipe network. The shape and size of the pipe is automatically determined from the targeted pipe part properties when the corridor model is constructed[2]. The pipe is constructed using four ‘compass’ or ‘quadrant’ points with complex links in between. These links are usable, just like any other links, in defining your subassembly shapes.

MultiPipeWithBackfill

MultiPipWithBackfill geometry components accept a Multi-Target parameter which is used to target multiple pipe networks in a single operation. The size and position of the pipes is analyzed and points are created at the left-most, right-most, bottom-most, and top-most points on the outer surfaces of the collection of pipes, effectively placing a point somewhere on each side of the rectangle which bounds all of the pipes. An option is given to include a backfill at a specified cover depth, and that backfill may be simple or complex (two elevations with a connecting slope). Insulation may also be added on top of or under the backfill links, and a geotextile code may be added to the lower of the backfill/insulation links. If the radius of any pipe exceeds a minimum threshold, a shape code may also be applied to the interior of the area enclosed by the outer hull of the pipe.

Pipes are assumed to be circular in this component – pipes of other shapes may cause the backfill geometry and bounding rectangle to be incorrect.

Links

Link

Link geometry components are used to create both simple and complex linear elements (straight, curved, or following a target surface) between two referenced points, specified by StartPointId and EndPointId; setting a value for the LinkCodes property is optional.

Note that as a convenience, Link components are optionally created when inserting most Point Geometry Components.

Created links may be either ‘simple’ or ‘complex’. A ‘simple’ link is a straight line between two end points; a ‘complex’ link has midpoints (for example, a tessellated curve).

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5c1ef3c.PNG

TwoPointHeightArcLink

TwoPointHeightArcLink geometry components are used to create a circular arc-shaped link between two referenced points, which are used to define a chord, and a height measured perpendicular to the chord at its center. The arc created is always a minor arc (sweep angle is less than 180 degrees), and if the height specified is too large, the arc radius is automatically limited to ensure that a minor arc is created. A positive height locates the arc on the right side of the chord; a negative height locates the arc on the left side of the chord.

TwoPointRadiusArcLink

TwoPointRadiustArcLink geometry components are used to create a circular arc-shaped links between two referenced points, which are used to define a chord, with a specified radius. The arc is limited to minor arcs only, and if the radius specified is too small, it is automatically limited to ensure that the resulting arc is a minor arc. If the radius is positive, the arc is located on the right side of the chord; if the radius is negative, the arc is located on the left side of the chord.

ThreePointArcLink

ThreePointArcLink geometry components are used to create a circular arc-shaped links between three referenced points. Both minor and major arcs are allowed. The arc will always be oriented starting at the start point, passing through a point on curve, and ending at the end point.

ParabolicLink

ParabolicLink geometry components are used to create a parabolic curve-shaped links between two referenced points. The curve created is actually half of a parabola. At the start point, the parabola has a slope of 0.0. The parabola is then calculated using this starting point and slope to end at the second referenced point. Because the ParabolicLink components create half-parabolas, two may be combined to form either a symmetrical or an asymmetrical parabolic section.

FollowSurface

FollowSurface geometry components are used to create an exact copy of a targeted surface between two endpoints, which also must lie on the surface.

Shapes

Shape components are used by Civil 3D to calculate structural volumes, and to display shading/hatching in cross sections. When creating shapes, you must specify the LinkIds that define the closed polygon which comprises the shape; setting a value for the ShapeCodes property is optional. For certain Shapes, you must specify a separate Layout Mode list of Link Ids which is used for drawing the shape in Layout Mode only.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5c0006b.PNG

LinkIds may be added using the Link List Editor dialog, or may be typed in manually. Valid shapes must be defined using three or more ‘simple’ links, or two or more ‘complex’ and/or ‘simple’ links

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5c08ce1.PNG

Shape

Shape geometry components are the most basic form of Shapes in Subassembly Studio. The links need not be defined all in the same rotational direction (i.e. they don’t have to stack start point to end point), nor do coincident link endpoints have to reference the same point id, however, you must define a geometrically closed polygon comprising at least two links in order for the shape to be properly formed by Civil 3D. Shape components are labeled using curly braces to surround the Shape Id, followed by the shape code (e.g. “{2} Codes: Pave”) and are located at the centroid of the polygon defined by the bounding links. At runtime, if any referenced link does not exist, or if less than two links are specified, the shape will not be created.

ShapeWithRefPoint

ShapWithRefPoint geometry components are similar to standard Shape components except that, much like Point/Complex Geometry and many Flow components, they are only built if a specified Reference Point exists. If the Reference Point exists, the ShapeWithRefPoint will behave exactly as a standard Shape component would. ShapeWithRefPoint component labels are modified from those of a standard Shape component by the addition of an asterisk (“*”) after the curly braces surrounding the Shape Id in the standard component (e.g. “{2}* Codes: Pave”).

ShapeFromValidLinks

ShapeFromValidLinks geometry components are similar to standard Shape components except that non-existing or otherwise invalid links referenced by the component are ignored when defining the polygon. Once the polygon is defined, the ShapeFromValidLinks component will behave like a standard Shape component. ShapeFromValidLink components also require a second set of Link Ids to be specified for layout mode – these Link Ids should form a simple closed polygon that adheres to the same rules as apply to standard Shape components. ShapeFromValidLink component labels are modified from those of a standard Shape component by substituting double curly braces for the single curly braces surrounding the Shape Id in the standard component (e.g. “{{2}} Codes: Pave”).

ShapeFromValidLinksWithRefPoint

ShapeFromValidLinksWithRefPoint geometry components are similar to ShapeFromValidLinks components except that, just like the ShapeWithRefPoint components, if the specified Reference Point does not exist, the shape will not be created. ShapeFromValidLinksWithRefPoint component labels are modified from those of a standard ShapeFromValidLinks component by the addition of an asterisk (“*”) after the double curly braces surrounding the Shape Id (e.g. “{{2}}* Codes: Pave”).

Logical

Logical Components are used to control the logic used to construct an intelligent subassembly (i.e. to define the logical ‘flow’ of the subassembly geometry).

Conditional

Conditional components are the equivalent of a simple If-Then statement. There is a True condition and a default of False condition, and a single Test Case to determine which to use. In Layout Mode, both cases are shown as separate Conditional Points on the model with connecting Logical Links, which do not have Ids because they do not represent real subassembly links. At runtime, the Logical Links and Conditional Points are removed and only the appropriate attached geometry is built (attached to the Conditional Component’s Reference Point).

Case

Case components are similar to Conditional components, except that they allow for multiple Test Cases in addition to the default condition. In Layout Mode, all Test Case points are shown, as are the Logical Links (similar to the Conditional component above). At runtime, the Test Cases are evaluated one at a time, starting at the top of the list. As soon as one Test Case evaluates to True, the remainder are ignored and the geometry attached to the point corresponding to the Test Case that evaluated to True is built, inserted at the Case component’s Reference Point. If no Test Case evaluates to True, the Default Case will be used.

IsLayoutMode

IsLayoutMode components are similar to Conditional components, except that the test case is hard-coded to determine whether the current subassembly is running in Layout mode.

IsRightSide

IsRightSide components are similar to Conditional components except that the test case is hard-coded to determine whether the current subassembly is inserted facing Right. .

IsLeftSide

IsLeftSide components are similar to Conditional components except that the test case is hard-coded to determine whether the current subassembly is inserted facing Left.

PointExists

PointExists components are similar to Conditional components, except that the test case is hard-coded to determine whether a specified point reference ‘exists’ in the current subassembly.

MarkedPointExists

MarkedPointExists components are similar to Conditional components, except that the test case is hard-coded to determine whether a specified marked point reference exists in the corridor model at the current station/in the current assembly.

PointsInSameLocation

PointsInSameLocation components are similar to Conditional components, except that the test case is hard-coded to determine whether the referenced points are coincident within a specified tolerance.

CompareVirtualPointToSurface

CompareVirtualPointToSurface components allow you to compare {offset, elevation} coordinate pairs to a target surface to determine the location of a Virtual Point defined by the coordinates relative to the target surface. This component is the equivalent of a Case component with three predefined test cases. At runtime, only one of the four points created will ‘exist’ for any given instance of this component.

LayoutDeltaElevationDeltaOffset

LayoutDeltaElevationDeltaOffset components simply provide a way of creating a point at a specified delta offset/delta elevation relative to a Reference Point in Layout Mode only. At runtime, the point created by this component is always placed coincident to the Reference Point.

Rollback

Rollback components are used to back up to a Target Point, recursively removing all Geometry Components encountered attached to the Target Point, any components attached to the points created by the previous iteration’s components, and so forth until a point is found which is not being referenced, or a point is found which is referenced by a component derived from (and including) the MergeFlow component. Rollback components should only be attached to a Conditional or Case Component. The Target Point may lie on any logical or geometric path; however, it is generally a best practice to restrict the Target Point to only those points on the same logical path as the Rollback component.

Rollback components allow you to apply a delta offset/elevation to the target point (applicable only in Layout Mode) to clearly distinguish the point created by the Rollback component from the Target Point. This delta offset/elevation is ignored in when the subassembly is built in the corridor model.

NullifyPath

NullifyPath Components are similar in nature to a Rollback Component, except that no previously existing geometry is removed…the Target Point is simply treated as if it did not exist for all components added after the NullifyPath component has executed without modifying any previously existing component geometry or logic.

UncreatePoint

UncreatePoint components allow you to remove a previously “existing” point at runtime, effectively making the targeted point non-existing for all subsequent references. No rollback operation occurs, and any component or geometry which referenced the target point prior to the UncreatePoint component executing are unaffected.

And

And components allow you to merge multiple logical paths (via end point references) into a single path which is executed only if ALL referenced points exist. This component can be applied in layout mode.

Not

Not components allow you to create a point which exists if the referenced point does not, and does not exist if the referenced point does.

MergeFlow

MergeFlow components are used to merge several separate logical paths in the subassembly back into one and are the equivalent of a logical OR operation. The point created by a MergeFlow component is located at the coordinates of the first ‘existing’ point found in the subassembly when not in layout mode.

MergeFlowHighestPoint

MergeFlowHighestPoint components are used to merge several separate logical paths in the subassembly back into one. The point created by a MergeFlowHighestPoint component is located at the coordinates the referenced ‘existing’ point with the highest elevation found in the subassembly.

MergeFlowLowestPoint

MergeFlowLowestPoint components are used to merge several separate logical paths in the subassembly back into one. The point created by a MergeFlowLowestPoint component is located at the coordinates the referenced ‘existing’ point with the highest elevation found in the subassembly.

MergeFlowLeftMostPoint

MergeFlowLeftMostPoint components are used to merge several separate logical paths in the subassembly back into one. The point created by a MergeFlowLeftMostPoint component is located at the coordinates the referenced ‘existing’ point with the lowest numeric offset found in the subassembly.

MergeFlowRightMostPoint

MergeFlowRightMostPoint components are used to merge several separate logical paths in the subassembly back into one. The point created by a MergeFlowRightMostPoint component is located at the coordinates the referenced ‘existing’ point with the highest numeric offset found in the subassembly.

MergeFlowInsideMostPoint

MergeFlowInsideMostPoint components are used to merge several separate logical paths in the subassembly back into one. The point created by a MergeFlowInsideMostPoint component is located at the coordinates the referenced ‘existing’ point found in the subassembly which is closest to the insertion point/subassembly origin.

MergeFlowOutsideMostPoint

MergeFlowOutsideMostPoint components are used to merge several separate logical paths in the subassembly back into one. The point created by a MergeFlowOutsideMostPoint component is located at the coordinates the referenced ‘existing’ point found in the subassembly which is farthest from the insertion point/subassembly origin.

StopProcessingConditional

StopProcessingCondtional components are used in the creation of Conditional Subassemblies (supported in AutoCAD Civil 3D 2010 and later versions only, and should not be confused with Conditional Components, which are internal components in Subassembly Studio and are supported in all versions of AutoCAD Civil 3D). When a StopProcessingConditional component is encountered, AutoCAD Civil 3D is notified that all subassemblies which attach to the current subassembly should be omitted from the corridor model.

ModifyVariable

ModifyVariable components are used to change the value of internal variables used in a subassembly as the subassembly is being constructed. ModifyVariable components should be used with caution as it is very easy to cause unintended consequences in your subassembly geometry.

ModifyParameter

ModifyParameter components are used to change the value of subassembly parameters used in a subassembly as the subassembly is being constructed. ModifyParameter components should be used with caution as it is very easy to cause unintended consequences in your subassembly geometry.

CalculateValue

CalculateValue components are used to perform an arithmetic operation between two referenced values (or hard-coded numeric values). The result is stored in an Internal Variable.

Sum

Sum components are used to perform a sum operation on multiple referenced values (or hard-coded numeric values). The result is stored in an Internal Variable.

CalculateDistanceBetweenPoints

CalculateDistanceBetweenPoints components are used to calculate the distance (always a positive value) between two referenced points. The result is stored in an Internal Variable.

CalculateSlopeBetweenPoints

CalculateSlopeBetweenPoints components are used to calculate the slope between two referenced points. The result is stored in an Internal Variable.

CombineStrings

CombineStrings components are used to concatenate two string values with an optional delimiter in between (e.g. for combining two separate code values into a single comma separated list of codes). The result is stored in an Internal Variable.

CombineMultipleStrings

CombineMultipleStrings components are used to concatenate multiple string values with an optional delimiter in between (e.g. for combining several separate code values into a single comma separated list of codes). The result is stored in an Internal Variable.

NOTE: The Values field accepts multiple Subassembly Parameter references, Internal Variable references, and hard-coded string literal values with each reference/value separated by a vertical bar (with no adjacent spaces); however, the current user interface does not support creating lists of multiple value references, so the references and values must be manually typed into this field.

GetMarkedPointCoordinates

GetMarkedPointCoordinates components are similar to the GetMarkedPoint geometry component except that instead of storing a point in the subassembly, the coordinates of the targeted Marked Point are instead stored to Internal Variables if the Marked Point is found.

MultiTargetCount

MultiTargetCount components allow you to determine the number of targets specified by the user for Multi-Target Parameters, or the number of targets found for Auto Multi-Target Parameters. The result is stored in an Internal Variable.

SortMultiTargetAtPoint

SortMultiTargetAtPoint components allow you to sort the found targets in a Multi-Target or Auto Multi-Target Parameter by evaluating each entity at the specified point. This results in comparison by elevation for Surface and Elevation Targets, and by offset for Offset Targets. Sort order may also be specified as either ascending or descending. Use of this component is generally required prior to invoking another subassembly via a Repeater Component, or before referencing an individual target entity by index.

ProjectLinkPointsToVertical

ProjectLinkPointsToVertical components allow you to project all nodes along a complex link to a vertical line at an arbitrary offset along an arbitrary projection slope. This is useful for determining base elevations for overlays and stripping when creating subassemblies for roadway rehabilitation.

XRecordGet

XRecordGet components allow you to retrieve a value stored in a named XRecord within the current DWG at runtime. This allows you to retrieve values saved by subassemblies which executed at previous stations, or values stored by other applications. The result is stored in an Internal Variable.

XRecordSet

XRecordSet components allow you to store a value in a named XRecord within the current DWG at runtime. This allows you to later retrieve the saved value using an XRecordGet component.

XRecordGetMultipleToParameters

XRecordGetMultipleToParameters components allow you to store values retrieved from named XRecords within the current DWG at runtime in a batch operation for all Subassembly Parameters where the parameter name matches both a specified match pattern (Regular Expression) AND an XRecord stored on the specified path. This method is significantly faster than retrieving the XRecord values individually via XRecordGet components.

XRecordSetMultipleFromParameters

XRecordSetMultipleFromParameters components allow you to store values to named XRecords within the current DWG at runtime in a batch operation for all Subassembly Parameters where the parameter name matches a specified match pattern (Regular Expression). The stored XRecord name will match the corresponding Subassembly Parameter name. This method is significantly faster than storing the XRecord values individually via XRecordSet components.

XRecordGetMultipleToVariables

XRecordGetMultipleToVaraibles components allow you to store values retrieved from named XRecords within the current DWG at runtime in a batch operation for all Internal Variables where the variable name matches both a specified match pattern (Regular Expression) AND an XRecord stored on the specified path. This method is significantly faster than retrieving the XRecord values individually via XRecordGet components.

XRecordSetMultipleFromVariables

XRecordSetMultipleFromVariables components allow you to store values to named XRecords within the current DWG at runtime in a batch operation for all Internal Variables where the variable name matches a specified match pattern (Regular Expression). The stored XRecord name will match the corresponding Internal Variable name. This method is significantly faster than storing the XRecord values individually via XRecordSet components.

PostErrorEventMessage

PostErrorEventMessage components are used to post an error message to the AutoCAD Civil 3D Event Viewer.

PostWarningEventMessage

PostWarningEventMessage components are used to post a warning message to the AutoCAD Civil 3D Event Viewer.

PostToCommandHistory

PostToCommandHistory components are used to post an error message to either the AutoCAD Civil 3D or the Subassembly Studio command history window instead of posting to the Civil 3D Event Viewer. This is extremely useful for debugging your subassemblies because it can be used to display the value of variables and parameters, or to indicate the state of some logical component, or any number of other uses as the subassembly is executing.

Abort

Abort components are used to cause the subassembly to immediately stop executing (does not apply in layout mode) and to post an error message to the AutoCAD Civil 3D Event Viewer.

InvokeSubassembly

InvokeSubassembly components are used to invoke another subassembly from the current catalog as if it were just another geometric component. The user must first specify the name of the subassembly by selecting it from a list. Once a subassembly is selected, the component properties will dynamically populate with properties corresponding to the targeted subassembly’s parameters. You may hard-code values or reference parameters/variables from the current subassembly as input for these dynamic properties. You may also decide whether to display the invoked subassembly geometry in layout mode, or just a point and layout line instead (using Layout Mode delta elevation and offset values to control the point location relative to the specified Reference Point).

RepeatUntilOutOfTargets

RepeatUntilOutOfTargets components are used to repeatedly invoke a subassembly using the previous iteration’s end point (i.e. Attachment Point) as the Anchor or Insertion Point for the current iteration for each target in a referenced Multi-Target or Auto Multi-Target Parameter. When there are no more parameters, the component terminates with an identified point created at the end point of the very last iteration.

RepeatUntilConditionIsTrue

RepeatUntilConditionIsTrue components are used to repeatedly invoke a subassembly using the previous iteration’s end point (i.e. Attachment Point) as the Anchor or Insertion Point for the current iteration until a break condition is satisfied. When the break condition is satisfied, the component terminates with an identified point created at the end point of the very last iteration. An example of where this may be used is in creation of a stacked block retaining wall where the blocks stop stacking when a specified maximum height is reached.

RepeatWhileConditionIsTrue

RepeatWhileConditionIsTrue components are used to repeatedly invoke a subassembly using the previous iteration’s end point (i.e. Attachment Point) as the Anchor or Insertion Point for the current iteration provided a break condition is satisfied. When the break condition is no longer satisfied, the component terminates with an identified point created at the end point of the very last iteration. An example of where this may be used is in creation of a stacked block retaining wall where the blocks continue to stack as long as the total height is less than a specified maximum height.

EndOfSurface

EndOfSurface components are used to determine the elevation and offset of the end of a surface in the specified ‘look direction’ (either right or left). The results may be posted back/written to internal variables.

SetAttachmentPoint

SetAttachmentPoint components are used to override the default behavior used when implicitly determining the Attachment Point (i.e. end point where other subassemblies should attach to) for the subassembly. For example, if you create a lane subassembly with point (2) as the outside top point, and point (8) as the bottom outside point, the default behavior will be to set point (8) as the Attachment Point. This is undesirable in most cases, and without using a SetAttachmentPoint component to identify point (2) as the intended Attachment Point, you would have to store another point on top of point(2) to force the Attachment Point to be located at the top outside point on the subassembly.

IsLicensed

IsLicensed components are based on Conditional components and are used by appropriately licensed developers to extend their own proprietary intellectual property protection into the subassemblies they create with Subassembly Studio. More information re the specific behavior of this component and the internal licensing mechanisms it uses are available only to licensed developers.

Intellassembly

Intellassembly Logical Components are not available in the Professional and lesser editions of Subassembly Studio – you must have Subassembly Studio – Ultimate Edition (or equivalent) to enable these components. Intellassembly Logical Flow Components are found in the standard Logical Component Menu and are interchangeable with standard Logical Logical Components.

IntellassemblyEvents

IntellassemblyEvents components are essentially the same thing as a Case component except that in addition to a default case condition, there is also a pre-defined condition for a NULL target (which occurs on the last iteration of the Intellassembly Main Loop).

IntellassemblyTargetCount

IntellassemblyTargetCount components allow you to determine how many Intellassembly targets were found at the current station, how many targets separate the current target from a target with a specified code, or how many targets remain to be processed. The results are stored to an Internal Variable (Integer type).

AbortIntellassembly

AbortIntellassembly causes the Intellassembly to stop executing regardless of which loop it is in or how many targets remain. Unlike the Abort component for standard subassemblies (which may be used in Intellassemblies as well), the geometry built prior to executing the AbortIntellassembly component is retained and written to the Civil 3D corridor model.

SkipIntellassemblyTargets

SkipIntellassemblyTargets components allow you to skip over a specified number of Intellassembly Targets immediately prior to executing the next loop iteration. This operation only works in the forward direction – i.e. the Number of Targets to Skip must be a positive integer value.

SkipToIntellassemblyTargetByCode

SkipToIntellassemblyTargetByCode components allow you to skip ahead to the next Intellassembly Target with the specified code immediately prior to executing the next loop iteration. This operation only works in the forward direction and, if no suitable target is found, will result in the Intellassembly Main Loop executing the last (NULL target) iteration.

Naming Conventions

Catalog

The catalog name should be descriptive of the type of subassemblies contained within. The catalog name must not contain any special characters or spaces (punctuation, etc) except for the underscore character (“_”), which may appear at any location within the name. The catalog name may contain numbers provided the first character is a letter. Letters may be either upper or lower case. Catalog names should be unique across your organization – if you reuse a catalog name, you will not be able to deploy both exported subassembly catalog packages on the same Windows profile using the standard method.

Subassembly

Subassembly names should be descriptive of their intended purpose. Subassembly names must not contain any special characters or spaces (punctuation, etc) except for the underscore character (“_”), which may appear at any location within the name. The subassembly name may contain numbers provided the first character is a letter. Letters may be either upper or lower case. Subassembly names must be unique in a given catalog, but need not be unique across all catalogs in your organization.

Parameters and Variables

Parameter and variable names are largely unrestricted, however, there are some best practices which should be adhered to. Any character or combination of characters may be used, provided you do not use a ‘reserved’ name, and that each parameter is unique within the parent subassembly in which it is defined. Even though you are not prevented from doing so, it is STRONGLY recommended that you do not use special characters (such as punctuation, brackets, braces, etc) in your parameter and variable names in order to ensure compatibility with future versions of the software, and to ensure that parsing errors will not occur when referencing the parameters and variables (limit parameter names to the same rules used for subassembly names) . There are a few ‘reserved’ names, the only one of which you are likely to encounter is ‘Side’. A ‘Side’ parameter is implicitly defined and is AUTOMATICALLY created for your subassembly when it is exported/compiled (unless you modify a setting in the subassembly properties to exclude the side parameter); therefore a ‘Side’ parameter SHOULD NOT be included in your list of subassembly parameters.

Referencing Parameters and Variables – Syntax

General

Values for subassembly component (and other) properties may be entered manually if desired. In some cases this is more efficient than using the various dialog boxes. This also allows you to copy/paste values between properties.

TIP: While the dialogs will typically try to manage the mapping of references by restricting the type of variable or parameter being references to the context of the property being set, there is no requirement that the data types actually match. For example, if you had a string data type that contained a numeric value as text, it could actually be implicitly used as a numeric input for a ‘distance’ property, etc. Likewise, a numeric value can be treated as text as well (the ‘format’ modifier below is particularly useful in the latter case).

Hard-coded/Literal Values

Hard-coded or Literal values are the most simple items to enter in a field accepting a reference. In this case, no escape sequences, quotes, etc. are used – you simply enter the literal value you want used.

e.g. if you wanted to hard-code a point ‘code’ property to a value of ‘CROWN’, you would simply type the value ‘CROWN’ (without the quotes) in the field for that property.

Modifiers do not apply to literal values.

Referencing Parameters and Variables

Parameters and variables are referenced using an escape sequence. References are case sensitive.

For Parameters, the syntax is

\\XP<ParameterName>

where: ‘<ParameterName>’ is the name of the parameter being referenced.

For Variables, the syntax is:

\\UV<VariableName>

where: ‘< VariableName >’ is the name of the variable being referenced.

Point References

In some cases, it may be useful to extract the elevation, offset, code, or slope (from the reference point of the component that created the targeted point) directly from a point in the subassembly geometry. This can be done via a point reference:

\\PT(<n>).ELEVATION

\\PT(<n>).OFFSET

\\PT(<n>).CODES

\\PT(<n>).SLOPE

Where: ‘<n>’ is the id of the point you wish to extract this information from.

The ‘slope’ option uses the primary reference point specified for the geometric component that created the targeted point. Because of this, the ‘slope’ option should generally be used only with components that create a single point; if used with complex components, be careful which point you select as a target because typically only one of the points created will return a meaningful value for this property.

Applying Modifiers

When referencing parameters or variables (and in several other cases as well), you may prefix the reference string with a ‘modifier’. The syntax for modifiers is:

\\MOD[<Modifier Function>]<Ref>

Where: ‘<Modifier Function>’ is one of several functions that may be applied to the value being referenced, and <Ref> is a properly formatted (unmodified) reference string.

Note that modifiers do not stack – i.e. you may have one and only one modifier at the beginning of a reference string.

The list of modifiers which may be applied is:

Description Modifier Function Notes
Scalar multiplier -12.345 Enter any number
Opposite
Absolute Value ABS()
Negative Absolute Value -ABS()
Reciprocal 1/X
Negative Reciprocal -1/X
Bump BUMP(<val>) ‘<val>’ is a numeric literal value
Add origin offset to Baseline +ORIGIN.OFFSET Converts from local to assembly coordinates
Subtract origin offset to Baseline -ORIGIN.OFFSET Converts from assembly to local coordinates
Add origin elevation to Baseline +ORIGIN.ELEVATION Converts from local to assembly coordinates
Subtract origin elevation to Baseline -ORIGIN.ELEVATION Converts from assembly to local coordinates
Multiply by ‘Side’ *SIDE() 1.0 for ‘right’; -1.0 for ‘left’
Integral Part INT()
Fractional Part FRACT()
Squared X^2
Square root SQRT()
Sine SIN()
Cosine COS()
Tangent TAN()
Arcsine ASIN()
Arccosine ACOS()
Arctangent ATAN()
Round RND(<n>) Rounds to ‘<n>’ decimal places
Format FMT(<fmt>) ‘<fmt>’ is a standard numeric formatting string

Extracting the Elevation of a 3D Offset Target

If you have an offset target that maps to a 3D entity in Civil 3D (such as a feature line, survey figure, or 3D polyline), it is possible to extract the elevation of that entity at the current station by appending the string “::Z (without the quotes) after the target reference (e.g. “\\XPOffsetTarget3D::Z”). For a 2D target entity, this will always return an elevation of 0.0.

Currently, there is no support within the user interface for appending this suffix to the offset target reference – you must manually type in the change once the base reference string has been constructed.

Referencing Entity Ids and Id Lists

Entity Ids and Id lists are similar to hard-coded/literal values – simply enter the id number, or in the case of a list, use commas to separate the numbers (no spaces). In some cases, ranges of numbers may be appropriate. In these situations you can use a range notation similar to the following example:

To include entity id’s 1,3,4,5, and 7, you can enter the list as: 1,3-5,7

Referencing RPN Expressions

RPN expressions may be manually typed in as a reference string, however, the syntax is fairly complicated and it is generally best to use the dialog boxes to create the string. An example of an RPN reference for sqrt(1+2) would be:

\\RPN:sqrt||+||2||1

Note that the ‘stack’ for the expression is given in reverse order in the reference string. In the example above, the corresponding RPN stack would be:

1
2
+
sqrt

Please refer to the RPN Expressions section of this document for further details.

Intellassembly

Intellassembly Targets

If you are using Subassembly Studio – Ultimate Edition, you will have another option available as a reference source: the Intellassembly Target Reference.

The functional part of this reference is the IAssy Target Properties field, which is configured using the dialog below:

The Index Offset refers to the relative position of the intended target relative to the current target. For example, to look at the current target, enter ‘0’ (as shown). To look at the next target, enter ‘1’; to look at the previous target, enter ‘-1’.

The Target Property field allows you to reference various properties of the target object, such as Offset or Extended Attribute Keys.

The XAttribute Key field accepts a user-defined Extended Attribute Key name, which corresponds to values stored for the target in Civil 3D.

The Layout Mode Value field accepts a hard-coded value to use in Layout Mode for drawing the subassembly Layout Mode geometry.

Alternate Indexing for the Intellassembly Target

The user interface described above provides a mechanism for selecting the Intellassembly Target by a fixed or static offset from the current target, and results in an index string that looks like [n], [n+1], [n-2], etc. Sometimes the exact number of targets between the current target and the target you need to look ahead or backward to is not known, or is not static. In these cases, it is useful to be able to look ahead or backward to a target based on its code or relative position. The following options describe how to index the targets thusly, and must be entered manually inside the square brackets in the target reference string after the base string has been constructed:

Behavior Indexer Syntax Notes
Look forward to the next target with the specified code ~>TargetCode Replace TargetCode with the actual code (literal string) you are targeting
Look backward to the next target with the specified code ~<TargetCode Replace TargetCode with the actual code (literal string) you are targeting
Look at the current offset for a target with the specified code ~TargetCode Replace TargetCode with the actual code (literal string) you are targeting
Look forward for the next target with an offset that is different than that of the current target !>
Look backward for the first encountered previous target with an offset that is different than that of the current target !<

Additional notes:

  • An Asterisk (*) may be used in the target code as a wildcard character.
  • If no target is found that satisfies the search condition, the value returned by the reference will be an empty (Null) string.

In addition to looking for target codes, you may also look to see whether a target contains a given Extended Attribute, collection of Extended Attributes, or a specified code AND Extended Attribute(s). To do this, replace TargetCode in the above syntax examples with a search string similar to the following:

^TargetXAttrib

TargetCode^TargetXAttrib

TargetCode^TargetXAttrib1|TargetXAttrib2|…|TargetXAttribN

RPN Expressions

Subassembly Studio uses ‘Reverse Polish Notation’ expressions to perform calculations. The expressions are entered using the RPN Calculator dialog:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5c9d1bd.PNG

Most people are conditioned to using Algebraic notation for performing calculations. While this works well for simple equations, it can be cumbersome and inefficient when performing large or complex calculations. RPN is equally efficient for either situation. RPN is also very efficient from a computational standpoint.

To those who have used the Hewlett Packard 48/49-series calculators, this will be very familiar; to those who use TI and other ‘regular calculators’, it will likely seem quite strange and alien at first.

Let’s say we want to add the scalar values 2 and 3 together. In Algebraic notation this calculation would look like this:

2 + 3

In RPN, we put the operands first, and follow with the operator or function. The same calculation written in RPN looks like this:

2 3 +

Or, expanded into ‘stack’ form, like this:

2

3

+

If we enter this exact calculation into the RPN Calculator in Subassembly Studio, we can see the values on the ‘stack’, and we can see the state of the stack both immediately before and immediately after the ‘+’ operation is executed:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5d3a81f.PNG

Now, let’s try a more complex calculation…let’s say we want to calculate 2+3+2*(4+5)-3*(1-2-3). In RPN, this would look like this:

2 3 + 4 5 + 2 * + 1 2 – 3 – 3 * –

The first group (yellow highlight) is added to the stack, and is reduced to a single number after the first ‘+’ operator is applied, just as we saw in the first example above. Then, the second group (cyan highlight) is evaluated and reduced to a single number. When the first grey highlighted ‘+’ operator is reached, there are two numbers on the stack – the ‘+’ operator now reduces this to one number. Now the third group is evaluated (dark cyan highlight), and is reduced to a single number. At the point where the last grey oparator (‘-‘) is reached, there are just two numbers on the stack. The ‘-‘ operator is applied and the entire expression is evaluated to a single number, which is returned by the RPN Calculator to be used as a referenced value, or to be stored directly into a variable or parameter.

There is another way we could evaluate this same expression:

2 3 + 4 5 + 2 * 1 2 – 3 – 3 * – +

In this case, each of the three groups is evaluated and results in a single number being placed on the stack. We then evaluate the first grey highlighted operator is reached, it is applied to the cyan and dark cyan groups. The last operator is then applied to this result and the yellow group.

There is no practical limit to the number of items which may be placed on the stack. This allows you to run several computations in a single RPN expression. This is especially helpful if you need to utilize any of the vector or summation operations/functions included in the Subassembly Studio RPN Calculator. It can also be a very efficient way of copying values from parameters and storing in variables.

Subassembly Studio includes RPN functions for basic arithmetic, exponents, roots, logarithms, and trigonometry. It also includes several vector functions for determining 2d slope/distance between points, interpolation between points, angle between 3 points (and 2-points relative to the positive x-axis), integral and fractional parts of a number, etc. It also includes conditional functions which take true and false value arguments along with ‘test’ and ‘datum’ values which are compared – the result of the comparison determines whether the true or the false value is returned. It is also possible to reference variables, parameters, and geometry, and to insert meaningful constants and values from the model such as current station and the ‘side’ constant (1.0 for ‘right; -1.0 for ‘left’). Last, there are ‘stack operations’ which may be used to duplicate, swap, or drop values from the stack, write values to variables or parameters, or add comments into the stack.

There is also a component that can be added to the stack which does not have a corresponding button in the calculator: ‘random’. Enter this at the text input box in the bottom left corner of the calculator and either hit the enter key or the enter button to the right of the text box. The function will be added to the stack and will produce a random number between 0.0 and 1.0. To trigger a new random value to be generated, type ‘re’ or ‘regen’ and hit the enter key. This won’t add anything to the stack, but it will cause it to be re-evaluated and any random numbers to be regenerated.

Exporting the Subassembly Catalog

NOTE: If you do not have a licensed copy of the application, you will not be able to run the subassemblies you create using the Subassembly Studio in AutoCAD Civil 3D without first purchasing a license. You will also be unable to export your subassembly catalog for use with AutoCAD Civil 3D.

The Subassembly Catalog Project may be exported to an Exported Subassembly Package file (.PKT) for importing into AutoCAD Civil 3D. To do this, select the File=>Export Catalog menu command, use the ‘Export Catalog’ command icon in the toolbar, enter ExportCatalog at the command prompt or right-click on the catalog name in the project explorer and select the Export Catalog command from the context menu:

Note that certain subassembly components may not be supported in all versions of Subassembly Studio. If you are running a limited version and you attempt to export a subassembly catalog which contains components not supported in your version, the catalog will not be exported. In this situation, you will be notified (via the Command History window) which subassemblies contain the unsupported components, and which components are unsupported.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML586c36a.PNG

Invocation of this command will bring up the Export Options dialog. In the Export Options dialog, you have the option of choosing your Target AutoCAD Civil 3D Platform (which version of AutoCAD Civil 3D you will be using your subassemblies with).

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5886bc9.PNG

There are several options in this dialog for sharing content with other users. While exported subassembly catalogs are generally usable only within the same company (see the licensing section of this document for more information), you may from time to time need to share your catalog with another company (e.g. a subcontractor, etc). In this situation, you may enter an arbitrary ‘Content Sharing Key’ – this can be anything you want. When you export the catalog, this key will be embedded into the generated assemblies. Send both the key and the matched exported catalog to the person or company needing to use your subassemblies. The other option is primarily for developers – it allows you to restrict the use of exported subassemblies for a specified number of days from the date you exported the catalog.

Clicking the OK button will bring up a SaveAs dialog. If you have previously exported your project, the name of the archive file last saved to will appear in the File name field. If not, the filename will default to the current catalog name.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML58e6b6c.PNG

During the export process, you will see a series of messages appear in the command history window:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML58fc54e.PNG

The very last line will contain the full path to the exported PKT file if successful. If the export process was unsuccessful for any reason, you will be notified here.

If the export process fails, you most likely have a naming conflict or illegal name, either in one or more of your parameter names, or one or more of your subassembly names (or both). The most common mistakes are to begin a catalog, subassembly, or parameter name with a number, or to use names that are identical when stripped of special characters and spaces. For example, using names similar to the following would cause the process to fail:

‘1stSlope’

 

‘Special Lane Subassembly’ and ‘SpecialLaneSubassembly’ in the same catalog

Importing the Subassembly Catalog in Civil 3D

NOTE: If you do not have a licensed copy of the Subassembly Studio Runtime, you will not be able to run the subassemblies you create using the Subassembly Studio in AutoCAD Civil 3D without first purchasing an appropriate license.

The process of importing your subassemblies to AutoCAD Civil 3D is very simple:

  • First, you need to make sure you have the Subassembly Studio Runtime installed and activated with an appropriate license. Please refer to the licensing section for more details on this.
  • Start AutoCAD Civil 3D if it is not already started.
  • Open the Tool Palettes window and create a new palette (or just use an existing one):
    C:\Users\akoerner\AppData\Local\Temp\SNAGHTML59e7d08.PNG
  • Right-click on the palette tab/header and select ‘Import Subassemblies…’
    C:\Users\akoerner\AppData\Local\Temp\SNAGHTML59e24cc.PNG
  • Select the file you exported from Subassembly Studio:
    C:\Users\akoerner\AppData\Local\Temp\SNAGHTML59f976b.PNG
  • Your new subassemblies are now ready to go:
    C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5a04150.PNG

Note that if you have not already installed the Subassembly Studio Runtime application, the importation process may fail, and the subassemblies will not function. Likewise, if your Subassembly Studio Runtime installation is not licensed, or is not licensed at the proper level, your subassemblies will also fail to run.

Configuring AutoCAD Civil 3D to use Custom Subassemblies

Configuring AutoCAD Civil 3D

Provided you have already installed and licensed the Subassembly Studio Runtime application, there is nothing to be done to configure AutoCAD Civil 3D to work with your subassemblies beyond what has already been done during the importation process.

AutoCAD Civil 3D Templates

There are a few reserved codes used by the Subassembly Studio that should be accounted for in your AutoCAD Civil 3D templates. If you look at the subassembly properties in the Subassembly Studio (in the Property Explorer), you will find the following code properties:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5a5dce4.PNG

These codes are used for special purposes when displaying the custom subassemblies in Layout Mode and when building the corridor model. You should create a custom style for each in your AutoCAD Civil 3D Template (DWT) in order to make your subassemblies appear correctly when drawn.

AttachmentPointCode: Create block in the shape of a diamond (or any other shape that is empty in the center). Create a new Marker Style and use this block as the marker symbol. Be sure to set the scale appropriately – you will want to make this marker just large enough that your other markers will appear fully inside of its shape. The Attachment Point is inserted with an index of 0 to ensure that its index will be static. The coordinates are matched to the last point created in your subassembly, or to a specified point. This allows AutoCAD Civil 3D to always connect subsequent subassemblies to the correct end point (it determines the connection point by index) regardless of the geometry created by the subassembly’s conditional logic, if any.

If you prefer, you can also create a ‘no display’ style for this point to effectively hide it.

FlowLinkCode: The FlowLinkCode is used only in Layout Mode to create the links that represent the logical paths in the subassembly geometry created when Conditional, Rollback, etc. Components are used. You should create an appropriate Link Style for this. It is recommended that you use a color that looks dim or washed out against the current background to indicate that the link is not a ‘real’ link.

NullElementCode: The NullElementCode is used when the corridor model is built. It is assigned to points that exist in Layout Mode, but are flagged as non-existing when the corridor model is built. As a means of preserving subassembly point indices, which are used by AutoCAD Civil 3D to determine which point to use when attaching additional subassemblies, these points will still be inserted in the corridor model if the MakeAllPoints subassembly property is set to True (recommended setting). The location of the points is determined by tracing the reference points specified in the logical path to the first ‘existing’ point on the path. They are coded with the NullElementCode so that you may prevent these points from being displayed. As such, the MarkerStyle you create for this code should display nothing.

PointExtensionLinkCode: This special link code is used in Intellassembly to graphically tie the pre-run loop origin point to the subassembly origin point. This code should typically match the FlowLinkCode setting, and is only used with Intellassembly.

Licensing

Subassembly Studio consists of two separately licensed application components: the Editor component, and the Runtime component.

The Subassembly Studio Editor is where you create your subassemblies. It runs outside of AutoCAD Civil 3D (and in fact, AutoCAD Civil 3D doesn’t even need to be installed on the same machine as Subassembly Studio).

The Subassembly Studio Runtime component is the part that allows your exported subassemblies to function in AutoCAD Civil 3D. It installs as an AutoCAD plugin and loads automatically when you start AutoCAD Civil 3D. The Subassembly Studio Runtime component is licensed separately from the Subassembly Studio Editor, and the Editor is not required to be on the same machine in order to use the Runtime component.

Activating Subassembly Studio

Editor

Subassembly Studio is activated using our online licensing service. You should be provided with the activation key/registration code by your reseller or vendor. This goes in the ‘top box’ of the activation dialog (see below).

The license mode option allows you to specify whether your activation key is for a ‘standalone’ (per machine) or network based license.

If using a network license, you must specify the path to a shared folder one of your servers. This path MUST be a location on a mapped drive where all users have both read and write access.

The Master Key Code is what allows you to keep your exported subassemblies secure by limiting their use only to others who activate Subassembly Studio with the same code. On the first install, you should use the ‘Create New Key’ button to generate a key. Copy this key and re-use it for all subsequent activations at your site.

If you connect using a proxy, you will need to have your IT staff provide the login credentials in order to connect to the licensing service.

If a connection cannot be made, it is possible to activate manually. In this event please contact product support for instructions.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML5b13bc5.PNG

Runtime

The Subassembly Studio Runtime component uses an activation dialog which is virtually identical to that which is used for the Editor component. Be sure to use the correct activation key for the Runtime component. Also, be sure to use the Master Key Code generated on the first installation or else you may not be able to run any of your exported subassemblies.

Licensing Options

For a complete description of the licensing options and the privileges/restrictions associated with each, please refer to the Subassembly Studio End User License Agreement (EULA) and the readme files installed with Subassembly Studio.

Tutorial – Superelevated lane with minimum subgrade slope

Planning a Custom Subassembly

Before you start building a custom subassembly, you must first determine what you want to achieve. The best way to accomplish this is to start with a sketch of the subassembly geometry. Determine the relationship of each point to the last, what order to insert the geometric components, how the geometric components will be coded, and what aspects of the subassembly will be dependent on user input. Once this is established, you can determine what subassembly parameters and internal variables are needed. With this information in hand, you are ready to create a custom subassembly.

For our example, we’ll create a superelevated lane subassembly (imperial units) consisting of a single pavement layer, plus a base and subbase layer. When complete, it will look something like this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML79d51a0.PNG

We’ll need the following Input Parameters (Parameter Data Type in parentheses):

  • LaneWidth (Double) Value = 12
  • PavementDepth (Double) Value = 0.3
  • BaseDepth (Double) Value = 0.5
  • SubBaseDepth (Double) Value = 0.75
  • Slope (DoublePercent) Value = -2%
  • SubgradeMinimumSlope (DoublePercent) Value = -3%
  • Superelevation (Superelevation) Value = DoNotUse
  • TopCode (String) Value = TOP
  • PaveCode (String) Value = PAVE
  • BaseCode (String) Value = BASE
  • SubBaseCode (String) Value = SUBBASE
  • DatumCode (String) Value = DATUM
  • OuterEdgePointCode (String) Value = ETW

We’ll also need some Target parameters to allow the user to target alignments and profiles at runtime to override the default width and calculated elevation (Parameter Logical Name Type in parentheses):

  • OffsetTarget (OffsetTarget)
  • ElevationTarget (ElevationTarget)

We might also want to output the actual pavement and subgrade slopes, plus the outer subgrade depth so that an adjacent subassembly could match the slope/depth of this one, so we will need the following output parameters:

  • PavementSlopeOut (DoublePercent) DefaultValue = 0.0
  • SubgradeSlopeOut (DoublePercent) DefaultValue = 0.0
  • SubgradeDepthOut (Double) DefaultValue = 0.0

We will code the top links with the codes TOP and PAVE, therefore we will need a variable to hold the value resulting from combining these two codes:

  • TopPlusPaveCode (String) DefaultValue = <empty>

We’ll also need variables to hold the values of the actual pavement slope, and the actual subgrade slope:

  • ActualPavementSlope (DoublePercent) DefaultValue = 0.0
  • ActualSubgradeSlope (DoublePercent) DefaultValue = 0.0

Creating a new Subassembly Catalog

Once you have a subassembly design, you need to either open an existing subassembly catalog project, or create a new catalog project, as shown below:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML79e3a87.PNG

Next, give the catalog a meaningful name (remember to adhere to the catalog naming conventions):

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML79fffc9.PNG

We also need to ensure that the catalog is configured for the correct system of measurement. To do this, check the catalog’s ‘Units’ property in the Property Explorer:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7a8bc44.PNG

Create a new Custom Subassembly

We now have an empty catalog file. The next step is to add a new subassembly. The easiest way to do this is to use the toolbar and press the ‘new subassembly’ command icon:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7a19bc9.PNG

When you issue the NewSubassembly command (by any method), you will be prompted to enter a name and description for the new subassembly. The name is required, and is subject to the naming conventions described earlier in this document. The description may be left blank if desired. Both fields may be changed later.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7a3ddc8.PNG

At this point, you will have a new subassembly in your catalog that consists of only an Origin geometry component. Note that you cannot remove the Origin, nor can you add additional Origins. You can, however, edit the Origin component properties.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7a4af88.PNG

Add Subassembly Parameters

With the new subassembly created, you are ready to add your Subassembly Parameters and Internal Variables. For our sample, we determined that we needed the following parameters:

Input:

  • LaneWidth (Double) Value = 12
  • PavementDepth (Double) Value = 0.3
  • BaseDepth (Double) Value = 0.5
  • SubBaseDepth (Double) Value = 0.75
  • Slope (DoublePercent) Value = -2%
  • SubgradeMinimumSlope (DoublePercent) Value = -3%
  • Superelevation (Superelevation) Value = DoNotUse
  • TopCode (String) Value = TOP
  • PaveCode (String) Value = PAVE
  • BaseCode (String) Value = BASE
  • SubBaseCode (String) Value = SUBBASE
  • DatumCode (String) Value = DATUM
  • OuterEdgePointCode (String) Value = ETW

Target:

  • OffsetTarget (OffsetTarget)
  • ElevationTarget (ElevationTarget)

Output:

  • PavementSlopeOut (DoublePercent) DefaultValue = 0.0
  • SubgradeSlopeOut (DoublePercent) DefaultValue = 0.0
  • SubgradeDepthOut (Double) DefaultValue = 0.0

To add the parameters, use the ‘Edit Subassembly Parameters’ command icon in the toolbar shown below:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7a63682.PNG

Input Parameters

First, let’s add our input parameters. Ensure that the parameter type filter is set to ‘Input Parameters’ and use the ‘Add’ button to create a new parameter. Next, change the Name, ParamDataType, and Value fields to the appropriate values. You may also enter a description if you wish. Repeat for all input parameters:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7ae6a00.PNG

Target Parameters

Now that the input parameters have been created, we need to create our Target Parameters. To do this, simply change the Parameter Type filter to Target Parameters and repeat the process described above for adding new parameters:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7b0e7c7.PNG

Note that in this case, instead of setting the parameter data type, you must set the ParamLogicalNameType property instead. This is critical – if you do not set this properly, the targets will not be usable.

Also note that there is an additional property here called ParamTargetRequired. If set to False, the subassembly will still execute if AutoCAD Civil 3D fails to find a target for the Parameter. If set to True, AutoCAD Civil 3D will abort the subassembly if it is unable to find the target for the Parameter.

Output Parameters

Now that the input and target parameters have been created, we need to create our Output Parameters. To do this, simply change the Parameter Type filter to Output Parameters and repeat the process described above for adding new parameters:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7b3636c.PNG

Internal Variables

Last, we need to add our internal variables to hold calculation results, etc:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7b9ae50.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7bbb256.PNG

Best Practice: Save Often

Now that we have all of our parameters and variables created, we are ready to start creating the subassembly geometry. Before we do that, this is a good point to save our work:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7b61e41.PNG

If you are working in an existing subassembly catalog project, the changes will be saved to the project file. If you are working in a new catalog file that has not yet been saved, you will be shown the Save As dialog box where you must enter the new catalog project filename:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7b7213e.PNG

After saving, you will notice that the subassembly catalog project path and filename are displayed in the application title bar:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7b7e670.PNG

Geometry Components

Add Geometry

We are now ready to add our geometric components to the subassembly. There are many possible ways to construct this subassembly. For example, we could construct it using a collection of discrete geometric components such as SlopeDeltaOffset, Vertical, NearVertical, etc, however there is a far more efficient way to do this using the ‘Structural’ geometric components. These are ‘complex’ components that create points, links, and shapes in a single operation.

Before we can construct any geometry, there is a bit of housekeeping that must be attended to. Specifically, we have two separate code parameters for ‘Top’ and ‘Pave’, and we need to combine these into one code list and store the results in a variable that can be used by our geometry. To do this, right-click anywhere on the viewport (except on the origin point marker) and select ‘Add Logical Component’:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7c3f445.PNG

The component we are looking for is ‘Combine Strings’. It is found under the ‘Strings’ category:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7c4cf86.PNG

Set the properties as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7c6462c.PNG

Several items to take note of here are:

  • Layout Delta Elevation/Offset: these properties are used to graphically ‘shift’ the marker that represents this component in the subassembly image/graphic displayed in the viewport. These properties have no effect on ‘runtime’ behavior.
  • ApplyInLayoutMode: in addition to checking the reference point, a check is made to determine whether the subassembly is being executed in ‘layout mode’, or if the corridor is actually being modeled (‘design’ mode). If set to ‘Yes’, this component will combine the input values and write the result to the target varaible (and/or parameter) when in layout mode as well as design mode; if set to ‘No’, it will only do this in ‘design’ mode.
  • IsHidden: Set to ‘Yes’ to force the point created for this component to a code of ‘_NULL’ (or whatever your ‘null code’ is set to) so that it will not be displayed in AutoCAD Civil 3D.

After adding this component, the subassembly graphic will look something like this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7cb3f49.PNG

The first geometric component to add is the ‘Structural Layer’. Right click on the viewport (anywhere except on the origin point marker) and select the ‘Add Point/Complex Geometry’ menu command to open the Add/Edit Geometry dialog:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7ccc5e6.PNG

Next, select the ‘Structural Layer’ component:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7c102e5.PNG

With the structural layer component selected, we can proceed to set the properties for the component:

First, let’s set our ‘codes’. The upper link code should be set to reference the variable we created for storing the combined top and pave codes:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7ceb89d.PNG

The remainder of the code properties should be set as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7d01231.PNG

Next, we set the geometry:

For the ‘Depth’ property, we reference the ‘PavementDepth’ parameter and apply a ‘negative absolute value’ modifier to it in order to make the component build in a downward direction relative to the reference point:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7d22d7e.PNG

The remainder of the geometric properties are set as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7d3da50.PNG

Note that we left the value for the ‘Lower Slope’ property blank. This tells the component to match the upper slope, whatever it may be.

Last, we need to set the ‘target parameters’:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7d5fc60.PNG

As configured, our lane now looks like this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7d6d6a8.PNG

At this point, we have the upper layer completed, and now have a means to calculate the ‘actual’ pavement slope from the geometric components created for this layer. The slope of the structural layer will be determined as follows:

If an elevation target is specified, the upper outside point will move to the target elevation; if not superelevation will be checked and used. If the superelevation is not specified, or if it is set to ‘do not use’, then the default slope will be used instead. In any case, the slope measured between point (4) (the upper outside point on the structural layer) and the origin point (1) will be the actual pavement slope. We should now set the variable we created to hold this value. To do this, we use a logical component:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7db44a6.PNG C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7dbff9b.PNG

We will use the value of the ‘slope’ property for point (4) as the ‘new value’, and will store the result to our variable:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7ddaaa9.PNG C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7de1fd8.PNG

Note that we could use an RPN expression here instead to set the value, or we could use the ‘Calculate Slope Between Points’ component. The solution presented above is the most simple and elegant for this application, but for other applications one or several of the other components may be more appropriate.

After doing this, our subassembly graphic will look similar to this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7def82c.PNG

Now that we have the actual pavement slope, we can set the actual subgrade slope. Recall that we have a ‘minimum’ slope parameter (currently set to -3%). The intention here is that the subgrade always slope down at a rate steeper than 3%, thus the use of the term ‘minimum’. Algebraically, this is actually a ‘maximum’ limit as a ‘steeper’ slope such as -5% is actually ‘less than’ -3%, therefore the value we want to ‘keep’ will be the ‘minimum’ of the two. The easiest way to set this value will be to use the MinMax logical component, configured thusly:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7e51482.PNG

While we could also set some of our output parameters at this point, we will defer that operation until the end.

We now have all of the information we need to construct the lower two layers. Next, let’s add the ‘Base’ layer. To do this, we add a ‘Structural Sublayer’ component (a ‘point/complex’ component found in the ‘structural’ category just under ‘Structural Layer’).

This component is similar to the ‘Structural Layer’ component, except that there is no top link created. Instead, the top link is ‘referenced’ (actually a collection of links is referenced) and the layer is built using the referenced link(s) as the upper boundary. We must also reference the points at which the component connects to the subassembly. Previously we had only one reference point for each component – here, we have 2. The first ‘reference point’ is for the upper inside (closest to center) point of the layer, which corresponds with the lower inside point created by the previously constructed structural layer, in this case point (2). The ‘upper outside point reference’ will be set to the lower outside point of the structural layer, point (3). We must also set a reference to the link or links that will form the upper boundary of this layer, specifically the bottom link of the pavement layer, link (3).

The depth will be the ‘negative absolute value’ of the ‘base depth’ parameter to ensure that it always builds in a downward direction.

The ‘lower slope’ should be set to the ‘ActualPavementSlope’ variable (technically we could also reference the ‘Slope’ property of point (4) here, but this value was already stored to the variable in order to make the subassembly more understandable and to avoid duplicating the calculation). Also noteworthy is that we do not set the superelevation here as it is already accounted for in the slope reference. If you set superelevation here and an elevation target was used to control the slope of the upper layer, the slope of this layer would not reflect the elevation target and would therefore be incorrect.

The remainder of the properties are set as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7f090c3.PNG

Our subassembly now looks like this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7f24bc8.PNG

We still need to create the bottom subbase/subgrade layer. To do so, we insert a new Structural Sublayer component and attach it to the bottom of the base layer, just as we attached the base layer to the pavement layer. The primary difference here will be that we will now reference the actual subgrade slope variable for the lower slope property:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7f77e2d.PNG

The geometry of our subassembly is now complete:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7f84350.PNG

The subgrade and pavement slopes are very close in value so it is somewhat difficult to visually verify that the subgrade slope limit is being applied correctly. To test this, we can modify the parameters and watch the subassembly react in near real time:

If the pavement slope is steeper than the minimum subgrade slope, we expect the subgrade slope to ‘follow’ the pavement slope. This is verified by setting the ‘Slope’ parameter to something steeper than -3%:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7fcbc65.PNG

As we can see, the layers are all parallel as expected, so this condition is behaving correctly. Next, let’s test by altering the pavement slope in the other direction…if the pavement slope moves in a positive direction, is the subgrade still limited to -3%?

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML7fe6013.PNG

Setting the slope parameter value and regenerating the subassembly confirms the correct behavior, so we know now that we have implemented the logic correctly. We can now reset the Slope parameter to its default value of -2%.

While we have constructed the geometry and have verified the behavior of the subgrade slope, we’re not quite done yet – we still need to set the output parameter values and identify which point should serve as the ‘attachment point’ for another subassembly to connect to (or else disable this feature, which is a perfectly acceptable alternative for this subassembly).

The easiest and most efficient way to set the output parameters will be to use the RPN Calculator component. If you are not familiar with RPN notation, click here for a primer. The RPN Calculator component may be found in the ‘Calculations’ category of the Logical Components. We’re going to use this component to perform several calculations and set several values in one operation. To do this we need to construct the RPN ‘stack’:

First, we retrieve the value for the ‘actual pavement slope’ (reference the variable we created…), and then we assign to the ‘PavementSlopeOut’ output parameter:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8063db5.PNG

Next, we repeat for the Subgrade slope:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML80727b5.PNG

And last, we need to perform a calculation to get the vertical distance between the upper and lower endpoints (outside) of the subbase layer:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8083e8f.PNG

This calculation looks like this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML809443a.PNG

At the point where the last operation is evaluated, the values on our ‘stack’ looks like this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML80a4e86.PNG

The column on the left shows the two point elevations highlighted in ‘dark cyan’; the column on the right shows the final result with the result of the last operation highlighted in ‘goldenrod’.

Note that we do not explicitly write the result of this last calculation to the output variable at this time. This is accomplished in the properties of the RPN Calculator component. The last value on the stack is written to whatever variable and/or parameter you specify as the ‘target’ of the calculation:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML80c7893.PNG

Now that the output parameters are taken care of, all that remains is to either disable the ‘attachment point’, or assign it to a proper location in the subassembly, which would be the upper outside point on the subassembly – point (4).

To disable, modify the subassembly properties as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML80e6909.PNG

To set it to point (4), use the logical component ‘SetAttachmentPoint’:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML80f5f1a.PNG

If setting the attachment point, you must set both the ‘reference’ and the ‘target’ point correctly. In this case the ‘reference point’ is not critical as all points are created for this subassembly. In other subassemblies that have conditional branching this becomes important. The target point is critical as this is the actual location that will be used to locate the attachment point. For this subassembly, we set both to point (4). Be sure to also set the ‘IsHidden’ property to ‘Yes’ as well. Doing so will not hide the actual attachment point, but rather just the point created for the ‘set attachment point’ component.

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML811b322.PNG

Don’t forget to save your work…

We have now completed the subassembly design and are ready to export the catalog for use with AutoCAD Civil 3D:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML82781e6.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML827cb16.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML828fdaa.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML829686d.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML82b38a7.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML82be615.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML82ce4ec.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML82c99c9.PNG

Variant #1 – Adding a gravel shoulder

There are several variants we might construct based on the superelevated lane subassembly we created in this tutorial, the first of which is to add a gravel shoulder (at the same slope as the lane) similar to this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8355338.PNG

To do this we will need a new parameter to control the gravel shoulder width. We will also need to add ‘Gravel code’ and ‘Edge of Shoulder Code’ parameters, and a ‘TopAndGravelCode’ variable (just like we did with ‘Top’ and ‘Pave’ previously). Then, we will need to combine the top and gravel codes, insert the gravel shoulder upper outside point and top link, and then modify the base layer accordingly. The subbase layer will not require modification.

To begin, we copy the subassembly in the catalog so that we do not modify the original:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8396909.PNG C:\Users\akoerner\AppData\Local\Temp\SNAGHTML83a71a1.PNG

We now need to rename the ‘copy’ to something more appropriate:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML83b6dca.PNG

Next, we modify the subassembly parameters and variables as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8471aac.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML83ebf24.PNG

Now that we have all of the required parameters and variables defined, we can proceed to modify the subassembly logic and geometry. The first thing to do is to combine the ‘top’ and ‘gravel’ codes and store the result in the ‘TopPlusGravelCode’ variable. To do this, we ‘insert’ another ‘CombineStrings’ component immediately after the previous instance (right click on the NEXT component access the context menu as shown below):

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML841b381.PNG

The properties for the inserted component will look like this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8434219.PNG

…and the modified subassembly will look similar to this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8444592.PNG

Next, we need to insert the new upper outside point and top link just in front of the base layer component:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML847e7f9.PNG C:\Users\akoerner\AppData\Local\Temp\SNAGHTML848aed0.PNG

We will insert a ‘Slope Delta Offset’ component as shown above. We will also take advantage of the feature which allows the automatic addition of a link between the new component and its reference point.

Because we allowed the lane width to be either positive or negative in the original subassembly (we never applied an ‘absolute value’ modifier to the original structural layer width), we need to make sure that the sign of the shoulder width value we use always matches that of the lane width parameter. The easiest way to do this will be to use an RPN Expression as the reference for the ‘delta offset’ property of our inserted point component:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML84d6034.PNG

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML84dd360.PNG

This RPN Expression retrieves the lane width, takes the absolute value, retrieves the lane width again and divides to obtain the ‘sign’ of the lane width (the result at this point will be either + or – 1.0). It then retrieves the value of the shoulder width parameter and removes its sign by taking the absolute value. The result is then multiplied by the ‘sign’ value at the top of the stack and the result of this last calculation is returned.

The remainder of the properties for the ‘Slope Delta Offset’ component should be configured as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML850f967.PNG

Note that we are using the variable containing the combined ‘top’ and ‘gravel’ codes for the ‘added’ link code, and we are using the actual pavement slope variable for the slope. The reference point is set to point (4), which if you will recall is the upper outside point of the pavement layer. The resulting change to the subassembly looks similar to this:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8556524.PNG

Now that we have established the location of the edge of the shoulder, and have created the link for the top of the gravel shoulder, we can modify the base layer to extend to the edge of the shoulder. To do this, we need to edit the parameters of the base layer component as follows:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML8575720.PNG

We changed the targeted ‘upper link ids’ to include the vertical at the outer end of the pavement layer, and the top link we added for the shoulder. We also updated the ‘upper outside point’ reference to point to the edge of the shoulder instead of the edge of the lane. The result is:

C:\Users\akoerner\AppData\Local\Temp\SNAGHTML858ea79.PNG

The subbase layer properties remain unchanged – the bottom outside of the base layer is still targeted, and because this point moved in response to the changes we made to the base layer properties, the subbase layer geometry is automatically updated to reflect this.

All that remains is to save and export the catalog, and to import the new PKT file into AutoCAD Civil 3D.

  1. ‘Flow’ is the old name for ‘Logical Components used in previous versions of Subassembly Studio
  2. Automatic determination of shape is supported in AutoCAD Civil 3D 2010 and newer versions only (currently only rectangular and circular pipes are supported). In AutoCAD Civil 3D 2009, the pipe shape is assumed to be circular, and the radius is calculated using the pipe part width.
 

The web store has been temporarily placed in demo/test mode while we update and test some new features. If you see this message and wish to make a purchase please contact sales@civilplus.net. Thank you.