Template BLD

Building Templates
About This Guide 3
Introducing ADAMS Template Builder 5
Working with Test-Rig Templates 17
Setting Up Communication Between Templates and Test Rigs 29

2 Building Templates
Copyright
U.S. Government Restricted Rights: If the Software and Documentation are provided in connection with a government
contract, then they are provided with RESTRICTED RIGHTS. Use, duplication or disclosure is subject to restrictions
stated in paragraph (c)(1)(ii) of the Rights in Technical Data and Computer Software clause at 252.227-7013.
Mechanical Dynamics, Incorporated, 2300 Traverwood Drive, Ann Arbor, Michigan 48105.
The information in this document is furnished for informational use only, may be revised from time to time, and should
not be construed as a commitment by Mechanical Dynamics, Incorporated. Mechanical Dynamics, Incorporated,
assumes no responsibility or liability for any errors or inaccuracies that may appear in this document.
This document contains proprietary and copyrighted information. Mechanical Dynamics, Incorporated permits
licensees of ADAMS® software products to print out or copy this document or portions thereof solely for internal use
in connection with the licensed software. No part of this document may be copied for any other purpose or distributed
or translated into any other language without the prior written permission of Mechanical Dynamics, Incorporated.
©2002 by Mechanical Dynamics, Incorporated. All rights reserved. Printed in the United States of America.
ADAMS ® is a registered United States trademark of Mechanical Dynamics, Incorporated.

All other product names are trademarks of their respective companies.
Part number: 120TEMBL-01

Building Templates 3
About This Guide
About This Guide
Welcome to Building Templates

Welcome to the ADAMS template-based products: ADAMS/Aircraft, ADAMS/Car,
ADAMS/Driveline, ADAMS/Engine powered by FEV, and ADAMS/Rail. The template-
based products are Mechanical Dynamics’ (MDI) industry-specific virtual prototyping
software.
The template-based products expand the full-simulation package to provide you with
standard building blocks and analyses, so you can rapidly prototype your real system, such
as engines, car suspensions, and rail cars. They offer fully parametric modeling
techniques, so for example, if you move one entity, its dependents move accordingly.
The template-based products consist of two interfaces: Standard Interface and Template
Builder. This guide introduces you to the Template Builder interface, provides an
overview of the system architecture, and explains the role of communicators. The
information in this guide is common to all template-based products. For information
specific to a certain template-based product, please see the guides associated with that
product:
■ Road Map to ADAMS/Aircraft Documentation
■ Road Map to ADAMS/Car Documentation
■ Road Map to ADAMS/Driveline Documentation
■ Road Map to ADAMS/Engine Documentation
■ Road Map to ADAMS/Rail Documentation
What This Guide Assumes

This guide assumes that you have a basic understanding of modeling concepts for the types
of systems you will create using your template-based product.
About This Guide
1 Introducing ADAMS Template
Builder
Overview
Using ADAMS Template Builder, you can assemble standard
components, such as springs, parts, and bushings, to define the
topology of your system, such as a suspension or a single valve
train in an engine. Templates are the foundation on which you
create topological systems.
This chapter gives an overview of using templates:
■ Architecture of Template-Based Products, 6
■ File Architecture, 7
■ Getting Started with ADAMS Template Builder, 14

Introducing ADAMS Template Builder
Architecture of Template-Based Products

Templates are topological representations of a system. They define how the components
that make up a system connect. A system could be a single set of components or a complex
collection of components. For example, a simple system could be an anti-roll bar, while a
complex system could be a 24-valve valvetrain system.
For more information about templates, see Templates on page 9.
The two interfaces that make up the template-based products are:
■ Standard Interface - You use it when working with existing templates to
create and analyze the performance of your systems. Both standard users and
expert users can use ADAMS Standard Interface. ADAMS Standard Interface
will have a different look and feel, depending on the ADAMS template-based
product you are using: ADAMS/Car, ADAMS/Engine, or ADAMS/Rail.
■ Template Builder - If you have expert user privileges, you use ADAMS
Template Builder to create new templates for use in ADAMS Standard
Interface, as well as modify existing templates. You can start with the default
templates that MDI provides or you can create your own.
For information on setting up user access, see Setting User Privileges on page 34 of the
guide, Configuring Template-Based Products.
File Architecture
The file architecture of the ADAMS template-based products is comprised of the
following types of files which are stored in databases:
■ Property Files, 9
■ Templates, 9
■ Subsystems, 11
■ Assemblies, 13
Figure 1 on page 8 shows an example of how template-based products use this
architecture: a template uses property files to provide data for components such as springs,
dampers, bushings, and so on.
When creating a new subsystem, you can reference the property files that the template
references, or reference other property files held either in a different database or with a
different file name, as indicated by the dashed lines in Figure 1 on page 8. A collection of
subsystems merged together forms an assembly.
Figure 1. Front Suspension Assembly with Steering
Property File Property File

Suspension Steering
Template Template
Property File
Property File
Property File
Subsystem Subsystem
File File
Test Rig
■ Suspension
■ Full Vehicle
■ User-Defined
Assembly
Property Files
Property files contain data for modeling components, such as valve spring, cams, and
bushings. Because property files are flat text files, you can use any text editor to create or
modify them.
You can reference property files in different subsystems and templates. Figure 1 on page 8
shows how you can reference property files.
All property file types are specified in the configuration file (acar.cfg). When you edit
property files, you can save them either with the existing file name or with a new file name.
For information about managing property files, see Managing: Property Files Through
Configuration Files on page 43 in the guide, Configuring Template-Based Products.
A subset of property files define force-displacement or force-velocity characteristics for
springs, dampers, bumpstops, reboundstops, and bushings. For those components, you use
the Curve Manager to create, edit, and view property files. You can access the Curve
Manager from the Tools menu. From within dialog boxes, you can edit property files using
the Curve Manager tool and view property files using the View File tool .
Templates
Templates are parametric ADAMS models, built by expert users within ADAMS
Template Builder. Templates define the default geometric data and topology of models.
The components within a template are parametrically defined such that you can use a
single template to represent numerous subsystems. For information on components, see
Component Descriptions on page 17 in the guide, Component Descriptions.
Templates provide a quick way to experiment with different subsystems and still retain the
basic design components that are required. For information on subsystems, see
Subsystems on page 11.
A template in its most fundamental form cannot be used in ADAMS Standard Interface
without first being referenced by a subsystem file. Figure 2 on page 10 shows how the
combination of a template and a subsystem file can make geometric changes to the base
template. In the example shown, in ADAMS/Car you could use a subsystem file to
transform the left-hand-drive vehicle to a right-hand-drive vehicle by modifying the
hardpoint locations at each point in the steering column.
Figure 2. Generating a Subsystem
Template
Subsystem file
Subsystem
You can modify the data of a template by changing the values of design parameters.
Hardpoints, parameter variables, and property files are the design parameters of templates,
where:
■ Hardpoints define locations for geometry, attachments, and construction frames.
■ Parameter variables contain strings, integers, and real values that you can
modify in the Standard Interface and store in the subsystem file.
■ Property files are referenced by some components.
For more information about hardpoints, parameter variables, and other components, see
Component Descriptions on page 17 in the guide, Component Descriptions.
Templates contain communicators to enable the exchange of information with other

templates. For information on communicators, see Setting Up Communication Between
Templates and Test Rigs on page 29.
You can save templates in either ASCII or binary format. To learn about the advantages
of saving in either format, see Saving Templates on page 16.
For information about templates specific to your template-based product, see the product-
specific guide. For example, for information about ADAMS/Car templates, see the guide,
ADAMS/Car Templates.
Subsystems
You only use subsystems in ADAMS Standard Interface. You can either create new
subsystems or read in existing ones. When you create a new subsystem, you must
reference an existing template. When you use an existing subsystem, the template
associated with it is automatically read in.
Subsystems are based on templates and allow standard users to change the parametric data
of the template as well as the definition of some of the components. For example, you can
change the location of hardpoints and modify parameter variables. Figure 2 on page 10
shows how in ADAMS/Car you can use a subsystem file to transform a left-hand-drive
vehicle to a right-hand-drive vehicle by modifying the appropriate hardpoints.
ADAMS template-based products organize the basic components that make up a full
assembly or subassembly into subsystems. For example, subsystems can include
suspensions, wheels, drivelines, chassis, and so on.
You create subsystems by selecting a template that defines the topology and default data
for your subsystem. Using the Standard Interface, you can modify the default data to
match your design. MDI supplies several templates with each product. For example, for
ADAMS/Car users, MDI supplies templates that represent MacPherson strut and double-
wishbone suspension subsystems. Using the Template Builder you can create templates
for your company-specific topologies.
Subsystems contain descriptions of the component that they model. These descriptions
consist of:
■ Design data, such as wheel radii, toe angles, and locations of various points in
the subsystems, called hardpoints, mass properties of parts, and so on.
■ References to property files that contain design data for bushings, bumpstops,
dampers, engines, springs, and tires. A bushing property file, for example,
contains a description of the bushing’s stiffness and damping characteristics.
■ Reference to a template that defines the subsystem’s construction, including the
kinds of parts and how the parts interact and attach to one another. For example,
a template that defines a rack and pinion steering system defines a rack part, a
pinion part, and a housing part. It also defines that the rack slides in the housing,
that the pinion rotates in the housing, and that the rack and pinion are geared
together. Since the construction of all rack and pinion steering systems is
similar, all subsystems describing a rack and pinion steering system can
reference the same template.
A major role is a property of a template. A subsystem inherits the major role of the type
on which it is based. Examples of major roles are suspension, steering, and body.
A minor role defines the subsystem’s location. For example, a minor role can be front or
rear.
In ADAMS Standard Interface, you can create, read in, or solve subsystems.
You save subsystems in ASCII format, and you can publish subsystems to databases so
other users can share them. We support two formats: Teim Orbit and XML. For
information about those formats, see the online help. For information on publishing
subsystems, see Publishing a Subsystem on page 24 in the guide, Configuring Template-
Based Products.
Assemblies
Assemblies represent a collection of subsystems, along with a test rig, which when
assembled form a system that you can analyze using ADAMS/Solver. To learn about test
rigs, see Working with Test-Rig Templates on page 17.
In ADAMS/Car for example, a steering subsystem and a front-suspension subsystem, plus
a suspension test rig, form the basis of a suspension assembly that you can analyze for
kinematic behavior.
In ADAMS Standard Interface, you can create, open, save, and analyze assemblies. You
can also publish assemblies to databases so other users can share them. For information on
publishing assemblies, see Publishing an Assembly on page 25 in the guide, Configuring
Template-Based Products.
Getting Started with ADAMS Template Builder

The following sections introduce you to ADAMS Template Builder:
■ Accessing ADAMS Template Builder, 14
■ Opening Existing Templates, 15
■ Creating Templates, 15
■ Saving Templates, 16
Accessing ADAMS Template Builder

You must have expert user privileges to use ADAMS Template Builder. For information
on setting up user access, see Setting User Privileges on page 34 of the guide, Configuring
Template-Based Products.
To access ADAMS Template Builder:

Depending on the configuration you are using, you can access ADAMS Template Builder
as follows:
■ From the Welcome dialog box, select Template Builder, and then select OK.
■ From ADAMS Standard Interface, from the Tools menu, select ADAMS Template
Builder.
Opening Existing Templates

When using ADAMS Template Builder for the first time, we recommend that you first
open some of the example templates we provide and familiarize yourself with them.
To open an existing template:
1 From the File menu, select Open.

The Open Template dialog box appears.
2 Right-click the Template Name text box, point to Search, and then select
<shared>\templates.tbl.
3 Double-click the template of interest.

4 Select OK.
Notice that once the template is open, the Edit and Build menus become active. We
recommend that you familiarize yourself with each menu item.
Creating Templates
To create a new template:
1 From the File menu, select New.

The New Template dialog box appears.
2 Assign a name to the template.
3 Depending on the template-based product you are using, select a major role for the
template.
4 Select OK.
Saving Templates
Using ADAMS Template Builder, you can save your files in ASCII or binary format.
Saving your files in ASCII format provides the benefit of small file sizes and being human
readable. On the other hand, saving your files in binary format ensures faster processing,
but does not have the benefits associated with ASCII format.
Note: For ADAMS/Engine and ADAMS/Rail, the ASCII template format is EDS. We
recommend that you do not hand edit EDS files because it is difficult to maintain
the correct structure.
To save a template:
1 From the File menu, select Save or Save As.

2 Fill in the dialog box.
3 Select OK.
2 Working with Test-Rig Templates
Overview
You can extend the functionality of your templates by
converting them into test-rig templates, also referred to as test
rigs.
This chapter describes how you can work with test rigs:
■ About Test Rigs, 18
■ Process Overview, 18
■ Creating Test-Rig Templates, 19
■ Saving Test-Rig Templates, 20
■ Converting Templates into Test Rigs, 22
■ Adding Test Rigs to Binaries, 26

Working with Test-Rig Templates
About Test Rigs

In the ADAMS template-based products, test rigs are almost completely comparable to
regular templates. The basic topological difference between test rigs and regular templates
is that besides containing parts that are attached using attachments and forces, test rigs also
contain actuator elements, such as motions and forces, to excite the assembly. Just like
regular templates, test rigs also contain communicators to enable the exchange of
information with other templates.
You use test rigs when creating assemblies. A collection of subsystems and a test rig form
an assembly.
Note that the name of a test rig is always preceded by a period and two underscores, that
is .__. For example, .__MY_TESTRIG. This is a convention used by all template-based
products to differentiate between templates (._), subsystems (.), and test rigs (.__).
Process Overview
The process of working with test-rig templates involves the following steps:
For ADAMS/Car and ADAMS/Rail:
1 Creating a template and saving it in ASCII format as explained in Creating Test-Rig

Templates on page 19 and Saving Test-Rig Templates on page 20.
2 Modifying the ASCII template file to become an ASCII command file, which is
now the test rig, as explained in Converting Templates into Test Rigs on page 22.
3 Saving the ASCII command file into a binary file as described in Adding Test Rigs
to Binaries on page 26.
For ADAMS/Engine:
1 Creating a template and saving it in ASCII format as explained in Creating Test-Rig

Templates on page 19 and Saving Test-Rig Templates on page 20.
2 Opening the test rig as explained in Opening Test-Rig Templates in
ADAMS/Engine on page 20. You can optionally add your test rig to a binary as
described in Adding Test Rigs to Binaries on page 26.
3 Modifying test rigs, as described in Modifying Test-Rig Templates in
ADAMS/Engine on page 21. If you modified the test-rig template after you added
it to a binary, you must repeat the steps outlined in Adding Test Rigs to Binaries on
page 26, to reflect the changes you made to the test-rig template in your private or
site binary.
Creating Test-Rig Templates

You create test-rig templates the same way you create regular templates.
To create a test-rig template:
1 From the File menu, select New.

The New Template dialog box appears.
2 Assign a name to the template.
3 Depending on the template-based product you are using, select a major role for the
template:
❖ For ADAMS/Car and ADAMS/Rail, you set the major role to analysis, as
explained in Major Role on page 23.
❖ For ADAMS/Engine, you set the major role to testrig.
4 Select OK.
Note: You must specifically set the minor roles of communicators in test-rig
templates to any. Do not set them to inherit. You set the minor roles to any
because generally a template test rig should be capable of connecting with
any subsystem.
Saving Test-Rig Templates

You can save test-rig templates to files, just as you would save regular templates. We
recommend that you save test rigs in ASCII format so you can hand edit them. Storing
test-rigs in ASCII format also ensures portability from one machine to another. It allows
you, for example, to use the same file when building a site binary on either a UNIX or NT
machine.
To save test-rig templates:
1 From the File menu, select Save or Save As. Using these options, you can save your
test-rig templates in binary or ASCII format.
2 Fill in the dialog box.
3 Select OK.
4 Depending on the template-based product you are using, continue as follows:
❖ If working in ADAMS/Engine, go to Opening Test-Rig Templates in
ADAMS/Engine on page 20.
❖ If working in ADAMS/Car or ADAMS/Rail, go to Converting Templates
into Test Rigs on page 22.
Opening Test-Rig Templates in ADAMS/Engine

To use an ADAMS/Engine test rig in the Standard Interface, you must first open the test
rig.
To open a test rig:
1 From the File menu, point to Open, and then select Test Rig.
2 Right-click the Test Rig Name text box, point to Search, and then select the database
you want to search.
3 From the Select File dialog box, double-click the name of the test rig you want to
use.
4 Select OK.
Modifying Test-Rig Templates in ADAMS/Engine

In ADAMS/Engine, you can modify your test-rig template in the Template Builder in the
same way you would modify a regular template.
To modify a test rig:
1 From the File menu, select Open.

2 Right-click the Template Name text box, point to Search, and then select the database
you want to search.
3 From the Select File dialog box, double-click the name of the test-rig template you
want to use.
4 Select OK.
5 Modify the test-rig template as needed.
6 Make sure you save the test-rig template, as explained in Saving Test-Rig
Templates on page 20.
7 If you modified the test-rig template after you added it to a binary, you must repeat
the steps outlined in Adding Test Rigs to Binaries on page 26, to reflect the
changes you made to the test-rig template in your private or site binary.
Converting Templates into Test Rigs

To convert templates into test rigs you must make the following modifications to your
ASCII test-rig template file generated from your template-based product:
■ Removing the Header Information, 22
■ Modifying ADAMS/View Variables, 23
Removing the Header Information

You must remove the header information that is added at the beginning of the ASCII
template file because the command file reader will not understand the information stored
in this header and will output errors.
The following example shows a typical header from an ASCII template file:
$---------------------------------------------------------------------MDI_HEADER
[MDI_HEADER]
FILE_TYPE = ’tpl’
FILE_VERSION = 13.3
FILE_FORMAT = ’ASCII’
HEADER_SIZE = 9
(COMMENTS)
{comment_string}
’Simple Double Wishbone Suspension’
$---------------------------------------------------------------------TEMPLATE_HEADER
[TEMPLATE_HEADER]
MAJOR_ROLE = ’suspension’
TIMESTAMP = ’1999/07/15,17:21:32’
HEADER_SIZE = 5
You should remove all the lines from the beginning of the file up to, and including, the line
containing the HEADER_SIZE attribute.
Modifying ADAMS/View Variables

Templates and test rigs in template-based products have information that is stored in
ADAMS/View variables to determine how the template is used. All templates, including
test rigs, have three required variables: major role, minor role, and model class. Test rigs,
however, have an additional required ADAMS/View variable called test rig class.
When you create the test-rig template, your template-based product automatically creates
the first three variables. You must, however, manually create the last variable, the test rig
class variable.
The following sections introduce the variables:
■ Major Role, 23
■ Minor Role, 24
■ Model Class, 24
■ Test-Rig Class, 25
Major Role
The major role of templates and test rigs is stored in an ADAMS/View variable called role.
The major role of a test rig is always analysis.
When creating a test rig, make sure that you set the major role as shown next:
variable create &

variable_name = .__acme_4PostRig.role &
string_value = "analysis" &
comments = "Memory for ADAMS/Car major role"
Minor Role
The minor role of templates and test rigs is stored in an ADAMS/View variable called
minor_role. The minor role of a test rig is typically any. Setting the minor role to any is very
important if you are designing a test rig that is supposed to work with other subsystems
that can have different minor roles.
In ADAMS/Car for example, a suspension test rig should work with either front, rear, or
trailer-type suspensions. If the minor role of the test rig were defined as front, the test rig
would hook up only to front suspensions.
Set the minor role as shown next:
variable create &

variable_name = .__acme_4PostRig.minor_role &
string_value = "any" &
comments = "Memory for ADAMS/Car minor role"
Model Class
Every assembly in template-based products has a specific model class. The model class of
an assembly is stored in an ADAMS/View variable called model_class. Your template-
based product automatically creates this variable when you create the assembly.
Currently, in template-based products, there are four model classes defined: template,
subsystem, testrig, and assembly.
Set your model class as shown next:
variable create &

variable_name = .__acme_4PostRig.model_class &
string_value = "testrig" &
comments = "Memory for ADAMS/Car model class"
Test-Rig Class
You can associate any test rig with a particular class of assembly. In ADAMS/Car for
example, the test rig .__MDI_SUSPENSION_TESTRIG is associated with suspension
assemblies. The assembly class of a test rig is stored in an ADAMS/View variable called
testrig_class.
Set the test rig class as shown next:
variable create &

variable_name = .__acme_4PostRig.testrig_class &
string_value = "full_vehicle" &
comments = "Memory for ADAMS/Car testrig class"
You can reference the variable testrig_class directly from the graphical user interface. In
ADAMS/Car for example, this variable is used in the suspension assembly and the full-
vehicle assembly dialog boxes. Each of these two dialog boxes contains an option menu
from which you can select the test rig to be included in the new assembly. The option menu
will only contain test rigs that are compatible with the particular class of assembly you
specified.
The following steps shows how you can reference testrig_class from the ADAMS/Car
interface. You can follow the same basic steps for the other template-based products.
To reference testrig_class from the interface:
1 From the File menu, point to New, and then select Suspension Assembly.
The New Suspension Assembly dialog box appears.
2 Set the Suspension Test Rig option menu to the desired test rig. Notice that the
option menu only lists those test rigs that have a test rig class of suspension.
Adding Test Rigs to Binaries

Adding a test rig to your private or site binary makes it available for use whenever you
start a private or site session. For information on the process of creating private and site
binary files see Creating Private and Shared Libraries on page 31 in the guide
Customizing Template-Based Products.
The following sections describe how you can add test rigs to binaries for your specific
template-based product:
■ Adding Test Rigs to Binaries in ADAMS/Car, 26
■ Adding Test Rigs to Binaries in ADAMS/Engine, 27
■ Adding Test Rigs to Binaries in ADAMS/Rail, 27
Adding Test Rigs to Binaries in ADAMS/Car

You should move the test rig you modified from the template table (templates.tbl) in your
template-based product databases to a directory that contains the source for the custom
private or site binary file. Typically, you will need to create custom analysis macros that
work with the new test rig. All these files should be located in the same directory structure.
For example, you could enter this command in the acar_build.cmd file to read the test rig:
file command read &

file=(eval(getenv("MDI_ACAR_SITE")//"/analysis/models/acme_4PostRig.cmd"))
When you add this command to the acar_build.cmd file, ADAMS/Car reads in and stores
the test rig in the private or site binary, making the test rig available for use whenever you
start an ADAMS/Car private or site session.
As as additional option, you can rename your test rig file from the .tpl extension to a .cmd
extension to reflect the fact the test rig is now a command file.
For information on creating macros, see Running an Analysis and Creating a Macro on
page 25 in the guide, Customizing Template-Based Products.
Adding Test Rigs to Binaries in ADAMS/Engine

To open the test rig, enter this command in the aengine_build.cmd file:
acar files open testrig &
testrig="<private>/templates.tbl/_my_testrig.tpl"
When you add this command to the aengine_build.cmd file, ADAMS/Engine reads in and
stores the test rig in the private or site binary, making the test rig available for use
whenever you start an ADAMS/Engine private or site session.
Adding Test Rigs to Binaries in ADAMS/Rail

To open the test rig, enter this command in the arail_build.cmd file:
file enhanced_data_set read &

file_name = (eval( getenv("MDI_ARAIL_SITE")//"analysis/models/my_testrig.tpl" ))
When you add this command to an arail_build.cmd file, ADAMS/Rail reads in and stores
the test rig in the private or site binary, making the test rig available for use whenever you
start an ADAMS/Rail private or site session.
As an additional option, you can rename your test-rig file from the .tpl extension to a .cmd
extension to reflect the fact the test rig is now a binary command file.
3 Setting Up Communication Between
Templates and Test Rigs
Overview
Communicators are the key elements in template-based
products. Communicators facilitate the exchange of
information between subsystems, templates, and the test rig
in your assembly.
This chapter describes how you use communicators and the
different communicators in the templates.
■ Types of Communicators, 30
■ Communicator Class, 30
■ Communicator Roles, 32
■ Communicator Naming, 33
■ Matching Communicators During Assembly, 34
■ Matching Communicators with Templates, 35
■ Displaying Communicator Information, 35
■ Testing Communicators, 36
Setting Up Communication Between Templates and Test Rigs
Types of Communicators
An assembly requires two directions of data transfer between its subsystems. To provide
for these two directions of data transfer, the template-based products have two types of
communicators:
■ Input communicators - Request information from other subsystems or test
rigs.
■ Output communicators - Provide information to other subsystems or test rigs.
In ADAMS/Car for example, a mount communicator in the rack and pinion steering
templates outputs the rack part name so that tie rods of suspension templates can attach to
the rack. In addition, a mount communicator in the steering template inputs a part name.
The steering template uses the part name to determine where to attach the steering column.
Communicator Class
The class of a communicator indicates the kind of information it exchanges. For example,
communicators of the class hardpoint exchange a location through a hardpoint name and
a part name. The classes of communicators and the information that each class exchanges
are listed in Table 1 on page 31. The classes apply to both input and output
communicators.
In ADAMS/Car and ADAMS/Rail, communicators can be either single or be part of a
symmetrical pair, either left or right. Entity classes (array, differential equation, motion,
parameter variable, solver variable, spline) have no symmetry and, therefore, are always
single, by default.
In ADAMS/Engine, all communicators are single.
Table 1. Communicator Class
The class: Exchanges:
Mount Part name to provide connections between subassemblies. As a

shortcut, the template-based products also automatically create
input mount communicators when you create a mount part.
Marker Construction frame and part name to provide both location and part
information. If the construction frame is part of a symmetrical pair,
the template-based products create an input communicator for each
construction frame in the pair.
Joint Joint name.
Joint-for-motion Joint name.
Bushing Bushing name.
Array ADAMS/Solver array name.
Spline Spline name.
Differential Differential equation name.
Solver variable ADAMS/Solver variable name. You must use an ADAMS/Solver
variable and not an ADAMS/View variable. Unlike an
ADAMS/View variable, an ADAMS/Solver variable’s
computation occurs during analysis. ADAMS/Car generates
ADAMS/Solver variables as state variables.
Location The location of the named hardpoint or construction frame. If the
hardpoint is part of a symmetrical pair, the template-based products
create two input communicators, one for each hardpoint in the pair.
Motion Motion name.
Part Part name.
Orientation The orientation of the named construction frame.
Real parameter A parameter variable name of the type real.
Integer parameter A parameter variable name of the type integer.
Communicator Roles
Each communicator has a minor role. A minor role defines the communicator’s position
in the assembly. The template-based products provide you with minor roles, as shown in
the following table:
Table 2. Communicator Minor Roles
This template-based product: Has these communicator minor roles:
ADAMS/Car ■ any
■ inherit
■ front
■ rear
■ trailer
ADAMS/Engine ■ any
■ inherit
For a list of the rest of the minor roles available for
ADAMS/Engine, see the dialog box help.
ADAMS/Rail ■ any
■ inherit
■ front
■ middle
■ rear
You can define a communicator’s minor role when you create it. For example, if you want
to provide input to or output from subsystems of specific roles, then you set the minor role
for communicators when you create them. We recommend, however, that you do not set
a communicator’s minor role. Instead, let the subsystem do it. For example, in
ADAMS/Car a suspension template might be used to define either a front or rear
suspension subsystem. By letting the subsystem determine the minor role, the assembly
process attaches a steering system to the front suspension and not to the rear.
Communicator Naming
After you create a communicator, your template-based product assigns a prefix to the
name. For example, it creates a prefix, cil_ where:
■ ci indicates it is an input communicator. If it were an output communicator, the
template-based product would use co.
■ l indicates it is for the left side of a symmetrical pair. If it were for the right side,
the template-based product would use an r. If it were a single communicator, it
would have an s (cis).
Note: ADAMS/Engine uses only single communicators.
If you create a mount part, your template-based product automatically creates an input
communicator of the class mount. It uses the name of the mount part as the name of the
communicator and appends the prefix ci[lrs]_ to it, depending on whether or not it is a left,
right, or single communicator. For example, if you create a mount part of mtl_rack_mount,
your template-based product creates an input communicator with the name
cil_rack_mount, where the l indicates it is for the left side.
As you name communicators, you should ensure that any input and output communicators
that exchange information have matching names. In ADAMS/Car for example, the name
you give to communicators that exchange a part name during assembly might be
ci_strut_mount and co_strut_mount. In addition, if you are working with MDI templates,
you must ensure that you use the same naming conventions as the MDI templates. For
more on matching communicators, see Matching Communicators During Assembly on
page 34.
Matching Communicators During Assembly

For a pair of communicators to exchange information during assembly, the
communicators must:
■ Have matching names.
■ Be of opposite types (one input, one output).
■ Be of the same symmetry type (left, right, or single).
■ Be of the same class (exchange the same type of information).
■ Have the same minor role or be assigned a role of any.
Note: For ADAMS/Rail, in order to match, the communicators must belong to a

subsystem with the same wagon order. For information on Wagon Order
definition, see Wagon Order on page 6 of the guide, Building Templates in
ADAMS/Rail.
If an input communicator does not have a corresponding output communicator, your

template-based product returns a warning message, and, if the input communicator
belongs to the class mount, the template-based product assigns the mount part to ground.
You can still analyze the model even if it does not have matching communicators. In fact,
you may find this helpful if you want to run an analysis of a subsystem without attaching
another subsystem to it.
In ADAMS/Car for example, the following pairs of input and output communicators
match and exchange a part name during assembly.
Table 3. Sample of Matching Input and Output Communicators
The pair: Belongs to the class: From minor role: To minor role:
cil_strut_mount mount front
col_strut_mount mount front
cil_strut_mount mount any
col_strut_mount mount front

Table 3. Sample of Matching Input and Output Communicators (continued)
The pair: Belongs to the class: From minor role: To minor role:
cil_strut_mount mount front
col_strut_mount mount any
You can match an input communicator with only one output communicator. You can,
however, match an output communicator with any number of input communicators.
You should always check the warning messages during the assembly, especially if the
warning refers to an input communicator of class mount that does not get assigned and is,
therefore, attached to ground.
Matching Communicators with Templates

To ensure that an analysis will work with your new template, when you create a template
you must make sure that the template is compatible with other templates and with the test
rigs. The template must contain the proper output communicators.
Displaying Communicator Information

You can display information about communicators in each template or test rig. The
communicator information includes the names of the communicators, their classes, and
minor roles. You can choose to display all types and classes of communicators in the
templates and test rigs or display only a specified set of types and classes.
To display information about communicators:
1 From the Build menu, point to Communicator, and then select Info.
The Communicators Info dialog box appears.
Tip: For more information on any dialog box, press F1 when the dialog box is
active.
2 In the Model Names text area, enter the names of the templates or test rigs about
which you want to display communicator information.
3 From the Type option buttons, select the type of communicators (input, output, or
all), about which you want to display information.
4 From the Entity option buttons, select one of the following:
■ To display information about only certain classes of communicators, select Many.
If you select Many, select the classes of the communicators from the list that
appears below the option buttons.
■ To display information about all classes of communicators, select All.
5 If you’ve used the Information window before and you want to clear it, select Clear
Information Window.
6 If you want to save the results to a file, select Save Test Results to File and then enter
the name of the file in the File Name text box.
7 Select OK.
The Information window appears. It displays the communicator information for
each template or test rig, grouped by each class of communicator that you selected.
Testing Communicators
You can perform a test to verify that you have correctly specified input and output
communicators in your template. You can use this test to determine whether or not you
need to add or modify communicators to correctly create an assembly.
When you perform the test, you specify the model names of one or more existing templates
or test rigs. Although you can specify a single template, you should specify all the
templates containing communicators that transfer information between the selected
template. You must specify a minor role for each template, subsystem, or test rig you
chose to test.
After you perform the test, your template-based product lists the matching input and
output communicators, the unmatched input communicators, and the unmatched output
communicators for the templates, subsystems, and test rigs you selected.
You can save the test information to a file.
To test your communicators:
1 From the Build menu, point to Communicator, and then select Test.
The Test Communicators dialog box appears.
Tip: For more information on any dialog box, press F1 when the dialog box is
active.
2 In the Model Names text box, enter the models or test rigs whose communicators
you want to test.
3 In the Minor Roles text box, enter the minor roles of the communicators.
You must enter one minor role for each model or test rig that you select.
Tip: If a communicator has a minor role of inherit, which specifies that when the
template-based product creates a subsystem from the template, the
communicator should inherit the subsystem’s minor role. Since when you
test a template’s communicators, the inherit minor role is still undefined,
entering minor roles in the Minor Role text box provides the
communicators with their minor role.
In ADAMS/Car for example, if you assign the template susp_02, a minor
role of front in the Minor Roles text box, the communicator test also changes
the minor role of any communicators in susp_02 whose minor role is inherit
to the role of front.
4 For ADAMS/Rail only: In the Wagon Order text box, enter the wagon order of the
models.
You must enter one wagon order for each model that you select. For more
information on wagon order, see Wagon Order on page 6 in the guide, Building
Templates in ADAMS/Rail.
5 If you’ve used the Information window before and you want to clear it, select Clear
Information Window.
6 If you want to save the results to a file, select Save Test Results to File, and then enter
the name of the file in the File Name text box.
7 Select OK.
The Information window appears. It contains a list of the communicators that
match other communicators and a list of those that do not. It shows the matched
communicators followed by the unmatched communicators. The lists include the
names of the input and output communicators and the names of the templates to
which they belong.
Often, you’ll see many communicators that are unmatched. Many of these
communicators are related to subsystems or test rigs that you do not currently have
open.
8 If you want to fully test the communicators in your template, you should open the
other templates with which you want the template to communicate. In
ADAMS/Car for example, if you are creating a suspenion template, the template
must be able to communicate with a steering template and the suspension test rig.
Note: ADAMS/Rail allows you to test the communication of models which are different
from each other. Therefore, you cannot test at the same time the communicators
of a certain assembly configuration where a template appears more than once.
Index
Index
A-B A-B
ADAMS Standard Interface, about 6
ADAMS Template Builder C-D
about 6
accessing 14 E-F
ADAMS/Solver variable communicator class, defined 31
G-H
Array communicator class, defined 31
Assembly I-J
matching communicators during 34
with mount communicators 34
K-L
Assembly files, about 13 M-N
Assumptions in this guide 3
O-P
Bushing communicator class, defined 31
C-D Q-R
Classes of communicators, about 30
S-T
Communicators
classes of 30 U-V
displaying information about 35
matching during assembly 34 W-Z
matching with test rigs 35
naming 33
roles of 32
testing 36
types of 30
Conventions for naming communicators 33
Creating test-rig templates 19
Differential communicator class, defined 31
Displaying communicator information 35
Index
E-F A-B
File architecture, about 7
Files
C-D
assembly 13
property 9 E-F
subsystem 11
templates 9 G-H
I-J I-J
Information, displaying communicator 35
K-L
Input communicators, defined 30
Integrator communicator class, defined 31 M-N
Joint communicator class, defined 31 O-P
Joint-for-motion communicator class, defined 31
Q-R
K-L
Location communicator class, defined 31 S-T
M-N U-V
Major roles
about 23 W-Z
of subsystems 12
Marker communicator class, defined 31
Matching communicators
during assembly 34
with test rigs 35
Minor roles
of communicators 32
of subsystems 12
of templates and test rigs 24
Model class, about 24
Motion communicator class, defined 31
Index
Mount communicator A-B

class, defined 31
warnings during assembly 34 C-D
Naming convention for communicators 33
E-F
O-P
Orientation communicator class, defined 31 G-H
Output communicators, defined 30
I-J
Overview of templates 5, 17
Part communicator class, defined 31 K-L
Property files, about 9 M-N
Q-R
O-P
Real parameter communicator class, defined 31
Roles Q-R
of communicators 32
of subsystems 12 S-T
S-T U-V
Saving
property files 9 W-Z
subsystems 12
templates 16
test-rig templates 20
Spline communicator class, defined 31
Standard Interface, about 6
Starting up ADAMS Template Builder 14
Subsystem files
about 11
descriptions contained by 12
role of, illustrated 10
roles of 12
Index
System architecture, illustrated 8 A-B

Template Builder, about 6
Template-based products
C-D
architecture of 6
E-F
Template-based products, list of 3
Templates G-H
about modifying 11
converting into test rigs 22 I-J
creating 15
defined 9 K-L
opening 15
overview of 5, 17 M-N
saving 16
O-P
Test rigs
about 18 Q-R
adding to binaries, in ADAMS/Car and ADAMS/Rail 26
adding to binaries, in ADAMS/Engine 27
S-T
matching communicators with 35
working with 18
U-V
Testing communicators 36
Test-rig class, about 25 W-Z
Test-rig templates
creating 19
modifying in ADAMS/Engine 21
opening in ADAMS/Engine 20
saving 20
Types of communicators 30
U-V
Verifying communicators 36
W-Z
Welcome to ADAMS 3

Template BLD

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Template BLD

Uploaded by

Copyright:

Available Formats

Building Templates

About This Guide 3

Introducing ADAMS Template Builder 5

Working with Test-Rig Templates 17

Setting Up Communication Between Templates and Test Rigs 29

ADAMS ® is a registered United States trademark of Mechanical Dynamics, Incorporated.

Part number: 120TEMBL-01

About This Guide

Welcome to Building Templates

What This Guide Assumes

■ Getting Started with ADAMS Template Builder, 14

Architecture of Template-Based Products

Figure 1. Front Suspension Assembly with Steering

Property File Property File

Figure 2. Generating a Subsystem

Templates contain communicators to enable the exchange of information with other

Getting Started with ADAMS Template Builder

■ Opening Existing Templates, 15

Accessing ADAMS Template Builder

To access ADAMS Template Builder:

Opening Existing Templates

To open an existing template:

1 From the File menu, select Open.

3 Double-click the template of interest.

To create a new template:

1 From the File menu, select New.

1 From the File menu, select Save or Save As.

■ About Test Rigs, 18

■ Creating Test-Rig Templates, 19

■ Saving Test-Rig Templates, 20

■ Converting Templates into Test Rigs, 22

■ Adding Test Rigs to Binaries, 26

About Test Rigs

1 Creating a template and saving it in ASCII format as explained in Creating Test-Rig

1 Creating a template and saving it in ASCII format as explained in Creating Test-Rig

Creating Test-Rig Templates

To create a test-rig template:

1 From the File menu, select New.

Saving Test-Rig Templates

To save test-rig templates:

Opening Test-Rig Templates in ADAMS/Engine

To open a test rig:

Modifying Test-Rig Templates in ADAMS/Engine

To modify a test rig:

1 From the File menu, select Open.

Converting Templates into Test Rigs

■ Removing the Header Information, 22

■ Modifying ADAMS/View Variables, 23

Removing the Header Information

Modifying ADAMS/View Variables

variable create &

variable create &

Set your model class as shown next:

variable create &

Set the test rig class as shown next:

variable create &

To reference testrig_class from the interface:

Adding Test Rigs to Binaries

■ Adding Test Rigs to Binaries in ADAMS/Engine, 27

■ Adding Test Rigs to Binaries in ADAMS/Rail, 27

Adding Test Rigs to Binaries in ADAMS/Car

file command read &

Adding Test Rigs to Binaries in ADAMS/Engine