Tutorial MSC MD Adams R3

ADAMS/Car
Training Guide
VERSION 11.0
PART NUMBER
110CARTRG-02
Visit us at: www.adams.com

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.
©2001 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.
&217(176
:HOFRPH WR $'$06&DU 7UDLQLQJ7

A Brief History of ADAMS 8
About Mechanical Dynamics 9
Referencing Online Guides 10
Getting Help at Your Job Site 12
A Review of Basic ADAMS Terminology 13
,QWURGXFLQJ$'$06&DU15
Motivation for Using ADAMS/Car 16
User Modes 20
Database Structure—A Directory Hierarchy 21
Configuration File 22
Workshop 1—Open and Run an Assembly 23
%DVLF&RQFHSWV 29
Data Hierarchy 30
Test Rig 32
Major and Minor Roles 33
Naming Convention 34
Workshop 2—Templates versus Subsystems 35
&UHDWLQJDQG$GMXVWLQJ6XEV\VWHPV41
Creating Subsystems 42
Adjusting Hardpoints 43
Adjusting Parameter Variables 44
Adjusting Mass Properties 45
Adjusting Springs and Dampers 46
Workshop 3—Creating and Adjusting Suspensions 48
8VLQJWKH&XUYH0DQDJHU55
Property File Types 56
Creating Property Files 57
Modifying an Existing Property File 60
Plot versus Table 61
Workshop 4—Modifying Springs with the Curve Manager 62
3
&217(176
&UHDWLQJDQG6LPXODWLQJ6XVSHQVLRQV65
Creating Suspension Assemblies 66
Half-Vehicle Analyses 67
Suspension Parameters 68
Creating Loadcases 69
Warning Messages 70
Files Produced by Analyses 71
Workshop 5—Running Suspension Analyses 72
&UHDWLQJDQG6LPXODWLQJ)XOO9HKLFOHV73
Creating Full-Vehicle Assemblies 74
Shifting Subsystems 75
Updating Subsystems 76
Updating Assemblies 77
Full-Vehicle Analyses 78
Adjusting Mass Automatically 80
Workshop 6—Running Full-Vehicle Analyses 81
'ULYLQJ0DFKLQH83
Standard Driver Interface (SDI) and Driving Machine 84
Why Use SDI? 85
Creating Inputs for SDI 86
Creating .dcf and .dcd Files 88
Workshop 7—Editing .dcf and .dcd Files 98
3ORW&RQILJXUDWLRQ)LOHV105
What is a Plot Configuration File? 106
Workshop 8—Creating Plot Configuration Files 107
3DUDPHWHUL]DWLRQ109
Parameterization in ADAMS/Car 110
Creating Hardpoints 111
Creating Construction Frames 113
Location Parameterization 115
Orientation Parameterization 120
4 Contents
&217(176
%XLOGLQJ7HPSODWHV127
Template Overview 128
Template Topology 129
File Architecture 130
Building a New Template 132
Types of Parts 133
Rigid Bodies (Parts) 134
Flexible Bodies (Parts) 135
Geometry 136
Attachments (Joints and Bushings) 137
Springs 138
Dampers 140
Bumpstops and Reboundstops 141
Suspension Parameter Array 142
General Advice 143
Workshop 9—Template-Builder Tutorial 144
&RPPXQLFDWRUV145
Types of Communicators 146
Classes of Communicators 147
Communicator Roles 149
Naming Communicators 150
Matching Communicators During Assembly 151
Matching Communicators with Test Rigs 153
Workshop 10—Getting Information About Communicators 155
8VLQJ)OH[LEOH%RGLHV159
Flexible Body Overview 160
Limitations of Flexible Bodies 161
Getting Flexible Bodies 162
Workshop 11—Flex Tutorial 163
5HTXHVWV167
Creating New Requests 168
Types of Requests 169
Contents 5
&217(176
7LUHV171
Tire Overview 172
ADAMS/Tire Modules 173
Tire Models 175
Tire Analyses 176
Workshop 12—Building a Wheel Template 177
([SORULQJ7HPSODWHV181
Investigating Templates 182
Understanding Templates 183
About the Database Navigator 184
Workshop 13—Exploring and Completing Templates 186
$GGLWLRQDO$SSOLFDWLRQV193
Conceptual Suspension Module and Driveline 194
Linear and Controls 196
Insight and Hydraulics 197
Vibration and Durability 198
Workshop 14—Using ADAMS/Linear with ADAMS/Car 199
:RUNVKRS³)XOO9HKLFOH$VVHPEO\205
([DPSOH$QDO\VHV213
Types of Analyses 214
Gather Data for the Model 215
Packaging Analysis on Suspension 216
Kinematic Analysis on Suspension 217
Suspension-Compliance Analysis 219
Static-Loading Durability Analysis 220
Dynamic-Loading Durability Analysis 222
Front Suspension Analyses 223
Full-Vehicle Design and Analysis 224
)RXU3RVW9HUWLFDO([FLWDWLRQ7HVW225
$'$06&DU)LOHV259
6 Contents
:(/&20( 72 $'$06&$5 75$,1,1*
Welcome to ADAMS/Car training. In this course, you learn how to use

ADAMS/Car to create, catalog, and analyze suspension and vehicle
assemblies.
:KDW·VLQWKLVVHFWLRQ
■ A Brief History of ADAMS, 8
■ About Mechanical Dynamics, 9
■ Referencing Online Guides, 10
■ Getting Help at Your Job Site, 12
■ A Review of Basic ADAMS Terminology, 13
Before starting class, make sure no other databases exist. Before using a database for the first time
in the class, make a new database.
Go over briefly.
Large displacement code vs. FEA (small displacement)
Systems based for mechanical systems
GUI just makes .adm for solver
30 minutes for material (modules 1-2, not including workshop)
$%ULHI+LVWRU\RI$'$06
$'$06$XWRPDWLF'\QDPLF$QDO\VLVRI0HFKDQLFDO6\VWHPV
7HFKQRORJ\ZDVLPSOHPHQWHGDERXW\HDUVDJR
0HFKDQLFDO'\QDPLFV,QFRUSRUDWHGIRUPHGE\UHVHDUFKHUVZKR
GHYHORSHGWKHEDVH$'$06FRGHDW8QLYHUVLW\RI0LFKLJDQ$QQ
$UERU0,86$
/DUJHGLVSODFHPHQWFRGH
6\VWHPVEDVHGDQDO\VLV
2ULJLQDOSURGXFWZDV$'$066ROYHUDQDSSOLFDWLRQWKDWVROYHV
QRQOLQHDUQXPHULFDOHTXDWLRQV<RXEXLOGPRGHOVLQWH[WIRUPDWDQG
WKHQVXEPLWWKHPWR$'$066ROYHU
,QWKHHDUO\·V$'$069LHZZDVUHOHDVHGZKLFKDOORZHGXVHUV
WREXLOGVLPXODWHDQGH[DPLQHUHVXOWVLQDVLQJOHHQYLURQPHQW
7RGD\LQGXVWU\VSHFLILFSURGXFWVDUHEHLQJSURGXFHGVXFKDV
$'$06&DU$'$065DLODQG$'$06(QJLQH
8 Welcome to ADAMS/Car Training
Give outline of class – module with workshop at end

$ERXW0HFKDQLFDO'\QDPLFV
)LQGDOLVWRI$'$06SURGXFWVDW
http://www.adams.com/mdi/product/modules.htm
/HDUQDERXWWKH$'$06²&$'&$0&$(LQWHJUDWLRQDW
http://www.adams.com/mdi/product/partner.htm
)LQGDGGLWLRQDOWUDLQLQJDW
http://support.adams.com/training/training.html
«RU\RXUORFDOVXSSRUWFHQWHU
Welcome to ADAMS/Car Training 9

5HIHUHQFLQJ2QOLQH*XLGHV
5HIHUHQFLQJWKH$'$06&DURQOLQHJXLGHV
Search and select text in Acrobat Reader:

Search in displayed guide:
Global search:
Select text:
Zoom in:
Zoom out: press Ctrl +
6HDUFKLQJ2QOLQH*XLGHV
'RLQJJOREDOVHDUFKHVRQDQ\RQOLQH$'$06JXLGH

*HWWLQJ+HOSDW<RXU-RE6LWH
2QOLQHJXLGHV
$FFHVVKHOSRQKHOSIURP
■ Help menu of any ADAMS product
■ Help tool on the Documentation Road Maps
.QRZOHGJHEDVH
Go to http://support.adams.com/kb
For a quick tour, go to: http://
www.adams.com/mdi/news/dyndim/
vol3_kbtour.htm
$6.HPDLOEDVHGXVHUVJURXS
Go to http://support.adams.com/support/
tech_ask.html
&RQVXOWLQJVHUYLFHV
Go to: http://support.adams.com/support/
cnsltsrv.html
7HFKQLFDOVXSSRUW
To find your support center, go to: http://support.adams.com/support/suppcent.html
To read the Service Level Agreement, go to: http://support.adams.com/support/sla_agree.html
The Knowledge Base is a database of solved problems/answered questions

The ASK group is a community – if you do not find your answer in the KB, you can post a message here – maybe,
someone will know.
$5HYLHZRI%DVLF$'$067HUPLQRORJ\
$'$066ROYHU
The solution engine.
$'$066ROYHUGDWDVHW DGP
The ASCII file submitted to ADAMS/Solver.
$'$066ROYHUFRPPDQG DFI
An ASCII file that contains commands to control how ADAMS/Solver runs the model.
$'$066ROYHURXWSXWILOHV
■ Graphics (*.gra) - Information about how graphics work.
■ Request (*.req) - Contains output for a specific set of results.
■ Results (*.res) - Contains results for every entity. This file is too big, and is not
produced by ADAMS/Car as default; you can, however, change ADAMS/Car to print
this.
■ Message (*.msg) - Information about the solver/simulation/problems.
■ Output (*.out) - Output including initial conditions and request, and content can
depend on output specifications.
.acf – in other words, what you can do with your data deck (.adm)
1RWHV

,1752'8&,1*$'$06&$5
This module discusses the advantages of using ADAMS/Car, as well as the

organization of the basic files.
:KDW·VLQWKLVPRGXOH
■ Motivation for Using ADAMS/Car, 16
■ User Modes, 20
■ Database Structure—A Directory Hierarchy, 21
■ Configuration File, 22
■ Workshop 1—Open and Run an Assembly, 23
15
0RWLYDWLRQIRU8VLQJ$'$06&DU
%ULGJHVGHSDUWPHQWVE\VKDULQJPRGHOVDQGGDWD
)DFLOLWDWHVTXLFNVXEV\VWHPFKDQJHV
7HPSODWHV
Test lab Engine Advanced

engineering
Suppliers
Driveline Chassis Body

engineering engineering
16 Introducing ADAMS/Car
Different departments can work with the same database, which minimizes data loss.
7HPSODWHV
Test lab Engine Advanced

engineering
Suppliers
Driveline Chassis Body

engineering engineering
Introducing ADAMS/Car 17
You can easily replace one subsystem without changing any other part of the vehicle.
7HPSODWHV
MacPherson
SLA
With quick subsystem replacement, you can see how handling, and other, characteristics change.
7HPSODWHV
Allow you to tailor one system for multiple vehicles.
Can create multiple (as many as you want) subsystems from one template
Example: BMW 3-5-7 Series suspension are all made from the same template
8VHU0RGHV
:LWKLQWKH$'$06&DUFRQILJXUDWLRQILOHDFDUFIJWKH

SDUWLFXODUDSSOLFDWLRQRI$'$06&DULVVSHFLILHGDVHLWKHU
VWDQGDUGXVHUPRGHDQGH[SHUWXVHUPRGH
([SHUWXVHU7HPSODWH%XLOGHUDQG6WDQGDUG,QWHUIDFH
■ Allows creation of building-block of ADAMS/Car, templates, with access to
Template Builder
■ For experienced ADAMS users
■ Access to all ADAMS modeling entities
6WDQGDUGXVHU6WDQGDUG,QWHUIDFHRQO\
■ Specifically for designers and testing engineers
■ Use libraries from the ADAMS/Car database to easily create vehicle (sub)assemblies
■ Simulation environment tailored to automotive standards
The expert user should have knowledge of ADAMS and how to build robust models
'DWDEDVH6WUXFWXUH³$'LUHFWRU\+LHUDUFK\
$GDWDEDVHLVDFROOHFWLRQRIGLUHFWRULHV
VWRUHGRQWKHKDUGGULYH7KHWRS
GLUHFWRU\ZKLFKKDVWKHH[WHQVLRQFGE
VWRUHVDQXPEHURIWDEOHVGLUHFWRULHV
(DFKWDEOHLVDSODFHKROGHUIRUPRGHO
LQIRUPDWLRQ
7KUHHW\SHVRIGDWDEDVHV
■ Shared - Common to all users, provided by MDI with
example files.
■ Private - User workspace (created by ADAMS/Car in
your $HOME directory).
■ User - User/site specific.
The databases are defined in private .acar.cfg or common
acar.cfg.
1ROLPLWDWLRQVRQQXPEHURIGDWDEDVHV
(DFKSURMHFWVKRXOGKDYHDVHSDUDWH
GDWDEDVH
<RXFDQRQO\VDYHWRRQHGDWDEDVHDWDWLPH
Here, the database is called “private”; cdb = car database.

For example, “springs.tbl” is where you put the spring stiffness curves
When you look for a spring file, A/Car will automatically look here
If you don’t have a private database when starting A/car, it will be created automatically for you
This will be more clear later.
We can improve this by explaining what every .tbl contains.
&RQILJXUDWLRQ)LOH
)RUHDFKXVHU$'$06&DUFUHDWHVDSULYDWHFRQILJXUDWLRQILOH
QDPHGDFDUFIJ1RWLFHWKHILUVWSHULRGZKLFKGLVWLQJXLVKHVLW
IURPWKHFRPPRQDFDUFIJ7KLVILOHLVORFDWHGLQWKHXVHUV
+20(GLUHFWRU\DQGGHILQHVSHUVRQDOVHWWLQJVDV
■ User mode (expert versus standard)
■ Personal databases and tables
■ Default property files
■ Default writable database
■ Database search order
■ Orientation of global reference frame
■ Other preferences
!----------------------------------------------------------------------------------------------------------------------!
!******************************** ADAMS/Car Configuration File *********************************!
! !
!----------------------------------------------------------------------------------------------------------------------!
! - List of personal environment variables
!----------------------------------------------------------------------------------------------------------------------!
ENVIRONMENT MDI_ACAR_USERMODE expert
ENVIRONMENT MDI_CAR_RENDER sshaded
ENVIRONMENT MDI_ACAR_VEHICLE_REAR 1, 0, 0
ENVIRONMENT MDI_ACAR_VEHICLE_LEFT 0, -1, 0
! !
!----------------------------------------------------------------------------------------------------------------------!
! - List of personal database directories
! Database name Path of database
!----------------------------------------------------------------------------------------------------------------------!
DATABASE private D:\private.cdb
DATABASE dbase_1 D:\dbase_1.cdb
DATABASE dbase_2 D:\dbase_2.cdb
DEFAULT_WRITE_DB private
!
!----------------------------------------------------------------------------------------------------------------------!
! - Desired database search order
!----------------------------------------------------------------------------------------------------------------------!
DATABASE_ORDERprivate, dbase_1, dbase_2, shared
!
You can set USERMODE to expert or standard

Here, REAR point x to the rear of the vehicle, -y to the left (y to the right); both are for the global coord sys.
You can name the databases anything you want, and you can add new databases.
You only can write to one database at a time, but you can read from as many databases as you want.
:RUNVKRS³2SHQDQG5XQDQ$VVHPEO\
XI XII I
X II
IX
VIII IV
III
This workshop takes about one half hour to complete.
VII VI V
3UREOHPVWDWHPHQW
This workshop introduces you to a couple of typical ADAMS/Car simulations. ADAMS/Car
basically runs either suspension or full-vehicle analyses. Here, you will perform one of each
type: an ISO lane change for a full vehicle, and a parallel wheel travel for a front suspension.
You will also add a trace marker to see the movement of particular parts in the model.
6HWWLQJ8S<RXU6HVVLRQ
7RFUHDWHDZRUNLQJGLUHFWRU\
■ Depending on the platform you’re on, do one of the following:
◆ On UNIX:
◆ To start ADAMS/Car in your home directory, open an UNIX shell and type
cd.
◆ To create a directory named acar, type mkdir acar.

◆ To move to the new directory, type cd acar.
◆ On Windows:
◆ On your hard drive, create a new folder acar. For example, C:\acar.
7RVWDUW$'$06&DU
■ Depending on the platform you’re on, do one of the following:
◆ At your UNIX shell prompt, type adams11.
◆ From the toolbar, select the ADAMS/Car tool .
◆ On Windows, from the Start button, point to Programs, point to ADAMS 11.0, point
to ACAR, and then select ADAMS - Car (view).
The Welcome dialog box appears.
By opening A/Car in the working directory, this will put the output files here.
7RWRJJOHWR6WDQGDUG,QWHUIDFH
■ From the Welcome dialog box, select Standard Interface, and then select OK. (Sometimes
the Welcome dialog box contains the option to select a mode, and other times it does
not. This depends on the configuration file.) To run analyses, you must be in the
Standard Interface mode.
■ Once in an ADAMS/Car session, you can toggle between modes by selecting
ADAMS/Car Standard Interface from the Tools menu. If ADAMS/Car Template
Builder is listed, then you are already in the Standard Interface mode.
7RFUHDWHDQHZGDWDEDVHDQGVHWLWDVWKHZULWDEOHGDWDEDVH
1 From the Tools menu, point to Database Management, and then select Create Database.
The Create New Database dialog box appears.
2 In the Database Name text box, enter acar_training.
3 In the Database Path text box, enter the desired path. The database name is an alias for the
Database Path, which needs to be explicitly defined. For example:
◆ On NT: c:\dir1\dir2\acar_training.cdb
◆ On UNIX: /dir1/dir2/acar_training.cdb
4 Select OK.
5 From the Tools menu, point to Database Management, and then select Set Default Writable,
and make sure the Database Name is set to acar_training (select the down arrow and then
select acar_training).
6 Select OK.
For Step 3, tell students explicitly what path to use.

6LPXODWLQJDIXOOYHKLFOHDVVHPEO\
You first open a full-vehicle assembly and then perform a full-vehicle, ISO lane-change
analysis with Driving Machine. You then investigate the results by animating the assembly. The
animation is based on the results of your analysis.
7RRSHQDIXOOYHKLFOHDVVHPEO\
1 From the File menu, point to Open, and then select Assembly.
2 Right-click the Open Assembly text box, select <shared>\assemblies.tbl, and then select
MDI_Demo_Vehicle.asy.
3 Select OK.
In the Message window, ADAMS/Car informs you when the assembly is ready.
4 Close the Message window.
7RSHUIRUPDQDQDO\VLV
1 From the Simulate menu, point to Full-Vehicle Analysis, point to Course Events, and then
select ISO Lane Change.
2 In the Output Prefix text box, enter workshop1a.
3 In the Initial Velocity text box, enter 70.
4 Select OK.
In the Message window, ADAMS/Car informs you about the progress of the analysis and
when the simulation is complete.
7RLQYHVWLJDWHWKHUHVXOWV
1 From the Review menu, select Animation Controls.
2 To animate the assembly, select the Play tool .

3 Zoom out to see more of the road grid:
■ Type a lowercase z.
■ Hold down the left mouse button, and do either of the following:
◆ To enlarge the display of the assembly, or zoom in, move the cursor up.
◆ To shrink the display of the assembly, or zoom out, move the cursor down.
■ To exit zoom mode, release the mouse button.
7RDGGDWUDFHPDUNHU
1 Change No Trace to Trace Marker.

2 Right-click the Trace Marker text box, point to Marker, and then select Browse.
The Database Navigator appears.
3 Double-click MDI_Demo_Vehicle, double-click TR_Body, double-click ges_chassis, and then
select cm.
7RIROORZWKHFDULQWKHDQLPDWLRQ
1 Change Fixed Base to Base Part.

2 Right-click the Base Part text box, point to Body, and then select Pick.
3 Move the cursor over the vehicle and select ges_steering_wheel.
4 Select Play.
The camera should move with the car, as the white line traces the path of the body marker.
6LPXODWLQJDVXVSHQVLRQDVVHPEO\
You simulate a suspension assembly in the same way you simulated the full-vehicle assembly.
7RRSHQDVXVSHQVLRQDVVHPEO\
2 Right-click the Open Assembly text box, select <shared>\assemblies.tbl, and then select
mdi_front_vehicle.asy.
3 Select OK.
In the Message window, ADAMS/Car informs you when the vehicle assembly is ready.
4 Close the Message window
7RSHUIRUPDSDUDOOHOZKHHOWUDYHOVXVSHQVLRQDQDO\VLV
1 From the Simulate menu, point to Suspension Analyses, and then select Parallel Wheel Travel.
2 Set up the analysis:
■ Output Prefix: workshop1b
■ Number of Steps: 10
■ Bump Travel: 100
■ Rebound Travel: -100

3 Select OK.
7RUHYLHZWKHUHVXOWVE\DQLPDWLQJ\RXUDVVHPEO\

2 Select the Play tool.
3 Zoom out to see more of the road grid.
7RDGGDWUDFHPDUNHU
1 Change No Trace to Trace Marker.

2 Right-click the Trace Marker text box, point to Marker, and then select Browse.
The Database Navigator appears.
3 Double-click Front_Suspension, double-click gel_spindle, and then select cm.
4 Select Play.
5 Zoom in to look for the white line that traces the path of the gel_spindle.cm marker.
%$6,&&21&(376
In this module, you learn how to create models in ADAMS/Car. This module
describes the relationships and differences between templates, subsystems,
and assemblies, which define ADAMS/Car models.
:KDW·VLQWKLVPRGXOH
■ Data Hierarchy, 30
■ Test Rig, 32
■ Major and Minor Roles, 33
■ Naming Convention, 34
■ Workshop 2—Templates versus Subsystems, 35
29
'DWD+LHUDUFK\
7KUHHOHYHOVRIILOHVEXLOGXSDYHKLFOHPRGHOIXOORUKDOIYHKLFOH
■ Template - Defines vehicle sub-assemblies topology (that is, how the parts and joints
fit together in the model, how information is transmitted, and so on). For example, a
template could be a suspension type, which can be defined either as front and/or rear.
■ Subsystem - A mechanical model that references a template and tailors it by
supplying parameters that adjust the template (for example, locations that define part
dimensions and spring stiffness). These models are usually a major system of your
vehicle, for example, front suspension, steering system, and body. The subsystem is a
specific instance of the template in which the user has defined new hardpoint
positions and property files.
■ Assembly - A list of subsystems and a single test rig combined in a vehicle or
suspension assembly. A test rig is necessary to provide an actuation, in your model,
for analysis.
Vehicle model
.asy
Subsystem data
.sub
Template design
.tpl
30 Basic Concepts
An assembly is just a list of pointers to subsystems and a test rig.

This structure is necessary due to parameterization.
Is this clear? In A/View, there is only one model; in A/Car, the “model” is made up of models.
We need a more graphical representation for this.
'DWD+LHUDUFK\
7KHILJXUHVKRZVKRZDVXEV\VWHPLVFUHDWHGIURPDWHPSODWH
7KHWHPSODWHKROGVGHIDXOWJHRPHWU\DQGWRSRORJ\7KHVXEV\VWHP
LVDVSHFLILFLQVWDQFHRIWKHWHPSODWHLQZKLFKWKHXVHUKDV
GHILQHGQHZPRGHOSDUDPHWHUVVXFKDVKDUGSRLQWSRVLWLRQV
SURSHUW\ILOHVDQGPDVVSURSHUWLHV
Subsystem File Creation
Default MacPherson Strut Template Specific Mass Properties

New Geometry Points
Specific Property Files
Bushing
Damper
Spring
MacPherson Subsystem
Basic Concepts 31
7HVW5LJ
$WHVWULJLQ$'$06&DULVWKHSDUWRIWKHPRGHOWKDWLPSRVHV
PRWLRQRQWKHYHKLFOH'HSHQGLQJRQWKHPRGHODQGHYHQW
GLIIHUHQWWHVWULJVPXVWEHXVHG
$WHVWULJLVDVSHFLDOVXEV\VWHPWKDWLVFRQQHFWHGWRDOORIWKH
RWKHUVXEV\VWHPVWKDWPDNHXS\RXUPRGHOIRUPLQJDQDVVHPEO\
7KHILJXUHRQWKHOHIWVKRZVWKHVXVSHQVLRQWHVWULJDORQH:LWK
WKHVXVSHQVLRQVXEV\VWHPVLWZRXOGORRNOLNHWKHILJXUHRQWKH
ULJKWDQDVVHPEO\
Suspension test rig assembled with

suspension and steering subsystems
Suspension test rig alone
32 Basic Concepts
0DMRUDQG0LQRU5ROHV
$'$06&DUXVHVPDMRUDQGPLQRUUROHVWRFUHDWHDYDOLG
DVVHPEO\0DMRUDQGPLQRUUROHVGHILQHWKHORFDWLRQRIWKH
VXEV\VWHPZLWKLQWKHDVVHPEO\
(YHU\WHPSODWHDQGWKHUHIRUHWKHVXEV\VWHPWKDWLVFUHDWHG
IURPWKDWWHPSODWHKDVDGHILQHGPDMRUUROHVXVSHQVLRQ
VWHHULQJERG\DQWLUROOEDUZKHHODQGVRRQ
:KHQDVXEV\VWHPLVFUHDWHGWKHVWDQGDUGXVHUGHILQHVWKH
VXEV\VWHPPLQRUUROHIURQWUHDUWUDLOHURUDQ\7KLVHQDEOHV
WKHVDPHVXVSHQVLRQWHPSODWHWREHXVHGIRUERWKDIURQWDQG
UHDUVXVSHQVLRQ
7RFUHDWHDYDOLGVXVSHQVLRQDVVHPEO\WKHPLQLPXPUHTXLUHPHQWLV
DVXVSHQVLRQVXEV\VWHPDQGWKH$'$06&DUVXVSHQVLRQWHVWULJ
7RFUHDWHDYDOLGYHKLFOHDVVHPEO\WKHPLQLPXPUHTXLUHPHQWLVD
IURQWVXVSHQVLRQDUHDUVXVSHQVLRQIURQWDQGUHDUZKHHOVD
ERG\DQGDVWHHULQJVXEV\VWHP
Basic Concepts 33
1DPLQJ&RQYHQWLRQ
$OO$'$06&DUHQWLWLHVDUHQDPHGDIWHUDQDPLQJFRQYHQWLRQ
7KHILUVWWKUHHOHWWHUVRIDJLYHQHQWLW\LGHQWLI\WKHW\SHDQGWKH
V\PPHWU\UXOH
([DPSOHV
■ gel_arm: General_Part_Left_….
■ hps_lcs_front: Hard_Point_Single_...
■ bkl_mount: Bushing_Kinematic_Left_...
■ nsr_main_spring: Non-linear_Spring_Right_...
■ pvs_toe_angle: ParameterVariable_Visible_Single_...
34 Basic Concepts
Explain symmetry (left and right)

Names are parsed and recognized by the software.
Not a complete list.
Also, can make own UDE and make own name.
Add all names in appendix in future
:RUNVKRS³7HPSODWHVYHUVXV6XEV\VWHPV
XI XII I
X II
IX
VIII IV
III
VII VI V
3UREOHPVWDWHPHQW
Understanding the difference between a template and a subsystem in ADAMS/Car is a pivotal
first step toward using the full power of ADAMS/Car. To illustrate this, consider two people
working side by side, both on a steering system. Looking at both computer screens, you see what
appears to be the same model. However, one user is working on a template in template-builder
mode, while the other is working on a subsystem in standard-interface mode. So, what’s the
difference?
As described before, the difference is what you can do with the models. The topology, or the
way that information and parts are connected, is defined in Template Builder using parameters
(variables), while defining those parameters is available in Standard Interface. Additionally,
you only perform analyses in Standard Interface, based on a model (specifically, a template)
created in Template Builder. A good way to understand this distinction is to create a template
file and a subsystem file and compare their contents.
2SHQLQJDWHPSODWHILOH
In this workshop, you create an ASCII template file and compare it to a subsystem file.
Template files can exist either as binary or text (ASCII) files. By default, the templates saved in
ADAMS/Car are binary, so to view the contents, you must save this one as text.
7RFKRRVHWKHWHPSODWHEXLOGHUPRGHLQ$'$06&DU
■ From the Tools menu, select ADAMS/Car Template Builder.
Note: You can toggle between Template Builder and Standard Interface by pressing the
F9 key.
Basic Concepts 35
Cut out some text and add a picture (low priority)

7RRSHQWKH0DF3KHUVRQVXVSHQVLRQWHPSODWHIURPWKHVKDUHGGDWDEDVH
1 From the File menu, select Open.

2 Right-click the Template Name text box, point to Search, and then select <shared>/
templates.tbl.
3 Double-click _macpherson.tpl.
4 Select OK.
7RVDYHWKHILOHDVDWH[WILOH
1 From the File menu, select Save As.

2 In the New Template Name text box, enter mac_ascii. (Note that this text box is grayed-out
because it is not a required text box to perform this function. If you do not enter a name,
ADAMS/Car saves the file with its current name.)
3 Set File Format to ASCII. You need to do this to be able to read the file.
4 Select OK.
ADAMS/Car saves the file in the acar_training database, which you had set up earlier.
36 Basic Concepts
7RRSHQWKHILOHDQGORRNDWWKHFRQWHQWV
1 From the Tools menu, select Show File (alternatively, you can use a text editor).
2 Right-click the File Name text box, point to Search, and then select <acar_training>.
3 Select the directory, templates.tbl, and then select _mac_acsii.tpl.
As you can see, the file has all the information to define the model using markers, parts,
communicators, forces, and so on. Take a look at the file to see what kind of information is
stored. For example, the following is the beginning of the definition of the left lower control
arm:
!
!---------------- gel_lower_control_arm ----------------------!
!
!
defaults coordinate_system &
default_coordinate_system = ._mac_ascii.ground
!
part create rigid_body name_and_position &
part_name = ._mac_ascii.gel_lower_control_arm &
location = 0.0, -550.0, 150.0 &
orientation = 0.0d, 90.0d, 180.0d
Basic Concepts 37
The template is basically an ADAMS/View command file with a header.

Won’t have to learn this language – the GUI will write out the files. The language is a superset of ADAMS/View (extra
stuff), using A/Car UDE’s.
2SHQLQJDVXEV\VWHPILOH
Subsystem files can only exist as text (ASCII) files, so you do not need to convert one from
binary. You do not have to specifically create MacPherson suspension subsystem from your
MacPherson template to see the major differences. Instead, you can open one based on a
MacPherson suspension that already exists in the shared database.
7RRSHQWKHILOHDQGORRNDWWKHFRQWHQWV
1 From the Tools menu, select Show File (alternatively, you can use a text editor).
2 Right-click the File Name text box, point to Search, and then select <shared>.
3 Double-click the directory, subsystems.tbl, and then double-click
MDI_FRONT_SUSPENSION.sub.
4 Take a look at the file to see what kind of information it stores.
You can see that the top portion of the file looks very similar to the template file, but the
rest is very different, as it resets values of parameters in the template file. Notice that in the
[SUBSYSTEM_HEADER] section, the MacPherson information is referenced for loading
into your ADAMS/Car session with the line: TEMPLATE_NAME = ’<shared>/
templates.tbl/_macpherson.tpl’. Also, notice that the subsystem sets the values for the
parameters in the lower control arms:
$------------------------------------------------------------------------------------PART_ASSEMBLY
[PART_ASSEMBLY]
USAGE = ’lower_control_arm’
SYMMETRY = ’left/right’
MASS = 5.0911573156
$ Part location is dependent.
$ X,Y,Z location = -6.6666666667, -496.6666666667, 225.0
$ Part orientation is dependent.
$ ZP vector = -0.0652566755, -0.9951643011, -0.0734137599
$ XP vector = -0.9972332421, 0.0676631757, -0.030782389
CM_LOCATION_FROM_PART_X = 0.0
CM_LOCATION_FROM_PART_Y = 0.0
CM_LOCATION_FROM_PART_Z = 0.0
IXX = 26908.978153
IYY = 60577.701004
IZZ = 33765.551131
IXY = 0.0
IZX = 3142.3266008533
IYZ = 0.0
38 Basic Concepts
When making a subsystem, the file contains just a path to the template. So if someone moves the template, your path
is destroyed.
6XPPDU\
Overall, a template defines the structure/topology of a model, and a subsystem redefines
whatever parameters the user wants to create an instance of the template for analyses.
Below is a table that lists the characteristics of the two file types:
Table 1: Comparison of Templates and Subsystems
Characteristic: Templates: Subsystems:
Used to define structure of model Yes No

References the other file (template versus subsystem) No Yes
Can be edited to change topology (for example, the Yes No
point at which force is applied)
Can edit parameters which define the model Yes Yes
Are used to perform ADAMS/Car analyses directly No Yes
An ADAMS/Car template is an ADAMS model built by an expert ADAMS/Car user in the

ADAMS/Car Template Builder. The ADAMS/Car template contains geometric and topological
data. The template file can be stored in ASCII or binary format.
An ADAMS/Car subsystem is based on an ADAMS/Car template and allows the standard user
to alter the geometric data and some of the topological data of the template. The subsystem file
is stored in ASCII format.
An ADAMS/Car assembly is a number of ADAMS/Car subsystems assembled together with an
ADAMS/Car test rig. The assembly file is stored in ASCII format and is a list of the subsystems
and test rig associated with the assembly
Basic Concepts 39
Make a new table

40 Basic Concepts
&5($7,1*$1'$'-867,1*68%6<67(06
In this module, you learn how to create a subsystem from a template, as well
as learn which parameters you can adjust in the subsystem.
:KDW·VLQWKLVPRGXOH
■ Creating Subsystems, 42
■ Adjusting Hardpoints, 43
■ Adjusting Parameter Variables, 44
■ Adjusting Mass Properties, 45
■ Adjusting Springs and Dampers, 46
■ Workshop 3—Creating and Adjusting Suspensions, 48
41
&UHDWLQJ6XEV\VWHPV
7RFUHDWHDQHZVXEV\VWHPDQH[LVWLQJWHPSODWHPXVWEH
DYDLODEOH
0DNHVXUH\RX·UHLQ6WDQGDUG,QWHUIDFH)URPWKH)LOHPHQX
SRLQWWR1HZDQGWKHQVHOHFW6XEV\VWHP<RXFDQRQO\FUHDWH
VXEV\VWHPVZLWKLQ6WDQGDUG,QWHUIDFH
,QWKH1HZ6XEV\VWHPGLDORJER[ILOOLQWKHIROORZLQJWH[WER[HV
■ Subsystem Name
■ Minor Role
■ Template Name
■ Translation values (optional; lateral shifting cannot be done)
42 Creating and Adjusting Subsystems
Looking into how to create your own subsystems now

Standard Interface is the only place you can make a subsystem
When making a subsystem, the file only includes a path to the template, so if someone moves the template, the path is
no longer valid
$GMXVWLQJ+DUGSRLQWV
:LWKLQDVXEV\VWHP\RXFDQPRYHKDUGSRLQWVIURPWKHLUGHIDXOW
YDOXHVGHILQHGLQWKHWHPSODWH+DUGSRLQWVGHILQHDOONH\ORFDWLRQV
LQ\RXUPRGHO)RUPRUHLQIRUPDWLRQRQKDUGSRLQWVVHHCreating
Hardpoints, 111RQSDJH
,Q6WDQGDUG,QWHUIDFHIURPWKH$GMXVWPHQXVHOHFW+DUGSRLQW
<RXKDYHWKUHHRSWLRQV
■ Modify - Displays a dialog box to select one hardpoint and modify its location.
■ Table - Displays a table with all the hardpoints in that subsystem. You can modify
the location of any hardpoint in the table.
■ Info - Displays a dialog box to select entity type and subsystem. This is already
preselected to entity type of hardpoint and to the current subsystem. It will give you
information about every hardpoint in the subsystem.
Creating and Adjusting Subsystems 43
All hardpoints are points on ground.

$GMXVWLQJ3DUDPHWHU9DULDEOHV
:LWKLQDVXEV\VWHP\RXFDQFKDQJHWKHYDOXHRISDUDPHWHU
YDULDEOHVFUHDWHGLQ7HPSODWH%XLOGHU$SDUDPHWHUYDULDEOHLV
VLPSO\DYDULDEOHWKDWLVXVHGWRVWRUHNH\LQIRUPDWLRQLQWKH
WHPSODWH)RUH[DPSOHLQWKHWHPSODWHVSDUDPHWHUYDULDEOHV
RIWHQVWRUHWKHWRHDQGFDPEHUDQJOHVIRUDVXVSHQVLRQRUWKH
RULHQWDWLRQRIWKHVSLQD[LV1RWHWKDWSDUDPHWHUYDULDEOHVFDQ
DOVRVWRUHWH[W
$'$06&DUGHILQHVVRPHSDUDPHWHUYDULDEOHVDXWRPDWLFDOO\
EHFDXVHWKH\DUHFRPPRQO\XVHGIRUDXWRPRWLYHDQDO\VHVIRU
H[DPSOHWRHDQGFDPEHUDQJOHV<RXFDQKRZHYHUFUHDWHQHZ
SDUDPHWHUYDULDEOHV
,Q7HPSODWH%XLOGHU\RXFDQFUHDWHSDUDPHWHUYDULDEOHVWKDWDUH
KLGGHQIURPVWDQGDUGXVHUV+LGGHQSDUDPHWHUYDULDEOHVFDQQRW
EHPRGLILHGWKURXJK6WDQGDUG,QWHUIDFH7KHQDPLQJFRQYHQWLRQ
IRUWKHVHYDULDEOHVLVSK>OUV@BQDPH
3DUDPHWHU9DULDEOHB+LGGHQB>/HIW5LJKW6LQJOH@8VHKLGGHQ
YDULDEOHVLI\RXGRQ·WZDQWWKHVWDQGDUGXVHUWRFKDQJHSDUWLFXODU
YDOXHV
7RPRGLI\SDUDPHWHUYDULDEOHVIURPWKH$GMXVWPHQXVHOHFW
3DUDPHWHU9DULDEOH<RXKDYHWZRRSWLRQV
■ Modify - Displays a dialog box to select one parameter variable and modify its value.
■ Table - Displays a table with all parameter variables in that subsystem, and you can
modify the value of any parameter variables in the table.
Parameter variables are fixed once a simulation is submitted.

No icon exists for parameter variable – you cannot right-click to modify.
Hidden variable example: phs_kinematic_flag, variable to make all kinematic or compliant
Show ADAMS/View variables underneath
$GMXVWLQJ0DVV3URSHUWLHV
:KHQWKHWHPSODWHLVFUHDWHGGHIDXOWPDVVSURSHUWLHVDUH
DVVLJQHGWRWKHERGLHV<RXFDQPRGLI\WKHVHYDOXHVLQ6WDQGDUG
,QWHUIDFH
7RPRGLI\PDVVSURSHUWLHVIURPWKH$GMXVWPHQXVHOHFW*HQHUDO
3DUW<RXKDYHWZRRSWLRQV
■ Modify - Displays a dialog box to select a part and you can specify mass and inertia
values. You can also display this dialog box by right-clicking on the part and
selecting the part name followed by Modify.
■ Calculate Mass - ADAMS/Car calculates the new values for mass and inertia based
on the ADAMS/Car geometry and the density. Note that if the geometry is changed in
Standard Interface from the template’s default value, the respective part’s mass will
not automatically change. To change it, simply use the Calculate Mass function again.
If your geometry is imported from a CAD package and is complex, you will have to
enter the mass manually.

$GMXVWLQJ6SULQJVDQG'DPSHUV
$VSULQJRUDGDPSHULVFUHDWHGLQ7HPSODWH%XLOGHUDQG
UHIHUHQFHVDSURSHUW\ILOHORFDWHGLQDSDUWLFXODUIROGHULQ\RXU
VHOHFWHGGDWDEDVH,Q6WDQGDUG,QWHUIDFH\RXFDQOLQNWKHVSULQJ
RUGDPSHUWRDGLIIHUHQWSURSHUW\ILOHRU\RXFDQFUHDWHDQHZ
SURSHUW\ILOH
7RPRGLI\DVSULQJULJKWFOLFNWKHVSULQJDQGVHOHFW0RGLI\
ZKLFKGLVSOD\VWKHIROORZLQJGLDORJER[
Specify the path to the property

file to be used for this spring
Calculates the required installed

length for a given preload
More information on
the Curve Manager in
subsequent chapters
ADAMS automatically converts the units of the property file to the units of the model.
$GMXVWLQJ6SULQJVDQG'DPSHUV
:LWKLQWKH0RGLI\6SULQJGLDORJER[ZKHQ\RXULJKWFOLFNWKH
SURSHUW\ILOHWH[WER[$'$06&DUWDNHV\RXWRWKHVSULQJWEO
GLUHFWRU\LQWKHVHOHFWHGGDWDEDVHOLNHZLVHZKHQ\RXULJKWFOLFN
WKHSURSHUW\ILOHWH[WER[LQWKH0RGLI\'DPSHUGLDORJER[
$'$06&DUWDNHV\RXWRWKHGDPSHUWEOGLUHFWRU\

:RUNVKRS³&UHDWLQJDQG$GMXVWLQJ6XVSHQVLRQV
XI XII I
X II
IX
VIII IV
III
VII VI V
3UREOHPVWDWHPHQW
In this workshop, you create a new subsystem and learn how to adjust its parameters.
&UHDWLQJDQGVDYLQJDVXEV\VWHP
7RFUHDWHDQHZVXEV\VWHP
1 Change to ADAMS/Car Standard Interface.

2 From the File menu, point to New, and then select Subsystem.
3 In Subsystem Name text box, enter my_macph.
4 Set Minor Role to rear.
5 Right-click the Template Name text box, point to Search, and then select
<shared>\templates.tbl.
6 Double-click _macpherson.tpl.
ADAMS/Car informs you that the template is already in the database.
7 Select Yes.
ADAMS/Car displays the subsystem.
7RVDYHWKHVXEV\VWHP
1 From the File menu, point to Save, and then select Subsystem.
The Save Subsystem dialog box appears. Because only one subsystem is open in
ADAMS/Car, by default my_macph is selected. However, if you have more than one
subsystem opened in your session, use the down arrow to select which one you would like
to save. ADAMS/Car saves the subsystem in the database, acar_training, which was set as
the default database in Setting Up Your Session, on page 23. ADAMS/Car saves the file in
the subsystems.tbl table.
2 Select OK.

0RGLI\LQJDVXEV\VWHP
7RRSHQ\RXUVXEV\VWHPILOH
1 From the Tools menu, select Show File.

2 Right-click the File Name text box, point to Search, and then select <acar_training>.
3 Double-click subsystems.tbl, and then double-click my_macph.sub.
7RWDNHDTXLFNORRNDWWKHFRQWHQWVRIWKHILOH
1 Look in the file and note the kind of information it stores. As you can see, parameters for
hardpoints, spring stiffness, and so on, are defined based on the values set when created in
Template Builder. To tailor this subsystem for a different MacPherson suspension, you
change these values in Standard Interface, creating your own instance of the model.
2 For example, note the thickness of the lower arm geometry, which is 10.6823911464.
You will change this value in Standard Interface, updating it in your subsystem file.
$------------------------------------------------ARM_GEOMETRY
[ARM_GEOMETRY]
PART = ’lower_control_arm’
THICKNESS = 10.6823911464
3 Select Clear, and then close the Info Window Read dialog box.
7RFKDQJHWKHORZHUFRQWURODUPWKLFNQHVV
1 Right-click either lower control arm (the red triangular area).

2 Point to Arm: graarm_lower_control_arm, and then select Modify.
3 Change the Thickness to 33.3.
4 Select OK.
On your screen, note that ADAMS/Car updates the arm thickness.
7RVDYH\RXUVXEV\VWHP
1 From the File menu, point to Save, and then select Subsystem. Your subsystem should be in
the dialog box by default.
2 Select OK, and then select No to prevent ADAMS/Car from creating a backup copy.

7RRSHQDQGORRNDW\RXUILOHDIWHUWKHFKDQJH
1 From the Tools menu, select Show File. Your subsystem should still be entered, so select
OK. Otherwise, right-click and search for <private>\subsystems.tbl\my_macph.sub.
Toward the top, you should see the arm geometry parameters updated for the thickness:
$-------------------------------------------------ARM_GEOMETRY
[ARM_GEOMETRY]
PART = ’lower_control_arm’
THICKNESS = 33.3
2 Close the Information window.
7RDGMXVWKDUGSRLQWV
1 From the Adjust menu, point to Hardpoint, and select either of the following:
■ Modify - Lets you adjust hardpoints one at a time
■ Table - Lets you adjust all hardpoints.

Alternatively, you could turn icon visibility on, right-click the hardpoint you want to
modify, and then select the hardpoint name followed by Modify.
2 Select Table.
3 Set Display to Both.
7RHGLWWKHVL]HRIWKHORZHUFRQWURODUP
1 Change loc_x for either hpl_lca_front or hpr_lca_front from –200 to –120. Because these
hardpoints are symmetrically parameterized, changing one will automatically change the
other.
2 Select Apply.
3 Change loc_x for either hpl_lca_rear or hpr_lca_rear from 200 to 120. Because these
hardpoints are symmetrically parameterized, changing one will automatically change the
other.
4 Select Apply.
The lower control arm becomes smaller.

7RFORVHWKHKDUGSRLQWWDEOH
■ To close the table, select OK or Cancel. When you save your subsystem, ADAMS/Car
updates the .sub file with these new hardpoint values.
7RDGMXVWSDUDPHWHUYDULDEOHV
1 From the Adjust menu, point to Parameter Variable, and then select Modify.
2 To see what parameter variables are available in this template, right-click the Parameter
Variable text box, point to Variable, and then select Guesses.
Here, you can see that one parameter available for adjustment is, pvl_toe_angle (toe angle).
Toe angle is the angle between the longitudinal axis of the vehicle and the line of
intersection of the wheel plane and the road surface. ADAMS/Car reports toe angle in
degrees. It is positive if the wheel front is rotated in towards the vehicle body.
3 Select pvl_toe_angle. Note that it currently has a value of 0.0.
4 To see the effects of toe angle, in the Real text box, enter 2.0.
ADAMS/Car updates both sides because Symmetric is set to yes.
5 Select OK.
For more related information, see the guides, Building Templates in ADAMS/Car and
Running Analyses in ADAMS/Car.
7RDGMXVWPDVVSURSHUWLHV
1 From the Adjust menu, point to General Part, and then select Modify.
2 Right-click the General Part text box, point to General Part, point to Guesses, and then select
gel_drive_shaft.
The dialog box fills in with the relative information.
Note that only the boxes that are not grayed-out are editable. Here’s the mass and inertia
properties:
■ Mass: 4.21745
■ Ixx: 1.65989
■ Iyy: 1.65989
■ Izz: 692.82585

3 To calculate the mass based on a material in the database, select the
Calculate Mass tool . Your selected general part is already entered.
4 Select a new material, such as titanium, and then select OK. Here are the new mass and
inertia properties:
■ Mass: 2.39635
■ Ixx: 8.0326
■ Iyy: 8.0326
■ Izz: 399.358
7RDGMXVWWKHVSULQJV
1 Right-click the spring, and then select Modify.

Here you can adjust the property file that defines the force versus deflection, as well as
either the installed length or the amount of preload, since these two quantities are directly
related. The property file <shared>/springs.tbl/mdi_0001.spr is already in the Property File
text box.
2 To see the force-deflection curve, select the Curve Manager tool .

The Curve Manager replaces your Standard Interface session. Notice that the spring is a
piece-wise linear spring.
3 To return to ADAMS/Car Standard Interface, from the File menu, select Close.
4 To change the property file, right-click the Property File text box, point to Search, and then
select <shared>\springs.tbl\MDI_125_300.spr.
5 To see the force-deflection curve, select the Curve Manager tool again. Notice that this
spring is a linear spring.
6 Return to ADAMS/Car Standard Interface.
7 Change the installed length to 200.
8 Select OK.
For a spring definition, see Springs, on page 138.
Need workshop to import spring data.

7RDGMXVWWKHGDPSHUV
This is the same procedure as for a spring.
1 Right-click the damper, and then select Modify.

Here you can adjust the property file that defines the force versus velocity. The property
file <shared>/dampers.tbl/mdi_0001.dpr is already in the Property File text box.
2 To see the force-velocity curve, select the Curve Manager tool. Notice that it is a nonlinear
curve.
4 To change the property file, right-click the Property File text box, point to Search, and then
select <shared>\dampers.tbl\MDI_default.dpr.
5 To see the force-velocity curve, select the Curve Manager tool. Notice the new nonlinear
characteristics.
7 Select OK.
5HPLQGHU
All of the modifications you just made in Standard Interface only change your subsystem. There
are many ways to perform these modifications. Note that the adjustments you make will change
your subsystem file only after you save it.
Need a block diagram


86,1*7+(&859(0$1$*(5
You use the Curve Manager to create and edit data in property files, as
described in this module.
:KDW·VLQWKLVPRGXOH
■ Property File Types, 56
■ Creating Property Files, 57
■ Modifying an Existing Property File, 60
■ Plot versus Table, 61
■ Workshop 4—Modifying Springs with the Curve Manager, 62
55
3URSHUW\)LOH7\SHV
7KH&XUYH0DQDJHUVXSSRUWVWKHIROORZLQJFXUYHW\SHV
■ Bushing
■ Bumpstop
■ Reboundstop
■ Spring
■ Damper
■ Wheel envelope
7KHIXQFWLRQDOLW\RIWKH&XUYH0DQDJHUFKDQJHVGHSHQGLQJRQWKH
NLQGRISURSHUW\ILOHEHLQJXVHG
7KH&XUYH0DQDJHUKDVWZRPRGHV
■ Plotting - In this mode you can build a curve by specifying functions that define the
curve.
For example, you can define a spring curve with a rate of 20 N/mm with 25 points
between –100 and 100 mm.
■ Table - In this mode you can specify each point in a data table.
For example, for the same spring curve made in the plotting mode, you would have to
type in the x-y numbers for all 25 points.
56 Using the Curve Manager
Open the curve manager to display these features.

&UHDWLQJ3URSHUW\)LOHV
7RFUHDWHDQHZSURSHUW\ILOHLQHLWKHU6WDQGDUG,QWHUIDFHRU
7HPSODWH%XLOGHUIURPWKH7RROVPHQXVHOHFW&XUYH0DQDJHU
7RVHWXSWKH&XUYH0DQDJHULQWKHDSSURSULDWHPRGHVHOHFWD
QHZILOHDQGVSHFLI\ZKDWW\SHRISURSHUW\ILOH\RXZDQWWR
FUHDWH
7\SHVRISURSHUW\ILOHV
■ Bushing - Specify all six curves that define 3-D translational and rotational stiffness.
Unlike a BUSHING statement, these curves can be nonlinear.
■ Bumpstop - A stiffness curve
■ Reboundstop - A stiffness curve
■ Spring - A stiffness curve and a free length (for information on springs, see Springs
on page 138)
■ Damper - A damping curve
■ Wheel envelope - Input boundaries:
◆ Steer input (length or angle)
◆ Wheel interior and boundary
◆ Steer interior and boundary
)HDWXUHVLQWKH&XUYH0DQDJHU
■ Fit the curve on the plot
■ Zoom a part of the curve
■ Curve math
■ Vertical hotpoints
■ Toggle memory curve
Using the Curve Manager 57
More notes for wheel envelope in the future

Describe memory curve
&XUYH0DWK
■ Slope - Specify a rate, limits, and number of points or number of segments, which is
the same as number of points minus 1.
■ Offset - Offsets the curve by the value you specify.
■ Absolute value - No parameters, takes the absolute value of the curve.
■ Negate - Inverts the curve.
■ Zero - Offsets the curve so it starts from zero.
■ Y mirror - Mirrors the y values around the middle point.
■ XY mirror - Mirrors the x and y values, so that the curve goes through the same
value for both the x and y axis.
■ Copy x->y - Makes the y value the same as the x.
■ Function - Specify a function, limits and number of points or segments, and you’ll
get a curve of the function you specified.
■ Interpolate - Uses one of the following interpolation methods and creates the number
of points you specify:
Akima Cspline
Linear Notaknot
Cubic Hermite
■ Step - Specify start and end values, and the y value for those start and end points.
■ Scale - Scales the curve by the value you specify.
■ Ramp - Specify start and end values, and the y value for those start and end points.
■ Expand - Stretches the x start and end points.
Take over screen and go through curve math commands

■ Sine - Start and end points for x and y values, when the sweep starts, minimum and
maximum amplitude, frequency and the number of points or segments.
■ Bushing - All six curves for translational and rotational stiffness, and the damping
values for each direction and for translation and rotation. You have the option of
specifying a percentage value of the stiffness instead of specifying an absolute
damping value.
■ Wheel envelope - The curve math is not available.

0RGLI\LQJDQ([LVWLQJ3URSHUW\)LOH
7RPRGLI\DQH[LVWLQJSURSHUW\ILOH\RXFDQGRHLWKHURIWKH
IROORZLQJ
■ Use the Tools menu in ADAMS/Car Standard Interface or Template Builder to open
the Curve Manager, as you would to create a property file. Here, open the property
file you want to edit and make your changes.
■ Use a modify dialog box to open the Curve Manager, and the selected curve will
automatically open for editing.
Curve Manager tool

3ORWYHUVXV7DEOH
7RVZLWFKEHWZHHQSORWDQGWDEOHIRUPDWXVHWKH9LHZFRPPDQG
RQWKHPDLQPHQXDQGVHOHFWHLWKHU3ORWRU7DEOHGHSHQGLQJRQ
ZKLFKPRGH\RXZDQWWRYLHZ<RXFDQRQO\FORVHWKH&XUYH
0DQDJHUWKDWLVUHWXUQWR6WDQGDUG,QWHUIDFHRU7HPSODWH
%XLOGHUIURPWKHSORWPRGH,I\RXDUHLQWDEOHPRGHJRWRSORW
PRGHDQGWKHQVHOHFW)LOH!&ORVH
:KHQ\RXILQLVKHGLWLQJWKHSURSHUW\ILOH\RXFDQVDYHLW
$'$06&DUVDYHVLWWRWKHFRUUHVSRQGLQJWDEOHGLUHFWRU\LQWKH
GHIDXOWZULWDEOHGDWDEDVH)RUH[DPSOH$'$06&$5VDYHVD
VSULQJSURSHUW\ILOHWRWKHWDEOHGLUHFWRU\VSULQJWEOLQWKH
GDWDEDVH
7RFKHFNZKDWWKHGHIDXOWZULWDEOHGDWDEDVHLV
■ From the Tools menu, point to Database Management, and then select Database Info.
■ See the subtitle in the plot, which shows the complete path to the property file.
,QWKH&XUYH0DQDJHUWRFKDQJH
WKHV\PEROVWKDWUHSUHVHQWWKHGDWD
SRLQWVIURPWKH6HWWLQJVPHQX
VHOHFW$SSHDUDQFH
The number of interpolation points are used to show the graphics.

Give time to students to play around with property files.
:RUNVKRS³0RGLI\LQJ6SULQJVZLWKWKH&XUYH0DQDJHU
XI XII I
X II
IX
VIII IV
III
VII VI V
In this workshop, you use the Curve Manager to modify springs in a suspension analysis.
6HWWLQJXSWKHPRGHO
7RVHWXS\RXUPRGHO
1 Open the mdi_front_vehicle assembly.

2 Run an opposite wheel travel analysis with Output Prefix named baseline.
0RGLI\LQJWKHVSULQJ
7RPRGLI\WKHVSULQJ
1 Right-click the spring and select Modify.

2 Select the Curve Manager tool.
3 Right-click the Curve Math toolstack , and then select the Scale tool .
4 In the Scale Value text box, enter 1.5.
5 Select Apply.

6DYLQJWKHVSULQJSURSHUW\ILOH
7RVDYHWKHVSULQJSURSHUW\ILOH
1 From the File menu, select Save As.

2 Name the file my_spring.spr.
3 Select OK.
ADAMS/Car saves the file in your default writable database.
4 From the File menu, select Close.
ADAMS/Car displays a dialog box that asks if you want to reference this spring property
file in your model.
5 Select Yes.
6 In the Modify Spring dialog box, select OK.
5XQQLQJDQDQDO\VLV
7RUXQDQDQDO\VLV
1 Run a wheel travel analysis identical to the analysis named baseline, with Output Prefix
named new_spring.
2 In ADAMS/PostProcessor, compare the results of dive.


&5($7,1*$1'6,08/$7,1*6863(16,216
In this module, you learn how to create a suspension assembly in

ADAMS/Car. You also learn about the available suspension analyses and how
to submit them.
:KDW·VLQWKLVPRGXOH
■ Creating Suspension Assemblies, 66
■ Half-Vehicle Analyses, 67
■ Suspension Parameters, 68
■ Creating Loadcases, 69
■ Warning Messages, 70
■ Files Produced by Analyses, 71
■ Workshop 5—Running Suspension Analyses, 72
65
■
&UHDWLQJ6XVSHQVLRQ$VVHPEOLHV
$QDVVHPEO\FRQVLVWVRIDVLQJOHWHVWULJDQGRQHRUPRUH
VXEV\VWHPVDWHVWULJE\LWVHOILVMXVWDVSHFLDOL]HGVXEV\VWHP
<RXFUHDWHVXVSHQVLRQDVVHPEOLHVLQ6WDQGDUG,QWHUIDFHIURPWKH
)LOHPHQXSRLQWWR1HZDQGWKHQVHOHFW6XVSHQVLRQ$VVHPEO\,Q
WKHGLDORJER[VSHFLI\DOOWKHVXEV\VWHPVWREHLQFOXGHGLQWKH
DVVHPEO\DVZHOODVWKHWHVWULJ
,I\RXXVHVXEV\VWHPVFUHDWHGIURPQHZWHPSODWHV\RXQHHGWR
PDNHVXUHWKHFRPPXQLFDWRUVPDWFKXS%HIRUHKDQGLQWKH
WHPSODWHEXLOGHUPRGH\RXFDQWHVWWKHFRPPXQLFDWRUVWRPDNH
VXUHWKH\PDWFKZLWKRWKHUWHPSODWHVFRPPXQLFDWRUVDUH
GHVFULEHGLQPRUHGHWDLOLQCommunicatorsRQSDJH $'$06&DU
GLVSOD\VZDUQLQJPHVVDJHVLQWKH0HVVDJHZLQGRZIRU
FRPPXQLFDWRUVWKDWDUHQRWPDWFKHGZKHQFUHDWLQJDQDVVHPEO\
7KHSLFWXUHEHORZVKRZVDVXVSHQVLRQDVVHPEO\FRQWDLQLQJD
VXVSHQVLRQDQGVWHHULQJVXEV\VWHPDQGWHVWULJ
%HFDXVHVLPXODWLRQVDUHDFWLYDWHGE\WHVWULJVWRSHUIRUPD
VLPXODWLRQ\RXPXVWXVHDQDVVHPEO\
66 Creating and Simulating Suspensions
Overview: First, we ran a simulation with an assembly. Next, we created a subsystem. Now, we will create an
assembly.
Have students open File -> New -> Suspension Assembly.
If you click a folder, it will change to a computer icon and will allow you to select subsystems already open in the
session.
+DOI9HKLFOH$QDO\VHV
<RXFDQSHUIRUPWKHIROORZLQJW\SHVRIVXVSHQVLRQDQDO\VHVLQ
$'$06&DU
■ Parallel wheel travel - Both wheels move up in unison.
■ Opposite wheel travel - One wheel up, one down.
■ Single wheel travel - One wheel fixed, while other moves.
■ Steering - Motion applied to steering wheel or rack.
■ Static load - Applied at specified locations (wheel center, tire contact patch).
■ External files:
◆ Loadcase - Essentially a selection of previous events.
◆ Wheel envelope - A parallel wheel travel while moving the steering to get the
volume the wheels take up in all exercises.
:KHQSHUIRUPLQJDVXVSHQVLRQDQDO\VLV$'$06&DUXVHVWKH
ILUVWVHFRQGWREULQJWKHZKHHOFHQWHUVWRWKHORZHVWSRVLWLRQDQG
WKHQXVHVDVPDQ\VHFRQGVDV\RXVSHFLI\VWHSVWRPRYHWKH
VXVSHQVLRQWRWKHXSSHUSRVLWLRQ
)RUPRUHLQIRUPDWLRQVHHWKHJXLGH5XQQLQJ$QDO\VHVLQ
$'$06&DU
Creating and Simulating Suspensions 67
Need a detailed explanation of each event

6XVSHQVLRQ3DUDPHWHUV
6RPHRIWKHGHIDXOWUHTXHVWRXWSXWVQHHGLQIRUPDWLRQWKDWLVQRW
DYDLODEOHLQWKHPRGHO7KHUHIRUH\RXPXVWVXSSO\WKLVDGGLWLRQDO
LQIRUPDWLRQ7KLVLQIRUPDWLRQKDVQREHDULQJRQWKHRXWFRPHRI
WKHVLPXODWLRQDVLWRQO\DIIHFWVVRPHRIWKHXVHUGHILQHG
UHVXOWVIRUH[DPSOHWKHUROOFHQWHUDPRQJRWKHUV
$'$06&DUVWRUHVWKHLQSXWLQDQDUUD\QDPHG6XVSHQVLRQ
3DUDPHWHUVZKLFK\RXFDQILQGLQWKH6WDQGDUG,QWHUIDFHXQGHU
6LPXODWH!6XVSHQVLRQ$QDO\VLV!6XVSHQVLRQ3DUDPHWHUV
7KHYDOXHV\RXPXVWVXSSO\DUH
■ Loaded tire radius
■ Tire stiffness
■ Sprung mass
■ CG height
■ Wheelbase
■ Drive ratio
■ Brake ratio
Manipulation of state data

&UHDWLQJ/RDGFDVHV
$ORDGFDVHLVDQ$6&,,ILOHFRQWDLQLQJDOOQHFHVVDU\LQIRUPDWLRQWR
UXQDVLPXODWLRQ,WLVEDVLFDOO\DZD\RIVFULSWLQJVXVSHQVLRQ
VLPXODWLRQVZLWKWKHVHILYHDQDO\VLVW\SHV
■ Parallel wheel travel
■ Opposite wheel travel
■ Single wheel travel
■ Steering
■ Static load
:KHQUXQQLQJDORDGFDVH$'$06&DUVHDUFKHVIRUWKHSDUWLFXODU
ORDGFDVHILOHVWRUHGLQWKHGDWDEDVH<RXFDQFDOOPDQ\
ORDGFDVHVDQG$'$06&DUZLOOUXQWKHPRQHDWDWLPH
<RXFDQFUHDWHDORDGFDVHILOHE\VHOHFWLQJ6LPXODWH!6XVSHQVLRQ
$QDO\VLV!&UHDWH/RDGFDVH7KHQVHOHFWWKHW\SHRIDQDO\VLV
\RXZDQWWRUXQDQGVSHFLI\WKHUHOHYDQWGDWD

:DUQLQJ0HVVDJHV
:KHQ\RXFUHDWHDQDVVHPEO\\RXZLOOVRPHWLPHVVHHZDUQLQJ
PHVVDJHV)RUH[DPSOHVXSSRVH\RXDUHFUHDWLQJDIURQW
0DF3KHUVRQVXVSHQVLRQDVVHPEO\ZLWKRXWDVWHHULQJRUERG\
VXEV\VWHP%HFDXVHVWHHULQJDQGERG\SDUWVDUHQRWVSHFLILHGLQ
WKHWHVWULJRUDQRWKHUVXEV\VWHPFHUWDLQFRPPXQLFDWRUVDUH
DWWDFKHGWRJURXQGRUQRWDWWDFKHGWRDQ\WKLQJ7KH0HVVDJH
ZLQGRZGLVSOD\VWKHIROORZLQJ
Creating the suspension assembly: ’macph_assy’...
Moving the rear suspension subsystem: ’my_macph’...
Assembling subsystems...
Assigning communicators...
WARNING: The following input communicators were not assigned during assembly:
my_macph.cil_tierod_to_steering (attached to ground)
my_macph.cir_tierod_to_steering (attached to ground)
my_macph.cis_subframe_to_body (attached to ground)
my_macph.cil_strut_to_body (attached to ground)
my_macph.cir_strut_to_body (attached to ground)
my_macph.cil_ARB_pickup
my_macph.cir_ARB_pickup
testrig.cis_steering_wheel_joint
testrig.cis_steering_rack_joint
testrig.cis_leaf_adjustment_steps
testrig.cis_powertrain_to_body (attached to ground)
Assignment of communicators completed.
Assembly of subsystems completed.
Suspension assembly ready.
7KHPRGHOVLQWKHVKDUHGFDUGDWDEDVHFRQWDLQDOOWKH
FRPPXQLFDWRUVWKDWFRXOGSRVVLEO\EHXVHGE\RWKHUV\VWHPVDQG
LQPDQ\FDVHVQRWDOOFRPPXQLFDWRUVDUHXVHG+RZHYHUEHVXUH
WRFKHFNRXWZKLFKRQHVDUHQ
WEHLQJFRQQHFWHGWRVHHLILWPDNHV
VHQVH+HUHPRVWRIWKHPFRXOGSRWHQWLDOO\EHFRQQHFWHGWRWKH
ERG\RUWRVRPHRWKHUVXEV\VWHP\RXFXUUHQWO\GRQ
WFDUHDERXW
LQ\RXUDQDO\VLV%\GHIDXOWLI$'$06&DUFDQQRWILQGWKH
PDWFKLQJFRPPXQLFDWRULWDWWDFKHVLWWRJURXQGZKLFKLQWKLV
FDVHLVILQH6R\RXXVXDOO\DUHQ
WFRQFHUQHGDERXWLWXQOHVV\RX
VHHDFRPPXQLFDWRUWKDWVKRXOGEHXVHGEXWLVQ
W

)LOHV3URGXFHGE\$QDO\VHV
,W·VLPSRUWDQWWRUHPHPEHUWKDWDOOYHUWLFDOSURGXFWVLQFOXGLQJ
$'$06&DUDUHVLPSO\SUHSURFHVVRUVIRU$'$066ROYHU7KLV
PHDQVWKDWWKH\VLPSO\SURGXFHWKHDGPILOH$'$066ROYHU
GDWDWKHPRGHODQGWKHDFIILOH$'$066ROYHUFRPPDQGV
7KHVHILOHVDUHFUHDWHGLQWKHZRUNLQJGLUHFWRU\)LOH!6HOHFW
'LUHFWRU\
7KHRXWSXWILOHVSURGXFHGLQFOXGHPHVVDJHUHTXHVWUHVXOWV
JUDSKLFVDQGRXWSXWILOHV$'$06&DUPD\DOVRSURGXFHDGFI
DQGGFGILOHDVGHVFULEHGLQDriving MachineRQSDJH
:KHQ\RXLPSRUWWKHDQDO\VLVUHTXHVWVILOHUHTLQ

$'$063RVW3URFHVVRU$'$06&DUDOVRSURGXFHVDVSHFLDOILOH
QDPHGWKHQDPHILOHQDPZKLFKFRQWDLQVWKHQDPHDVVRFLDWHG
ZLWKHYHU\UHTXHVWLQWKHLQWHUIDFH
<RXFDQXVHWKHDGPDFIDQGQDPILOHVWRVXEPLWDQDQDO\VLV
RXWVLGHRIWKH$'$06&DUJUDSKLFDOLQWHUIDFH

:RUNVKRS³5XQQLQJ6XVSHQVLRQ$QDO\VHV
XI XII I
X II
IX
VIII IV
III
This workshop takes about one hour to complete.
VII VI V
Go through Suspension Analysis Tutorial in the guide, Getting Started Using ADAMS/Car.

&5($7,1*$1'6,08/$7,1*)8//9(+,&/(6
In this module, you learn how to create full-vehicle assemblies in

ADAMS/Car. You also learn about the available full-vehicle analyses and how
to submit them.
:KDW·VLQWKLVPRGXOH
■ Creating Full-Vehicle Assemblies, 74
■ Shifting Subsystems, 75
■ Updating Subsystems, 76
■ Updating Assemblies, 77
■ Full-Vehicle Analyses, 78
■ Adjusting Mass Automatically, 80
■ Workshop 6—Running Full-Vehicle Analyses, 81
73
&UHDWLQJ)XOO9HKLFOH$VVHPEOLHV
7RFUHDWHDIXOOYHKLFOHDVVHPEO\JRWR)LOH!1HZ!)XOO
9HKLFOH7KLVGLDORJER[UHTXLUHVDOLVWRIDOOVXEV\VWHPVWKDW
PDNHXS\RXUDVVHPEO\7KHVXEV\VWHPQHFHVVDU\DUHERG\IURQW
DQGUHDUVXVSHQVLRQIURQWDQGUHDUWLUHVVWHHULQJV\VWHPDQGD
WHVWULJ
$OOWKHDQDO\VHVFXUUHQWO\DYDLODEOHDUHEDVHGRQWKH'ULYLQJ
0DFKLQH7KHUHIRUHWRSHUIRUPRSHQORRSFORVHGORRSDQG
TXDVLVWDWLFDQDO\VHV\RXPXVWVHOHFWWKH
BB0',B6',B7(675,*LQ\RXUDVVHPEOLHV7KHRQO\DQDO\VLVWKDW
LVQRWEDVHGRQWKH'ULYLQJ0DFKLQHLVWKHGDWDGULYHQDQDO\VLV
,WXVHVWKHBB0',B'ULYHUB7(675,*
<RXFDQLQFOXGHRWKHUVXEV\VWHPVLQWKHIXOOYHKLFOHDVVHPEO\E\
FKHFNLQJ2WKHU6XEV\VWHP7KHORFDWLRQDQGFRQQHFWLYLW\RIWKHVH
VXEV\VWHPVGHSHQGRQWKHKRZWKHVXEV\VWHPVDQGWKH
FRPPXQLFDWRUVDUHGHILQHGDQGZKHWKHURUQRWWKHWHPSODWHLV
VKLIWHG
74 Creating and Simulating Full Vehicles

6KLIWLQJ6XEV\VWHPV
7RVKLIWDVXEV\VWHPLQWKH6WDQGDUG,QWHUIDFHJRWR
$GMXVW!6KLIW+HUH\RXKDYHWKHFKRLFHRIVKLIWLQJWKH
VXEV\VWHPIRUHDIWDQGXSGRZQ)RUHDIWPRYHVWKHVXEV\VWHP
DORQJWKHJOREDO[D[LV8SGRZQPRYHVLWDORQJWKHJOREDO]D[LV
After shifting the rear suspension aft and up
Creating and Simulating Full Vehicles 75
Might be nice with a picture of how this works

8SGDWLQJ6XEV\VWHPV
2FFDVLRQDOO\\RXPD\ZDQWWRFKDQJHDVXEV\VWHPWKDWLVXVHG
ZLWKLQ\RXUDVVHPEO\DQGVHHWKHFKDQJHVWDNHHIIHFWLQ\RXU
DVVHPEO\,QRWKHUZRUGV\RXZDQWWRHGLWWKHVXEV\VWHPILOH
DQGVHHWKHFKDQJHVDOWHU\RXUDVVHPEO\ILOH7RGRWKLVJRWR
)LOH!8SGDWH!6XEV\VWHPDQGWKHQVHOHFWWKHVXEV\VWHP
7KLVRSWLRQSUHYHQWV\RXIURPFORVLQJWKHDVVHPEO\DQGUHRSHQLQJ
LWZLWKWKHPRGLILHGVXEV\VWHPWRVHHWKHFKDQJH
,03257$171RWHWKDW\RXPXVWVDYHWKHFKDQJHGVXEV\VWHPLQ
WKHGDWDEDVHWREHORDGHGLQWRWKHDVVHPEO\$OVRWKHXSGDWH
VXEV\VWHPFKDQJHVGRQRWDIIHFWWRSRORJ\WKH\RQO\XSGDWHWKH
SDUDPHWHUVZKLFKFDQEHDGMXVWHGDWWKHVXEV\VWHPOHYHO

8SGDWLQJ$VVHPEOLHV
6LPLODUO\WRXSGDWLQJVXEV\VWHPV\RXFDQXSGDWH\RXUDVVHPEO\
7RGRVRJRWR)LOH!8SGDWH!$VVHPEO\DQGWKHQVHOHFWWKH
DVVHPEO\7KLVRSWLRQSUHYHQWV\RXIURPFORVLQJWKHDVVHPEO\DQG
UHRSHQLQJLWZLWKWKHPRGLILHGVXEV\VWHPVE\UHORDGLQJ
LQIRUPDWLRQIURPWKHVDYHGVXEV\VWHPVWKDWWKHDVVHPEO\
UHIHUHQFHV

)XOO9HKLFOH$QDO\VHV
$VVWDWHGSUHYLRXVO\DOOWKHDQDO\VHVFXUUHQWO\DYDLODEOHDUH
EDVHGRQWKH'ULYLQJ0DFKLQH7KHUHIRUHWRSHUIRUPRSHQORRS
FORVHGORRSDQGTXDVLVWDWLFDQDO\VHV\RXPXVWVHOHFWWKH
BB0',B6',B7(675,*LQ\RXUDVVHPEOLHV7KHRQO\DQDO\VLVWKDW
LVQRWEDVHGRQWKH'ULYLQJ0DFKLQHLVWKHGDWDGULYHQDQDO\VLV
,WXVHVWKHBB0',B'ULYHUB7(675,*
7KHIROORZLQJLVDOLVWRIWKHW\SHVRIHYHQWVWKDWDUHDYDLODEOHLQ
$'$06&DU
■ OPEN LOOP EVENTS
◆ Drift
◆ Fish Hook (new to v11.0)
◆ Impulse Steer
◆ Ramp Steer
◆ Single Lane Change
◆ Step Steer
◆ Swept Sine Steer
■ CORNERING EVENTS
◆ Breaking-In-Turn
◆ Power-Off Cornering
◆ Constant Radius Cornering
◆ Cornering with Steering Release (new to v11.0)
◆ Lift-Off Turn-In (new to v11.0)
◆ Power-Off Cornering (new to v11.0)

)XOO9HKLFOH$QDO\VHV
■ STRAIGHT-LINE BEHAVIOR
◆ Acceleration and Braking (Improved for v11.0)
◆ Power-Off Straight-line (New to v11.0)
■ COURSE EVENTS
◆ ISO Lane Change
■ DCF DRIVEN
■ QUASI-STATIC MANEUVERS
◆ Constant Radius Cornering
◆ Constant Velocity Cornering
◆ Force Moment Method
■ DATA DRIVEN (only works with __MDI_Driver_testrig)
■ ADAMS/DRIVER
)RUGHWDLOVRQWKHVHDQDO\VHVVHHWKHJXLGH5XQQLQJ$QDO\VHVLQ
$'$06&DURUXVHWKH'LDORJ%R[+HOS)
2QWRSRIWKHG\QDPLFHYHQWV$'$06&DURIIHUVDVHWRITXDVL
VWDWLFHYHQWVLQFOXGLQJ
■ Constant Radius Cornering
■ Constant Velocity Cornering
■ Force-moment method
7KHVHDUHDYDLODEOHXVLQJHLWKHU0',B'5,9(5B7(675,*RU
0',B6',B7(675,*WHVWULJ
Need detailed explanation of these events. Need to talk about the setup button for the force-moment method.
What elements are added to the assembly?
$GMXVWLQJ0DVV$XWRPDWLFDOO\
,Q$'$06&DU\RXFDQDGMXVWWKHPDVVSURSHUWLHVRIDQ
DVVHPEOHGPRGHO7RDGMXVWWKHDJJUHJDWHPDVVHQWHUWKH
GHVLUHGPDVVWKHGHVLUHGFHQWURLGDOLQHUWLDVDQGWKHGHVLUHG
FHQWHURIPDVVORFDWLRQDOOUHODWLYHWRDPDUNHU<RXDOVRVHOHFW
DSDUWWKDW$'$06&DUPRGLILHVWRPDWFKWKHGHVLUHGPDVV
SURSHUWLHV7KHUHIRUHWKHPDVVSURSHUWLHVRIWKHYLUWXDOYHKLFOH
PDWFKWKRVHRIWKHUHDOYHKLFOH
7RDGMXVWWKHPDVVSURSHUWLHVJRWR6LPXODWLRQ!)XOO9HKLFOH
$QDO\VLV!$XWRPDWLF0DVV$GMXVWPHQW

:RUNVKRS³5XQQLQJ)XOO9HKLFOH$QDO\VHV
XI XII I
X II
IX
VIII IV
III
VII VI V
Go through Full-Vehicle Analysis Tutorial in the guide, Getting Started Using ADAMS/Car.

:RUNVKRS³5XQQLQJ)XOO9HKLFOH$QDO\VHV

'5,9,1*0$&+,1(
The Driving Machine drives your virtual vehicle according to your instructions
much like a test driver would drive an actual vehicle.
:KDW·VLQWKLVPRGXOH
■ Standard Driver Interface (SDI) and Driving Machine, 84
■ Why Use SDI?, 85
■ Creating Inputs for SDI, 86
■ Creating .dcf and .dcd Files, 88
■ Workshop 7—Editing .dcf and .dcd Files, 98
83
6WDQGDUG'ULYHU,QWHUIDFH6',DQG'ULYLQJ0DFKLQH
6WDQGDUG'ULYHU,QWHUIDFH6',LVDQDUFKLWHFWXUHXVHGE\

$'$06&DUWRSHUIRUPGULYLQJDQDO\VHVXVLQJLQSXWVWRGULYH\RXU
YLUWXDOYHKLFOH7KHPDQLIHVWDWLRQRIWKLVDUFKLWHFWXUHLVD
IXQFWLRQLQ$'$06&DUFDOOHG'ULYLQJ0DFKLQH7KLVLQWHUIDFH
FRQWUROVILYHGLIIHUHQWFKDQQHOVVWHHULQJWKURWWOHFOXWFKJHDU
DQGEUDNH7KLVHQDEOHV\RXWRHDVLO\UHFUHDWHDQ\SK\VLFDOWHVW
SURFHGXUHRUUHSOD\DFWXDOGULYLQJHYHQWVIURPPHDVXUHGGDWD
'ULYLQJ0DFKLQHSURYLGHVDVHDPOHVVLQWHUIDFHWRWKUHHYHKLFOH
FRQWUROOHUV
■ Open-loop control - The open-loop controller can use either constant values or
function expressions to drive the vehicle. No feedback is passed back to the
controller.
■ Machine control - The machine controller is a closed-loop controller that controls
the vehicle by using the vehicle states.
■ Human control - The human controller is, like the machine controller, a closed-loop
controller, but it also has learning capabilities.
7RKHOS\RXFDOFXODWHWKHFRQWUROVLJQDOVWKH'ULYLQJ0DFKLQH
SDVVHVYHKLFOHVWDWHVVXFKDVSRVLWLRQYHORFLW\DQGDFFHOHUDWLRQ
WR\RXUGULYHUFRQWUROOHU,WDOVRSURYLGHVDPHDQVIRUGHILQLQJ
DQGSDVVLQJVHWVRIFRPPDQGVLJQDOVIHHGEDFNVLJQDOVDQG
SDUDPHWHUVIRUHDFKRIWKHILYHFRQWUROVLJQDOV
84 Driving Machine
Open loop – define one value to impose motion

Machine control – define path for closed-loop
Human control – define path, and can learn to drive as fast as possible with long. and lat. Accel (closed-loop with
learning)
:K\8VH6',"
1RQHHGWRFUHDWHFRQWUROOHUVRUWRVWUXJJOHVHWWLQJJDLQV
6KRUWHQVLPXODWLRQWLPHVLIFRQGLWLRQVDUHDFKLHYHGRUDERUWHDUO\
LIFRQGLWLRQVDUHQRWPHW
&ORVHGORRSFRQWUROIRUVRPHGULYHUVLJQDOVFDQEHFRPELQHGZLWK
RSHQORRSFRQWUROIRURWKHUVIRUH[DPSOHFORVHGORRSIRU
VWHHULQJDQGRSHQORRSIRUWKURWWOH
(QDEOHVXVHUVWRHDVLO\UHFUHDWHDQ\SK\VLFDOWHVWSURFHGXUHRU
UHSOD\DFWXDOGULYLQJHYHQWVIURPPHDVXUHGGDWD
9HKLFOHHYHQWVFULSWLQJZLWKPLQLPDQHXYHUVDOORZVHDV\
FRQVWUXFWLRQRIQHZYHKLFOHWHVWV
$XWRPDWLFWUDQVPLVVLRQLQWKHSRZHUWUDLQPRGHO
6',FDSDELOLW\HQDEOHVDEVROXWHFRQWURORIYHKLFOHDQGGHILQLWLRQ
RIFORVHGORRSHYHQWVE\WDUJHWFRQGLWLRQH[DPSOHEUDNLQJDW
*6R\RXFDQEXLOGDQ\HYHQWXVLQJWKH'ULYLQJ0DFKLQH
Driving Machine 85
&UHDWLQJ,QSXWVIRU6',
7ZRILOHW\SHVDUHXVHGDVLQSXWIRU6',EDVHGHYHQWVGULYHU
FRQWUROILOHVGFIDQGGULYHUFRQWUROGDWDILOHVGFGILOHV
■ Driver control file (.dcf) - Controls the event and contains a list of mini-maneuvers
that allows you to script the simulation.
■ Driver control data file (.dcd) - Contains input data used in the driver control file.
This file is necessary only if it is referenced in the .dcf file.
'ULYHU&RQWURO)LOH
A driver control file is a tiem orbit ASCII file that you can modify in a text editor. It allows you
to reference external data in a .dcd file to drive the vehicle, such as steering wheel displacement,
vehicle acceleration, or other inputs. The driver control file requires four data blocks:
■ MDI header - Identifies the file as a .dcf file and provides version information.
■ Units - Sets the units of the parameters in the .dcf file. These units can be different
from those used in the model.
■ Experiment - Specifies some initial conditions for the simulation and a list of mini-
maneuvers that makes up the complete experiment or event.
■ Mini-maneuver - Specifies how the vehicle steering, throttle, brake, gear, and clutch
are controlled for each maneuver, which are basically instructions for the vehicle.
These names must match the names specified in the experiment block.
'ULYHU&RQWURO)LOH
■ MDI header
■ Units
■ Controls block:
◆ Closed-loop - Specifies the relative data according to input parameters. For
example, x, y coordinates for a vehicle path.
◆ Open-loop - Includes data for time versus the five input channels: steer, throttle,
brake, gear, and clutch.
86 Driving Machine
The .dcf and .dcd files reside in two different tables in the database.
Steal the screens and show where these are and what is in the files.
All slides from here on might be too detailed. We might want to think about cutting them down.
&UHDWLQJ,QSXWVIRU6',
7KHIROORZLQJLOOXVWUDWLRQVKRZVWKH'ULYLQJ0DFKLQHGDWDIORZ
ADAMS/Car Interface
Driver Driver ADAMS ADAMS

control control command dataset
data file file file file
(.dcd) (.dcf) (.acf) (.adm)
ADAMS/Car Solver
.msg
.req
.res Output files
.gra
.out
Driving Machine 87
Do the length units have to only be in (m), not (mm)???

&UHDWLQJGFIDQGGFG)LOHV
7RFUHDWHDGFIRUGFGILOH\RXQHHGDWH[WHGLWRU7KH
SUHIHUUHGZD\LVWRFRS\DGFIILOHIURPWKHVKDUHGGDWDEDVH
DQGPDNHWKHQHFHVVDU\FKDQJHVWRWKHGDWDEORFNV7KHIROORZLQJ
GHVFULEHVFKDQJHVWRWKHEORFNV
■ MDI header block - This does not require much editing: just make sure you start
with a .dcf file that was created for the same version of ADAMS/Car that you intend
to use.
■ Units block - The units should be those of the data in your .dcf file, which can be
different from you assembly units.
■ Experiment block - As seen below:
$---------------------------------------------------------------------------------EXPERIMENT
[EXPERIMENT]
EXPERIMENT NAME = ‘Constant Radius Cornering’
INITIAL_SPEED = 16.666
INITIAL_GEAR = 3
(mini_maneuver pri_end pri_value abort_time step_size
‘STEADY_STATE’ ‘VELOCITY’ 27.777 18.800 0.05
+HUH\RXGHILQHVRPHLQLWLDOVHWWLQJVDQGVSHFLI\WKHOLVWRIPLQL
PDQHXYHUV1RWHWKDW,1,7,$/B63(('DQG,1,7,$/B*($5DUH
WKHVSHHGDQGJHDUUHVSHFWLYHO\WKDW$'$06&DUZLOODSSO\DW
WKHILUVWWLPHVWHS/DVWLQWKHH[SHULPHQWGDWDEORFNLVWKHOLVW
RIWKHPLQLPDQHXYHUV\RXZDQWIRUWKHVLPXODWLRQ,QWKLV
H[DPSOHWKHUHLVRQO\RQHPDQHXYHUWRUXQ7KHPLQLPDQHXYHU
QDPHVOLVWHGPXVWPDWFKWKHQDPHVIRUWKHPLQLPDQHXYHUEORFN
88 Driving Machine
)RUHYHU\PLQLPDQHXYHU\RXPXVWVSHFLI\WKHIROORZLQJ
■ Pri_end - Primary end condition, which is the state you want to control the
termination. This could be one of the following:
◆ TIME
◆ DISTANCE
◆ VELOCITY
◆ ACCELERATION
■ Pri_value - The value to achieve for the primary end condition, +/- 0.2%.
■ Abort_time - The time when that mini-maneuver will be terminated, regardless if the
primary end condition has been achieved or not.
■ Step_size - The solver output step size.
(Note that new to v11.0, multiple end conditions can be specified, when the .dcf File
Version is 2.0. These end conditions can be for time, distance, velocity, acceleration
(longitudinal and lateral), and yaw (acceleration, displacement, and velocity). For
details, see the guide, Running Analyses in ADAMS/Car.
)RUHYHU\PLQLPDQHXYHU\RXVSHFLI\LQWKHH[SHULPHQWEORFN\RX
PXVWVSHFLI\DVHSDUDWHPLQLPDQHXYHUVXEEORFNWKDWPLJKWORRN
DVVKRZQQH[W
$---------------------------------------------------------------------------------STEADY_STATE
[STEADY_STATE]
(STEERING)
ACTUATOR_TYPE = ‘ROTATION’
this is the name of the mini-maneuver;
METHOD = ‘MACHINE’
(THROTTLE) it must match the name in the
METHOD = ‘MACHINE’ experiment block
(BREAKING)
METHOD = ‘MACHINE’
Driving Machine 89
(GEAR)
METHOD = ‘OPEN’
MODE = ‘ABSOLUTE’
CONTROL_TYPE = ‘CONSTANT’
CONTROL_VALUE =3
(CLUTCH)
METHOD = ‘OPEN’
MODE = ‘ABSOLUTE’
CONTROL_TYPE = ‘CONSTANT’
CONTROL_VALUE =0
(MACHINE_CONTROL)
STEERING_CONTROL = ‘SKIDPAD’
RADIUS = 80.0
TURN_ENTRY_DISTANCE = 30.0
TURN_DIRECTION = ‘LEFT’
SPEED_CONTROL = ‘VEL_POLYNOMIAL’
VELOCITY = 16.666
ACCELERATION = .855
JERK = 0.0
START_TIME = 3.800
+HUHWKHPLQLPDQHXYHUQDPH67($'<B67$7(LVVSHFLILHG

EHWZHHQWKHILUVWVHWRIVTXDUHEUDFNHWVDQGPXVWPDWFKWKH
QDPHOLVWHGLQWKHH[SHULPHQWEORFN(YHU\PLQLPDQHXYHU
VXEEORFNUHTXLUHVILYHDWWULEXWHVVWHHULQJWKURWWOHEUDNLQJ
JHDUDQGFOXWFKZKLFKDUHVSHFLILHGZLWKSDUHQWKHVHV+HUH
0$&+,1(B&21752/LVDQH[WUDEORFNWRSHUIRUPWKLV
IXQFWLRQ
90 Driving Machine
:LWKLQWKHVWHHULQJWKURWWOHEUDNLQJJHDUDQGFOXWFKYDULRXV
SDUDPHWHUVDUHDVVLJQHG1RWHVRQWKHVHSDUDPHWHUVDUHOLVWHG
QH[W
$&78$725B7<3(
$OORZVFKRLFHRIDFWXDWRULQSXW
■ ROTATION - Applies an angular motion to the steering column joint.
■ TRANS - Applies a translational motion to the steering rack joint.
■ FORCE - Applies a force to the steering rack.
■ TORQUE - Applies a torque to the steering wheel.
0(7+2'
6SHFLILHVWKHFRQWUROPHWKRGWRXVH
■ OPEN_CONTROL - Must be defined as a function of time. Must define the
CONTROL_TYPE argument.
■ MACHINE_CONTROL - Uses the Driving Machine controllers to drive the vehicle.
■ HUMAN_CONTROL - Uses ADAMS/Driver to control the vehicle.
02'(
6SHFLILHVZKHWKHUWRFDUU\VLJQDOVRQIURPSUHYLRXVPDQHXYHUVRU
VHWDQHZYDOXH
■ RELATIVE - Maintains the last signal from the previous mini-maneuver as the initial
input for the next mini-maneuver.
■ ABSOLUTE - Forces the initial input to be the value specified, which can cause
discontinuities in signals.
Driving Machine 91
Don’t go into in great detail

&21752/B7<3(
For steering, throttle, brake, clutch, and gear, you can define the control_type as:
◆ Constant
◆ Step
◆ Ramp
◆ Impulse
◆ Sine
◆ Swept_sine
◆ Data_driven
92 Driving Machine
)RUHYHU\FRQWUROW\SH0$&+,1(&21752/\RXPXVWLQFOXGHD
VHSDUDWHGDWDEORFN
67((5,1*
■ FILE - Supply a .dcd file.
■ STRAIGHT - Controls the vehicle to go straight from the initial position.
■ SKIDPAD - Controls the vehicle to drive on a skidpad. The following parameters

need to be defined as well.
■ TURN_DIRECTION - Left or right.
■ TURN_ENTRY_DISTANCE - Distance from start to turn.
■ RADIUS - Radius of skidpad.
■ MAINTAIN - Maintains the initial speed of the vehicle. The Driving Machine will
control the throttle to maintain the initial speed.
63(('B&21752/
■ FILE - Supply a .dcd file.
■ LAT_ACCEL - Controls the lateral acceleration.
■ LAT_ACCEL_TARGET - Lateral acceleration target.
■ MAX_ENGINE_SPEED - When it’s time to change gear.
■ MIN_ENGINE_SPEED - When it’s time to shift down.
Driving Machine 93
9(/B32/<120,$/
Defines a velocity curve.
■ VELOCITY - Velocity
■ ACCELERATION - Acceleration
■ JERK - Square of acceleration
■ START_TIME - The time when we hit the throttle.
■ The following equation is used:

IF (Time < START_TIME ):
SPEED = VELOCITY
IF (Time > START_TIME ):
SPEED = VELOCITY + ACCELERATION*(TIME – START_TIME)+1/2*
JERK(TIME-START_TIME)**2
94 Driving Machine
)RU+80$1FRQWURO$'$06'ULYHULVUHTXLUHGZLWKDVHSDUDWH
OLFHQVH<RXFDQQRWVZLWFKIURPDQRSHQORRSFRQWUROOHGPLQL
PDQHXYHUWRDKXPDQPLQLPDQHXYHUEXW\RXFDQVZLWFKIURP
KXPDQWRRSHQ$'$06'ULYHUDSSUR[LPDWHVWKHEHKDYLRURID
KXPDQGULYHUDQGLVFDSDEOHRIOHDUQLQJDQGDGDSWLQJWRWKH
FKDUDFWHULVWLFVRIWKHYHKLFOH
$UJXPHQWVXVHGZKHQXVLQJ+80$1FRQWURO
■ DRIVER_INPUT_FILE = STRING <filename.din> - This file specifies the option that
ADAMS/Driver uses to control the vehicle.
■ DRIVER_ROAD_FILE = STRING <filename.drd> - This file specifies the road as a set
of x, y coordinates and lane widths.
■ START_DRIVER_ACTIVITIES = VALUE <time> - Enter the time after the beginning
of the mini-maneuver when you want ADAMS/Driver to start controlling the vehicle.
If the mini-maneuver is the first in the experiment (simulation), this time must be
greater than zero.
■ LEARNING_ACTIVITIES = ‘LATERAL_DYNAMICS’ ||
‘LONGITUDINAL_DYNAMICS’ || ‘BASIC_DYNAMICS’ || ‘LIMIT_HANDLING’ ||
‘NONE’
Driving Machine 95
$'$06'ULYHUKDVWKHDELOLW\WROHDUQDQGDGDSWWRDSDUWLFXODU
YHKLFOH·VFKDUDFWHULVWLFV8VLQJ/($51,1*B$&7,9,7,(6\RX
VSHFLI\WKHNLQGRIOHDUQLQJ$'$06'ULYHUGRHV$'$06'ULYHU
VWRUHVZKDWLWOHDUQVDERXW\RXUYHKLFOHLQWKHRXWSXWNQRZOHGJH
ILOHIRUXVHLQVXEVHTXHQWVLPXODWLRQV
■ LATERAL_DYNAMICS - Learns and adapts to the vehicle’s lateral dynamics only.
■ LONGITUDINAL_DYNAMICS - Learns and adapts to the vehicle’s longitudinal

dynamics only.
■ BASIC_DYNAMICS - Learns and adapts to both the vehicle’s lateral and longitudinal
dynamics.
■ LIMIT_HANDLING - ADAMS/Driver learns and adapts to the vehicle’s limit handling
characteristics. To learn the limit handling characteristics of a vehicle,
ADAMS/Driver attempts to drive the vehicle as quickly as possible.
■ NONE - ADAMS/Car does not record any of the information resulting from the mini-
maneuver.
5(0(0%(5 ¶<(6·__12·
Select an option for REMEMBER. When you select YES, ADAMS/Driver reads the knowledge
file you specify using the KNOWL_INPUT_FILE argument. Each time you run
ADAMS/Driver, it creates a knowledge file, KNOWL_OUTPUT_FILE, to store what it learns
about the vehicle’s characteristics.
)RUHYHU\FRQWUROW\SH+80$1&21752/\RXPXVWLQFOXGHD
VHSDUDWHGDWDEORFN
(HUMAN_CONTROL)
DRIVER_INPUT_FILE = ‘<shared>/mdi_driver_001.din’
DRIVER_ROAD_FILE =‘<shared>/MDI_track.drd’
START_DRIVER_ACTIVITIES= 0.5
LEARNING_ACTIVITIES = ‘LIMIT_HANDLING’
REMEMBER = ‘YES’
KNOWL_INPUT_FILE = ‘limit_handling.kno’
KNOWL_OUTPUT_FILE = ‘limit_handling1.kno’
INITIAL_GEAR =3
96 Driving Machine
Examples in the future

7KHIROORZLQJWDEOHVXPPDUL]HVWKHFORVHGORRSGDWDWKDWDGFG
ILOHPD\FRQWDLQ7KHFROXPQVUHSUHVHQWVSHHGFRQWURORSWLRQV
IURPWKHGULYHUSDUDPHWHUVDUUD\7KHURZVUHSUHVHQWWKH
VWHHULQJFRQWURORSWLRQVIURPWKHGULYHUSDUDPHWHUVDUUD\7KH
LQWHUVHFWLRQVJLYHWKHGDWDFRQWDLQHGLQWKHGFGILOHDQGWKXV
WKHGDWDLQSXWWRWKHIXQQHOWRSURGXFH^[\YW`DVQHHGHGE\
'ULYHU/LWH
SPEED_CONTROL lon_vel lon_acc lat_acc path

none
STEERING_CONTROL (p1=0) (p1=1) (p1=2) (p1=3)
NOT {(distance {(distance or NOT VALID NOT

none VALID or time), time), VALID
lon_vel} lon_acc}
{distance, {(distance {(distance or {(distance or NOT

curvature curvature} or time), time), time), curvature, VALID
(p1 = 0) curvature, curvature, lat_acc}
lon_vel} lon_acc}
path {x, y} {x, y, vt} {x, y, {x, y, lat_acc} {x, y,

(p1 = 1) lon_acc} time}
NOT {distance or {distance or NOT VALID NOT

lat_acc VALID time, time, VALID
(p1 = 2) lat_acc, lat_acc,
lon_vel} lon_acc}
)RUH[DPSOHLI67((5,1*B&21752/ ¶SDWK·DQG
63(('B&21752/ ¶QRQH·WKHQLQWKH'$7$EORFNRI\RXUGFG
ILOH\RXQHHGDEORFNRI^;<`GDWDWRGHILQHWKHSDWKRI\RXU
YHKLFOH7KHSSDUDPHWHUVDUHWKHYDOXHVSDVVHGWRWKH6',
DUUD\VLQWKHDGPILOH
Driving Machine 97
More details on this in the documentation.

:RUNVKRS³(GLWLQJGFIDQGGFG)LOHV
XI XII I
X II
IX
VIII IV
III
VII VI V
3UREOHPVWDWHPHQW
In this workshop, you edit a .dcf and .dcd file from existing files in the default ADAMS/Car
shared database.
([DPSOHGFIILOH
$--------------------------------------------------MDI_HEADER
[MDI_HEADER]
FILE_NAME = iso_lane_change.dcf
FILE_TYPE = ’dcf’
FILE_VERSION = 1.0
FILE_FORMAT = ’ASCII’
(COMMENTS)
{comment_string}
’Example DCF file for Closed Loop ISO-Lane Change’
$-----------------------------------------------------UNITS
[UNITS]
LENGTH = ’meters’
FORCE = ’newton’
ANGLE = ’radians’
MASS = ’kg’
TIME = ’sec’
$-------------------------------------------------EXPERIMENT
[EXPERIMENT]
EXPERIMENT_NAME = ’ISO-Lane Change’
INITIAL_VELOCITY = 16.667
INITIAL_GEAR = 3
{mini_manuever pri_end pri_value abort_time step_size}
’LANE_CHANGE’ ’TIME’ 12.0 12.0 0.05
98 Driving Machine
■
$-------------------------------------------------LANE_CHANGE
[LANE_CHANGE]
(STEERING)
ACTUATOR_TYPE = ’ROTATION’
METHOD = ’MACHINE’
(THROTTLE)
(BRAKING)
ACTUATOR_TYPE = ’FORCE’
(GEAR)
METHOD = ’OPEN’
MODE = ’ABSOLUTE’
CONTROL_TYPE = ’CONSTANT’
CONTROL_VALUE = 3
(CLUTCH)
METHOD = ’OPEN’
MODE = ’ABSOLUTE’
CONTROL_TYPE = ’CONSTANT’
CONTROL_VALUE = 0
(MACHINE_CONTROL)
STEERING_CONTROL = ’FILE’
DCD_FILE = ’iso_lane_change.dcd’
SPEED_CONTROL = ’VEL_POLYNOMIAL’
VELOCITY = 16.667
ACCELERATION = 0.0
JERK = 0.0
TRANSITION_TIME = 0.0
MIN_ENGINE_SPEED = 750
MAX_ENGINE_SPEED = 6500
Here is the supporting .dcd file for the ISO lane change:
[MDI_HEADER]
FILE_NAME = iso_lane_change.dcd
FILE_TYPE = ’dcd’
FILE_VERSION = 1.0
(COMMENTS)
{comment_string}
’Example DCD file of ISO-Lane Change Path’
Driving Machine 99
$-----------------------------------------------------------UNITS
[UNITS]
LENGTH = ’meters’
FORCE = ’newton’
ANGLE = ’radians’
MASS = ’kg’
TIME = ’sec’
$------------------------------------------------------CLOSED_LOOP
[CLOSED_LOOP]
STEERING_CONTROL = ’path’
SPEED_CONTROL = ’none’
(DATA)
{X Y}
0.0 0.000
45.0 0.000
52.5 0.000
60.0 0.000
90.0 3.5
102.0 3.5
115.0 3.5
140.0 0
147.0 0
155.0 0
162.0 0
170.0 0
200.0 0
300.0 0
400.0 0
500.0 0
:RUNLQJZLWKWKHGHIDXOWGFIILOH
In this section, you open an assembly, perform a full-vehicle analysis on the default .dcf file,
and then review the results.
7RRSHQDQDVVHPEO\
2 Search the shared database for MDI_Demo_Vehicle.asy.
100 Driving Machine

7RSHUIRUPWKHIXOOYHKLFOHDQDO\VLV
1 From the Simulate menu, point to Full-Vehicle Analysis, and then select DCF Driven.
2 In the Output Prefix text box, enter default.
3 Right-click the Driver Control Files text box, and from <shared>\ driver_controls.tbl, double-
click iso_lane_change.dcf.
4 Select OK.
7RUHYLHZUHVXOWV
1 From the Review menu, select Postprocessing Window or press the F8 key.
2 From the Simulation list, select default_iso_lane_change.
3 From the Filter list, select user_defined.
4 From the Request list, select chassis_displacements.
5 From the Component list, select lateral.
6 Select Add Curves.
The plot displays the lateral displacement of the chassis, as defined in your driver control
data file. The plot shows how the car drives from one lane to another and back.
7RFRS\WKHGFIDQGGFGILOHVLQWR\RXUSULYDWHGDWDEDVH
1 From the Tools menu, point to Database Management, and then select Database Info to check
the path to the shared database.
2 From the shared database, copy the ISO lane change .dcf file, iso_lane_change.dcf, into
your private database.
3 Rename it to iso_lane_change_mod7.dcf.
4 From the shared database, copy the .dcd file, iso_lane_change.dcd, into your private
database.
5 Rename it iso_lane_change_mod7.dcd.
Driving Machine 101

(GLWLQJWKHGFGDQGGFIILOHV
Modify the .dcd file by increasing the displacement of the lane change, and then change the
names in your .dcf and .dcd files to correspond to their new names. For the .dcd file, rename the
file name in the MDI_HEADER block. For the .dcf file, rename the file name in the
MDI_HEADER and the LANE_CHANGE mini-maneuver blocks.
7RHGLWWKHLVRBODQHBFKDQJHBPRGGFGILOH
■ Change the three entries in the Y column data from 3.5 to 10, as seen in this excerpt:
$--------------------------------------------------------------------CLOSED_LOOP
[CLOSED_LOOP]
STEERING_CONTROL = ’path’
SPEED_CONTROL = ’none’
(DATA)
{X Y}
0.0 0.000
45.0 0.000
52.5 0.000
60.0 0.000
90.0 10
102.0 10
115.0 10
140.0 0
…
5XQQLQJDQDQDO\VLVDQGUHYLHZLQJLWVUHVXOWV
Run a full-vehicle analysis on the modified .dcf file in your private database.
7RSHUIRUPWKHIXOOYHKLFOHDQDO\VLV
1 From the Simulate menu, point to Full-Vehicle Analysis, and then select DCF Driven.
2 In the Output Prefix text box, enter mod7_iso.
3 Right-click the Driver Control File text box, point to Search, and then select
<private>\driver_controls.tbl.
4 Double-click iso_lane_change_mod7.dcf.
5 Select OK.
102 Driving Machine

7RUHYLHZWKHDQDO\VLVUHVXOWV
1 Launch ADAMS/PostProcessor.
You should still see the plot from the first lane change analysis.
2 From the Simulation list, select mod7_iso.
3 From the Filter list, select user_defined.
4 From the Request list, select chassis_displacements.
5 From the Component list, select lateral.
6 Select Add Curves.
The plot shows that the car has traveled farther than in the first analysis. It does not exactly
meet the desired path of 10 m (10000 mm), because a closed-loop controller performs the
maneuver to provide the best possible response given the desired output and simulation
conditions. If, say, we had given the Driving Machine more time and/or greater distance to
perform this maneuver, it would be able to more closely meet the 10 m desired path.
So, for example, if you changed your .dcd file as shown next, you would see that the lateral
displacement would be closer to the desired value of 10 m:
(DATA)
{X Y}
0.0 0.000
45.0 0.000
52.5 0.000
60.0 2
90.0 4
102.0 6
115.0 8
140.0 10
147.0 10
155.0 8
162.0 6
170.0 4
200.0 2
300.0 0.172
400.0 0.172
500.0 0.172
For more tips on the Driving Machine, see the knowledge base article 9058 (key words:
ADAMS/Driver, ADAMS/Driver-Lite, ADAMS Driving Machine, SDI, test rigs) at: http:/
/support.adams.com/kb/faq.asp?ID=kb9058.html.
Driving Machine 103

104 Driving Machine

3/27&21),*85$7,21),/(6
This module explains plot configuration files, how to create them, and how to
review the results of your analyses.
:KDW·VLQWKLVPRGXOH
■ What is a Plot Configuration File?, 106
■ Workshop 8—Creating Plot Configuration Files, 107
105
:KDWLVD3ORW&RQILJXUDWLRQ)LOH"
$SORWFRQILJXUDWLRQILOHGHILQHVDVHULHVRISUHGHILQHGSORWV
FUHDWHGE\XVLQJDQDO\VLVUHVXOWV7KLVILOHLVDFROOHFWLRQRISORW
WHPSODWHVWKDWVWRUHVWKHLQIRUPDWLRQDERXWZKDWRXWSXW
FRPSRQHQWVWRXVHIRUYHUWLFDODQGKRUL]RQWDOD[HVWLWOHVODEHOV
VFDOLQJOHJHQGVDQGVRRQ7KHVHILOHVVHWXSWKHFRPPDQGVWR
FUHDWHWKHSORWVQRWWKHDFWXDOSORWV7KLVILOHSUHYHQWV\RXIURP
FUHDWLQJHDFKLQGLYLGXDOSORWHYHU\WLPH\RXUXQDSDUWLFXODU
VLPXODWLRQ7KLVILOHLVVWRUHGLQWKHSORWBFRQILJVGLUHFWRU\WDEOH
DVDQ$6&,,ILOH
7RFUHDWHDSORWFRQILJXUDWLRQILOHILUVWFUHDWHWKHGHVLUHGSORWV
LQ$'$063RVW3URFHVVRUSDJHVDQGFXUYHV7KHQJRWR
)LOHV!([SRUW!3ORW&RQILJ
7RORDGDSORWFRQILJXUDWLRQILOHZKLOHLQ$'$063RVW3URFHVVRU
JRWR3ORW!&UHDWH3ORWVDQGVSHFLI\WKHDQDO\VLVDQGWKHSORW
FRQILJXUDWLRQILOH SOW
<RXFDQDOVRLQFOXGHDVHWRI$'$069LHZFRPPDQGVWRH[HFXWH
DIWHU\RX·YHORDGHGWKHGHILQHGSORWV7KHVHFRPPDQGVFDQ
FKDQJHWKHIRUPDWRIWKHSORWVRUPRGLI\WKHGDWDDVVRFLDWHG
ZLWKDFXUYH
106 Plot Configuration Files

:RUNVKRS³&UHDWLQJ3ORW&RQILJXUDWLRQ)LOHV
XI XII I
X II
IX
VIII IV
III
VII VI V
3UREOHPVWDWHPHQW
For this workshop, simply create a series of suspension plots and save a plot configuration file.
%DVLFSORWFRQILJXUDWLRQVWHSV
1 Run a suspension analysis in the Standard Interface.
2 Make plots by hand in ADAMS/PostProcessor.
3 Save the plot configuration file (.plt) in ADAMS/PostProcessor.
4 Re-run the analysis in Standard Interface.
5 Load the plot configuration file (.plt) in ADAMS/PostProcessor.
The same plots are made automatically with the plot configuration file.
Plot Configuration Files 107

:RUNVKRS³&UHDWLQJ3ORW&RQILJXUDWLRQ)LOHV
108 Plot Configuration Files

3$5$0(7(5,=$7,21
This module explains how ADAMS/Car models are parameterized, by

location and orientation, using hardpoints and construction frames.
:KDW·VLQWKLVPRGXOH
■ Parameterization in ADAMS/Car, 110
■ Creating Hardpoints, 111
■ Creating Construction Frames, 113
■ Location Parameterization, 115
■ Orientation Parameterization, 120
109
3DUDPHWHUL]DWLRQLQ$'$06&DU
:K\SDUDPHWHUL]H"
Parameterizing a template allows you to build relationships into the model so that when you
change a modeling entity, ADAMS/Car automatically updates all other entities that depend on
it. You can, therefore, build a whole vehicle model to depend on only a few key hardpoints and
variables, saving time and effort in making design changes.
:KDWFDQ\RXSDUDPHWHUL]H"
■ Location and orientation expressions
■ Geometry
■ Group activity
■ Functions
■ And so on
110 Parameterization
Go over quickly or let students read themselves

&UHDWLQJ+DUGSRLQWV
+DUGSRLQWVGHILQHDOONH\ORFDWLRQVLQ\RXUPRGHO7KH\DUHWKH
PRVWHOHPHQWDU\EXLOGLQJEORFNVWKDW\RXXVHWRSDUDPHWHUL]H
ORFDWLRQVIRUKLJKHUOHYHOHQWLWLHVVXFKDVFRQVWUXFWLRQIUDPHV
SDUWVDQGDWWDFKPHQWV+DUGSRLQWVDUHWKHVDPHDVSRLQWVLQ
$'$069LHZ
<RXFUHDWHKDUGSRLQWVLQ7HPSODWH%XLOGHU7RFUHDWHKDUGSRLQWV
JRWR%XLOG!+DUGSRLQWV!1HZ,QWKHGLDORJER[VSHFLI\WKH
QDPHRIWKHKDUGSRLQWLILW·VDOHIWULJKWRUVLQJOHDQGWKH
ORFDWLRQ:KHQ\RXFUHDWHDOHIWRUULJKWKDUGSRLQW$'$06&DU
FUHDWHVDFRUUHVSRQGLQJSDLUHGKDUGSRLQWE\UHIOHFWLQJWKH
ORFDWLRQDORQJWKHFDU·VORQJLWXGLQDOD[LV
<RXFDQPRGLI\KDUGSRLQWVE\ULJKWFOLFNLQJWKHKDUGSRLQWDQG
VHOHFWLQJWKHKDUGSRLQWQDPHIROORZHGE\0RGLI\
Parameterization 111
You can also select the hardpoint and pull down Edit->Modify or press Ctrl+E.
&UHDWLQJ+DUGSRLQWV
<RXFDQDOVRPRGLI\KDUGSRLQWVE\JRLQJWR%XLOG!+DUGSRLQW
ZKHUH\RXFDQVHOHFW
■ Table - Every hardpoint in the model appears and you can enter new locations for all.
■ Modify - You can modify only one hardpoint at a time.
&UHDWLQJ&RQVWUXFWLRQ)UDPHV
&RQVWUXFWLRQIUDPHVDUHEXLOGLQJEORFNVWKDW\RXXVHZKHQHYHUDQ
HQWLW\UHTXLUHVWKDW\RXVSHFLI\DQRULHQWDWLRQLQDGGLWLRQWRD
ORFDWLRQ&RQVWUXFWLRQIUDPHVDUHWKHVDPHDVPDUNHUVLQ
$'$069LHZ
7RFUHDWHFRQVWUXFWLRQIUDPHVJRWR%XLOG!&RQVWUXFWLRQ)UDPH
!1HZ,QWKHGLDORJER[VSHFLI\WKHQDPHDQGLILW·VDOHIW
ULJKWRUVLQJOH'HILQHWKHORFDWLRQDQGRULHQWDWLRQE\VHOHFWLQJ
RQHRIWKHIROORZLQJRSWLRQV
/RFDWLRQSDUDPHWHUL]DWLRQ
■ Delta location from coordinate
■ Centered between coordinates
■ Located on a line
■ Located along an axis
■ Location input communicator
■ Located at flexible body node
2ULHQWDWLRQSDUDPHWHUL]DWLRQ
■ User entered values (Euler angles)
■ Delta orientation from coordinate
■ Parallel to axis
■ Oriented in plane
■ Orient to zpoint - xpoint
■ Orient axis along line
■ Orient axis to point
■ Orientation input communicator
■ Toe/camber
&UHDWLQJ&RQVWUXFWLRQ)UDPHV
7RPRGLI\FRQVWUXFWLRQIUDPHVULJKWFOLFNWKHFRQVWUXFWLRQIUDPH
DQGVHOHFWWKHFRQVWUXFWLRQIUDPHQDPHIROORZHGE\0RGLI\
<RXFDQDOVRPRGLI\FRQVWUXFWLRQIUDPHVE\JRLQJWR%XLOG!
&RQVWUXFWLRQ)UDPH!0RGLI\,QWKHGLDORJER[VHOHFWWKHQDPH
RIWKHFRQVWUXFWLRQIUDPH\RXZDQWWRPRGLI\<RXFDQPRGLI\WKH
ORFDWLRQDQGRULHQWDWLRQ
/RFDWLRQ3DUDPHWHUL]DWLRQ
'HOWDORFDWLRQIURPFRRUGLQDWH
■ Locate with respect to a defined reference frame.
■ You can define X, Y, Z displacement in the local or global coordinate reference
frame.
Global reference frame
Coordinate reference
Location is 100 length units

along global x-axis
This picture had a gray background, and the previous had black, might want to be consistent. Same thing with bold text.
Sometime we have SGI type dialog boxes and sometime NT, might want to keep to one type.
&HQWHUHGEHWZHHQFRRUGLQDWHV
■ Using the two-coordinates method, the entity is located on the mid-point along an
imaginary line joining the defined reference coordinates.
■ Using the three-coordinate method, the entity is located on the center point of a plane
defined by the three reference coordinates.
/RFDWHGDORQJDQD[LV
■ The entity is located a defined distance along the chosen axis of the reference
construction frame.
■ In this example, the entity has been located 100 length units along the z-axis of the
reference construction frame.
/RFDWHGRQDOLQH
■ Locates the entity along a line defined by the two reference coordinates.
■ The entity is located a defined percentage along the line measured from the first
reference coordinate to the second reference coordinate.
/RFDWLRQLQSXWFRPPXQLFDWRU
■ Locates the entity using location data from the chosen input communicator.
■ Use this option to locate entities with respect to reference frames in other templates.
■ At the assembly stage, the location data is communicated to the input communicator
from the corresponding output communicator in the other template. Up to that point,
the entity is located at the initial value defined in the input communicator.
2ULHQWDWLRQ3DUDPHWHUL]DWLRQ
'HOWDRULHQWDWLRQIURPFRRUGLQDWH
■ Orients the entity with respect to the reference frame, using the Euler angle
orientation defined.
■ In this example, the entity has been defined such that there is no change in orientation
with respect to the reference construction frame.
'HOWDRULHQWDWLRQIURPFRRUGLQDWH
■ Orients the entity with respect to the reference frame, using the Euler angle
orientation defined.
■ In this example, the entity has been rotated -30 degrees about the reference frame
z-axis and then 90 degrees about the new x-axis.
3DUDOOHOWRD[LV
■ Orients the defined axis on the entity parallel to the defined axis on the reference
frame.
■ In this example, the z-axis of the entity is oriented parallel to the negative x-axis on
the reference frame.
2ULHQWHGLQSODQH
Orients the z-axis along a line defined by the first and second reference coordinates, and orients
the x-axis such that the entities zx plane lies in the plane defined by the three reference
coordinates.
2ULHQWWR]SRLQW[SRLQW
Orients the z-axis towards the first reference coordinate and the x-axis towards the second
reference coordinate.
Orients the x-axis towards the first reference coordinate and the z-axis towards the second
reference coordinate.
8VHUHQWHUHGYDOXHV
Orients the construction frame using Euler angles: Z-X’-Z’ incremental rotations with respect
to the global construction frame (origo).
1RWHV
%8,/',1*7(03/$7(6
This module provides details on creating templates, their components, and

their purpose in the hierarchy of ADAMS/Car.
:KDW·VLQWKLVPRGXOH
■ Template Overview, 128
■ Template Topology, 129
■ File Architecture, 130
■ Building a New Template, 132
■ Types of Parts, 133
■ Rigid Bodies (Parts), 134
■ Flexible Bodies (Parts), 135
■ Geometry, 136
■ Attachments (Joints and Bushings), 137
■ Springs, 138
■ Dampers, 140
■ Bumpstops and Reboundstops, 141
■ Suspension Parameter Array, 142
■ General Advice, 143
■ Workshop 9—Template-Builder Tutorial, 144
127
Let class read

7HPSODWH2YHUYLHZ
$'$06&DUWHPSODWHVDUHSDUDPHWHUL]HGPRGHOVLQZKLFK\RX
GHILQHWKHWRSRORJ\RIYHKLFOHFRPSRQHQWV%XLOGLQJDWHPSODWH
PHDQVGHILQLQJSDUWVKRZWKH\FRQQHFWWRHDFKRWKHUDQGKRZ
WKHWHPSODWHFRPPXQLFDWHVLQIRUPDWLRQWRRWKHUWHPSODWHVDQG
WKHWHVWULJ$WHPSODWHFRXOGUHSUHVHQWDVLQJOHVHWRI
FRPSRQHQWVRUDFRPSOH[FROOHFWLRQRIFRPSRQHQWV
$WWKHWHPSODWHOHYHOLWLVQRWFUXFLDOWKDW\RXFRUUHFWO\GHILQH
WKHSDUWV·PDVVSURSHUWLHVRUDVVLJQIRUFHFKDUDFWHULVWLFV
EHFDXVHWKLVFDQEHVHWDWWKHVXEV\VWHPOHYHO,WLVYHU\
LPSRUWDQWKRZHYHUWRFRUUHFWO\GHILQHSDUWFRQQHFWLYLW\DQG
H[FKDQJHRILQIRUPDWLRQEHFDXVH\RXFDQQRWPRGLI\WKHPDWWKH
VXEV\VWHPOHYHO
:KHQEXLOGLQJWHPSODWHVNHHSLQPLQGWKHDVVHPEO\SURFHVV7KDW
LVPDNHVXUHWKDW\RXUWHPSODWHVFDQFRPPXQLFDWHWRHDFKRWKHU
DQGFDQFRPPXQLFDWHWRWKHWHVWULJV\RXVSHFLI\&RPPXQLFDWRUV
GHILQHKRZWKHGLIIHUHQWVXEV\VWHPVH[FKDQJHLQIRUPDWLRQ
128 Building Templates
Let class read

7HPSODWH7RSRORJ\
,Q$'$06&DUFUHDWLQJWRSRORJ\FRQVLVWVRIFUHDWLQJHOHPHQWV
VXFKDVKDUGSRLQWVSDUWVDWWDFKPHQWVDQGSDUDPHWHUVWKDW
GHILQHVXEV\VWHPVDVH[SODLQHGQH[W
■ Creating hardpoints and construction frames - You first create hardpoints and
construction frames. Hardpoints and construction frames are the ADAMS/Car
elements that define all key locations and orientations in your model. They are the
most elementary building blocks that you can use to parameterize higher-level
entities. Hardpoint locations define most parts and attachments. Hardpoints are only
defined by their coordinate location. Coordinate frames are defined by their location
and orientation.
■ Creating parts - Once you’ve defined hardpoints and construction frames, you will
use them to create parts.
■ Creating attachments - Finally, you create the attachments, such as joints, bushings,
and parameters, which tell ADAMS/Car how the parts react in relation to one
another. You can define attachments for the compliant and kinematic analysis modes.
The compliant mode uses bushings, while the kinematic mode uses joints.
%HIRUH\RXEHJLQWREXLOG\RXUWHPSODWH\RXPXVWGHFLGHZKDW
HOHPHQWVDUHPRVWDSSURSULDWHIRU\RXUPRGHO<RXPXVWDOVR
GHFLGHZKLFKJHRPHWULHVVHHPPRVWDSSOLFDEOHWRHDFKSDUWRU
ZKHWKHU\RXZDQWDQ\JHRPHWU\DWDOO2QFH\RX·YHGHFLGHG\RX
FUHDWHDWHPSODWHDQGLWVEDVLFWRSRORJ\
Building Templates 129

)LOH$UFKLWHFWXUH
7KHILOHDUFKLWHFWXUHRIWKH$'$06WHPSODWHEDVHGSURGXFWVLV
FRPSULVHGRIWKHIROORZLQJW\SHVRIILOHVZKLFKDUHVWRUHGLQ
GDWDEDVHV
■ Property files
■ Templates
■ Subsystems
■ Assemblies
7KHILJXUHRQWKHQH[WSDJHLOOXVWUDWHVKRZWHPSODWHEDVHG
SURGXFWVXVHWKLVDUFKLWHFWXUHDWHPSODWHXVHVSURSHUW\ILOHVWR
SURYLGHGDWDIRUFRPSRQHQWVVXFKDVVSULQJVGDPSHUVDQG
EXVKLQJV:KHQFUHDWLQJDQHZVXEV\VWHP\RXFDQUHIHUHQFHWKH
SURSHUW\ILOHVWKDWWKHWHPSODWHUHIHUHQFHVRUUHIHUHQFHRWKHU
SURSHUW\ILOHVKHOGHLWKHULQDGLIIHUHQWGDWDEDVHRUZLWKD
GLIIHUHQWILOHQDPHDVLQGLFDWHGE\WKHGDVKHGOLQHV$FROOHFWLRQ
RIVXEV\VWHPVPHUJHGWRJHWKHUIRUPVDQDVVHPEO\

)LOH$UFKLWHFWXUH
Property File Property File optional

Property File Property File
mandatory
Property File Property File
Front Steering
Suspension Template
Template Property File
Property File
Property File
Subsystem Subsystem
File File
Test Rig
■ Suspension
■ Full Vehicle
■ User-Defined
Assembly

%XLOGLQJD1HZ7HPSODWH
7REXLOGDQHZWHPSODWH\RXZLOOFUHDWHYDULRXVSDUWV
JHRPHWULHVDWWDFKPHQWVMRLQWVDQGPRUH²DOORIWKHHQWLWLHV
QHFHVVDU\WRFUHDWH\RXUPRGHO7REXLOGDWHPSODWH\RXILUVW
QHHGWRNQRZDERXWWKHDYDLODEOHHQWLWLHVLQ$'$06&DUZKLFK
ZLOOEHGHVFULEHGLQWKHQH[WVHFWLRQV
'HVFULEHGLQWKLVPRGXOHDUH
■ Rigid bodies (parts)
■ Geometry
■ Attachments (joints and bushings)
■ Springs
■ Dampers
■ Bumpstops and reboundstops
■ The suspension parameter array
7HPSODWHVDOVRUHTXLUHFRPPXQLFDWRUVDYHU\LPSRUWDQWSDUWRI
$'$06&DUZKLFKDOORZ\RXWRSDVVGLIIHUHQWSLHFHVRI
LQIRUPDWLRQIURPVXEV\VWHPWRVXEV\VWHPDQGQHFHVVDU\IRU
DVVHPEOLHV&RPPXQLFDWRUVDUHGHVFULEHGLQWKHQH[WPRGXOH

7\SHVRI3DUWV
5LJLGERGLHVSDUWV
■ Are movable parts.
■ Have mass and inertia properties.
■ Cannot deform.
)OH[LEOHERGLHV
■ Are movable parts.
■ Have mass and inertia properties.
■ Can bend when forces are applied to them.
*URXQGSDUW
■ Must exist in every model.
■ Defines the global coordinate system (GCS) and the global origin, and, therefore,
remains stationary at all times.
■ Acts as the inertial reference frame for calculating velocities and acceleration.
0RXQWSDUWVDQGVZLWFKSDUWV
■ Mount parts are massless parts that will be replaced by other parts in the assembly
process.
■ Switch parts are also massless parts and act like a switch for connections. By
changing the switch part, one part will connect to another.

5LJLG%RGLHV3DUWV
$ULJLGERG\LVFDOOHGDJHQHUDOSDUWDQGLVDEEUHYLDWHGZLWK
JH>OUV@JHIRUJHQHUDOSDUW>OUV@IRUOHIWULJKWRUVLQJOH7KHVH
SDUWVFDQPRYHUHODWLYHWRRWKHUSDUWVDQGKDYHWKHIROORZLQJ
SURSHUWLHV
■ Mass
■ Inertia
■ Initial location and orientation [called a local body reference frame (LBRF) or a part
coordinate system (PCS)]
■ Initial velocities
7RFUHDWHDQHZULJLGERG\LQ$'$06&DUJRWR%XLOG!3DUWV
!*HQHUDO3DUWDQGVHOHFWHLWKHU
■ New - Specify the location and orientation of the local body reference frame (LBRF),
together with the mass properties for the body. This does not create the geometry of
the part.
■ Wizard - Select two or three hardpoints or construction frames that the part will be
parameterized against. The Wizard creates the part and the geometry.
$SDUWLVXVHGE\$'$066ROYHUWRSHUIRUPWKHDQDO\VLVDV
RSSRVHGWRDSDUW·VJHRPHWU\GHVFULEHGLQGeometryRQSDJH

)OH[LEOH%RGLHV3DUWV
<RXFUHDWHIOH[LEOHERGLHVE\LPSRUWLQJDQH[WHUQDOILOH)RU
LQIRUPDWLRQRQIOH[LEOHERGLHVVHHUsing Flexible BodiesRQSDJH

*HRPHWU\
$YHU\LPSRUWDQWDVSHFWRIWKH$'$06OLQHRISURGXFWVLVWKH
FRQFHSWRIJHRPHWU\NQRZQDVJUDSKLFVLQ$'$069LHZ
*HRPHWU\LVXVHGWRHQKDQFHWKHYLVXDOL]DWLRQRIDSDUWXVLQJ
SURSHUWLHVVXFKDV
■ Length
■ Radius
■ Width
■ Thickness
$VRSSRVHGWRSDUWVJHRPHWU\LVQRWQHFHVVDU\WRSHUIRUP
VLPXODWLRQV6R\RXFDQKDYHDSDUWZLWKRXWDJHRPHWU\EXWQRW
DJHRPHWU\ZLWKRXWDSDUW
1RWHWKDWVRPHWLPHV$'$06&DUFUHDWHVWKHJHRPHWU\IRU\RX
DXWRPDWLFDOO\ZKHQ\RXFUHDWHDSDUW)RUH[DPSOHWKH:L]DUG
RSWLRQGRHVWKLV+RZHYHULI\RXFUHDWHDSDUWZLWKWKH1HZ
RSWLRQQRJHRPHWU\LVFUHDWHG<RXFDQWKHQFUHDWHRUDGG
JHRPHWU\EDVHGRQ\RXURZQLQSXW

$WWDFKPHQWV-RLQWVDQG%XVKLQJV
$WWDFKPHQWVLQWKH$'$06&DUZRUOGDUHMRLQWVDQGEXVKLQJV
DQGWKHVHGHILQHKRZWKHSDUWVLQ\RXUPRGHOUHDFWWRRQH
DQRWKHU<RXFDQGHILQHDWWDFKPHQWVIRUWKHFRPSOLDQWDQG
NLQHPDWLFDQDO\VLVPRGHV7KHFRPSOLDQWPRGHXVHVEXVKLQJVZKLOH
WKHNLQHPDWLFPRGHXVHVMRLQWV
■ Bushings - Provide three-dimensional forces and moments between parts, calculated
with stiffnesses. You specify parameters, such as stiffness, preload and offset, that
define bushings. Note that this is different from the BUSHING statement in
ADAMS/View, which uses a constant stiffness and damping. In ADAMS/Car, the
bushing effectively acts as a FIELD in ADAMS/View.
■ Joints - Provide a kinematic constraint between parts. You specify the type of joint
that is applicable to your model.
<RXFDQSODFHERWKMRLQWVDQGEXVKLQJVDWWKHVDPHSDUW
FRQQHFWLRQVLQDPRGHO<RXFDQVZLWFKEHWZHHQWKHWZR
DWWDFKPHQWVDFWLYDWLQJRQHZKLOHGHDFWLYDWLQJWKHRWKHU7KXV
\RXFDQVLPXODWHNLQHPDWLFDQGFRPSOLDQWDQDO\VHVZLWKWKHVDPH
PRGHO<RXFDQDOVRPL[\RXUPRGHOXVLQJERWKMRLQWVDQGEXVKLQJV
IRUWKHVDPHDQDO\VLV

6SULQJV
:KHQFUHDWLQJDVSULQJ\RXQHHGWZRFRRUGLQDWHVWRDWWDFKWKH
WZRHQGVIRUWKHVSULQJ7KHFRRUGLQDWHVFDQEHHLWKHUKDUGSRLQWV
RUFRQVWUXFWLRQIUDPHV7KHQWRGHILQHWKHVSULQJ\RXPXVW
VSHFLI\
■ Two bodies between which you want the force to act and two reference frames
(points at which the spring is attached on the bodies).
■ Installed length of the spring, which will be used to derive the design preload on the
spring.
■ Property file, which contains the free length information, as well as the force/
deflection characteristics.
Might want to change the modify spring dbox to a create spring dbox.
6SULQJV
$'$06&DUFDOFXODWHVWKHIRUFHH[HUWHGE\WKHVSULQJXVLQJWKH
HTXDWLRQVVKRZQLQWKHILJXUH
Force = -k(C – DM(i,j))

C=FL – IL + DM(i,j)*
Installed length
Free length
Where,
■ C is a constant
■ FL is the is the free length of the spring, as defined in the property file
■ IL is the defined installed length
■ DM(i,j)* is the initial displacement between the I and J coordinate reference points. If
you enter a smaller value for DM(i,j)*, ADAMS/Car calculates an increased preload
for the spring; conversely, a decreased preload.
■ Force represents the spring force.
■ K is the nonlinear spring stiffness derived from the property file.
Might want to change the modify spring dbox to a create spring dbox.
'DPSHUV
:KHQFUHDWLQJGDPSHUV\RXVSHFLI\WKHWZRHQGSRLQWVDQGWKH
SURSHUW\ILOH8QOLNHDVSULQJDGDPSHUGRHVQ·WQHHGDSUHORDG
$'$06&DUDOVRFUHDWHVWKHJHRPHWU\IRUWKHGDPSHUOLNHWKH
RQHVKRZQQH[W

%XPSVWRSVDQG5HERXQGVWRSV
%XPSVWRSV
■ Define a force-displacement relationship between two parts. Bumpstops act between
user-specified coordinate reference points on each part, and conform to the force-
displacement curve described in the designated property file. The bumpstop force is
activated when the displacement between the two coordinate references exceeds a
certain value, that can be defined either by either of the following:
◆ Clearance - Defines how much part I can travel towards part J before the force
activates.
◆ Impact length - Defines how close part I can come to part J before the force
activates.
5HERXQGVWRSV
■ Work similarly to bumpstops, but act in rebound, instead of jounce like bumpstops.
$'$06&DUDOVRFUHDWHVJUDSKLFVIRUWKHHOHPHQWVVKRZQQH[W
J part
Clearance
I part

6XVSHQVLRQ3DUDPHWHU$UUD\
<RXDFFHVVWKHVXVSHQVLRQSDUDPHWHUDUUD\GLDORJER[E\JRLQJWR
%XLOG!6XVSHQVLRQ3DUDPHWHUV!&KDUDFWHULVWLFV$UUD\!6HW
<RXILUVWFUHDWHYDULDEOHVGHILQLQJWRHDQGFDPEHUDQJOHV
%HFDXVHWKHVHYDULDEOHVDUHFRPPRQO\XVHGIRUVXVSHQVLRQ
DQDO\VHV$'$06&DUFUHDWHVERWKRIWKHPLQRQHVWHS7KHVH
DUHGHILQHGXVLQJDVWHHUD[LV
$VWHHULQJD[LVLVFUHDWHGXVLQJHLWKHURIWKHVHPHWKRGV
■ Geometric method - ADAMS/Car calculates the steer axis by passing a line through
two noncoincident points located on the steer axis. To use the geometric method, you
must identify two parts and two hardpoints that fix the steer axis. For a MacPherson
strut type suspension, you might identify the wheel carrier part and a hardpoint
located at the lower ball joint for the first point and the strut rod and a hardpoint
located where the strut attaches to the body for the second point.
■ Instant-axis method - ADAMS/Car calculates the left and right steer axes from the
suspension’s compliance matrix. While the calculation is performed numerically, it is
best described in physical terms. To calculate the steer axis at a given suspension
position, ADAMS/Car first locks the spring travel and applies an incremental steering
torque or force. Then from the resulting translation and rotation of the wheel carrier
parts, ADAMS/Car calculates the instant axis of rotation for each wheel carrier. The
instant axes of rotation are the steer axes.
)LQDOO\\RXVHWWKHVXVSHQVLRQW\SHDVEHLQJLQGHSHQGHQWRU
GHSHQGHQW
Adjustable Forces are used to change toe and camber angles. This is accomplished by breaking an arm of the suspen-
sion in two, adding a translational join and an Adjustable Force to push or pull the parts to achieve the desired toe or
camber angle (see the double_wishbone_torsion template for an example).
*HQHUDO$GYLFH
0DNHDVNHWFKRQSDSHUILUVW
6WDUWZLWKWKHKDUGSRLQWV)ROORZFRUSRUDWHQDPLQJRUQXPEHULQJ
FRQYHQWLRQZKHUHSRVVLEOH7KLVHQVXUHVWKDW\RXUWHPSODWHVFDQ
EHVXFFHVVIXOO\XVHGE\RWKHUVZLWKLQ\RXUFRPSDQ\
3URFHHGGRZQWKURXJKWKH%XLOGPHQX
:ULWHFRPPHQWVWULQJVZKHQFUHDWLQJQHZREMHFWV
'RQ·WIRUJHWWKHUHLVGLDORJER[KHOSXVLQJWKH)NH\LI
LQVWDOOHGDVZHOODVRQOLQHKHOS
)RUVRPHFRPSRQHQWV\RXKDYHPRUHRSWLRQVLQWKHPRGLI\GLDORJ
ER[WKDQLQWKHFUHDWHGLDORJER[IRUH[DPSOHULJLGSDUW,Q
WKDWFDVHFUHDWHWKHFRPSRQHQWILUVWDQGWKHQSDUDPHWHUL]HLW
SURSHUO\XVLQJWKHPRGLI\GLDORJER[
3DUWVFDQEHULJLGIOH[LEOHERGLHVPRXQWVVZLWFKQRQOLQHDUURGV
EHDPVLQ$'$069LHZWHUPLQRORJ\
7KHPDVVSURSHUWLHVRIULJLGSDUWVFDQEHXVHUHQWHUHGRU
JHRPHWU\EDVHG
6XSSRUWHGJHRPHWULHVDUHF\OLQGHUVHOOLSVRLGVDUPVOLQNVDQG
RXWOLQHV
$WWDFKPHQWVFDQEHNLQHPDWLFFRQVWUDLQWVRUEXVKLQJV
)RUFHHOHPHQWVLQFOXGHVSULQJVGDPSHUVEXPSVWRSVDGMXVWDEOH
IRUFHV
$GYDQFHGHOHPHQWVDUHGHVFULEHGLQWKHIROORZLQJFKDSWHUV

:RUNVKRS³7HPSODWH%XLOGHU7XWRULDO
XI XII I
X II
IX
VIII IV
III
This workshop takes about two hours to complete.
VII VI V
Go through Template-Builder Tutorial in the guide, Getting Started Using ADAMS/Car.

As you go through the tutorial, keep in mind that when building new templates, it’s good
practice is to write documentation about the templates. Otherwise, it will be difficult for
someone else to use your templates.

&20081,&$7256
This module introduces communicators, which control how ADAMS/Car

assemblies are created and how subsystems exchange information.
:KDW·VLQWKLVPRGXOH
■ Types of Communicators, 146
■ Classes of Communicators, 147
■ Communicator Roles, 149
■ Naming Communicators, 150
■ Matching Communicators During Assembly, 151
■ Workshop 10—Getting Information About Communicators, 155
145
7\SHVRI&RPPXQLFDWRUV
&RPPXQLFDWRUVDUHWKHNH\HOHPHQWVLQ$'$06&DUWKDWHQDEOH
WKHGLIIHUHQWVXEV\VWHPVWKDWPDNHXS\RXUDVVHPEO\WRH[FKDQJH
LQIRUPDWLRQZLWKHDFKRWKHUDQGZLWKWHVWULJV
$FRPPXQLFDWRULVDQ$'$069LHZYDULDEOH$FRPPXQLFDWRU
FRQWDLQVHLWKHUDQ
■ Object (for example, a part, variable, marker, or joint)
■ Real value (for example, x,y,z location)
■ String
7\SHVRI&RPPXQLFDWRUV
An assembly requires two directions of data transfer between its subsystems. To provide for
these two directions of data transfer, ADAMS/Car has two types of communicators:
■ Input communicators - Demand information from other subsystems or test rigs.
■ Output communicators - Provide information to other subsystems or test rigs.
7KLQNRIDQLQSXWFRPPXQLFDWRUDVDQHOHFWULFDOSOXJDQGDQ
RXWSXWFRPPXQLFDWRUDVDSRZHUVWULS7KHHOHFWULFDOSOXJUHTXLUHV
HOHFWULFLW\IURPWKHSRZHUVWULS
)RUH[DPSOHDPRXQWFRPPXQLFDWRULQWKHUDFNDQGSLQLRQVWHHULQJ
WHPSODWHVRXWSXWVWKHUDFNSDUWQDPHVRWKDWWLHURGVRI
VXVSHQVLRQWHPSODWHVFDQDWWDFKWRWKHUDFN,QDGGLWLRQDPRXQW
FRPPXQLFDWRULQWKHVWHHULQJWHPSODWHLQSXWVDSDUWQDPHWR
GHWHUPLQHZKHUHWRDWWDFKWKHVWHHULQJFROXPQWRWKHERG\
146 Communicators
&ODVVHVRI&RPPXQLFDWRUV
7KHFODVVRIDFRPPXQLFDWRULQGLFDWHVWKHNLQGRILQIRUPDWLRQLW
H[FKDQJHV)RUH[DPSOHFRPPXQLFDWRUVRIWKHFODVVKDUGSRLQW
H[FKDQJHDORFDWLRQWKURXJKDKDUGSRLQWQDPHDQGDSDUWQDPH
7KHFODVVHVRIFRPPXQLFDWRUVDQGWKHLQIRUPDWLRQWKDWHDFKFODVV
H[FKDQJHVDUHOLVWHGLQWKHWDEOHEHORZ7KHFODVVHVDSSO\WRERWK
LQSXWDQGRXWSXWFRPPXQLFDWRUV
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 Hardpoint and part name to provide both location and part information. If the
hardpoint is part of a symmetrical pair, the template-based products create an
input communicator for each hardpoint 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 A parameter variable name of the type integer.
parameter
Communicators 147
&ODVVHVRI&RPPXQLFDWRUV
$FRPPXQLFDWRUFDQEHHLWKHUVLQJOHRUEHSDUWRIDV\PPHWULFDO
SDLUHLWKHUOHIWRUULJKW(QWLW\FODVVHVDUUD\GLIIHUHQWLDO
HTXDWLRQPRWLRQSDUDPHWHUYDULDEOHVROYHUYDULDEOHDQGVSOLQH
KDYHQRV\PPHWU\DQGWKHUHIRUHDUHDOZD\VVLQJOHE\GHIDXOW
148 Communicators
&RPPXQLFDWRU5ROHV
(DFKFRPPXQLFDWRUKDVDPLQRUUROH$PLQRUUROHGHILQHVWKH
FRPPXQLFDWRU·VSRVLWLRQLQWKHDVVHPEO\$'$06&DUSURYLGHV\RX
ZLWKILYHGHIDXOWPLQRUUROHV
■ Front
■ Rear
■ Trailer
■ Inherit
■ Any
,I\RXVHOHFWLQKHULWWKHPLQRUUROHRIWKHFRPPXQLFDWRUZLOO
EHFRPHWKDWRIWKHVXEV\VWHPXVLQJWKHWHPSODWH
<RXFDQGHILQHDFRPPXQLFDWRU·VPLQRUUROHZKHQ\RXFUHDWHLW
)RUH[DPSOHLI\RXZDQWWRSURYLGHLQSXWWRRURXWSXWIURP
VXEV\VWHPVRIVSHFLILFUROHVWKHQ\RXVHWWKHPLQRUUROHIRU
FRPPXQLFDWRUVZKHQ\RXFUHDWHWKHP:HUHFRPPHQGKRZHYHU
WKDW\RXGRQRWVHWDFRPPXQLFDWRU·VPLQRUUROH,QVWHDGOHWWKH
VXEV\VWHPGRLW)RUH[DPSOHDVXVSHQVLRQWHPSODWHPLJKWEH
XVHGWRGHILQHHLWKHUDIURQWRUUHDUVXVSHQVLRQVXEV\VWHP%\
OHWWLQJWKHVXEV\VWHPGHWHUPLQHWKHPLQRUUROHWKHDVVHPEO\
SURFHVVDWWDFKHVDVWHHULQJV\VWHPWRWKHIURQWVXVSHQVLRQDQG
QRWWRWKHUHDU
Communicators 149
1DPLQJ&RPPXQLFDWRUV
$IWHU\RXFUHDWHDFRPPXQLFDWRU$'$06&DUDVVLJQVDSUHIL[WR
WKHQDPH)RUH[DPSOHLWFUHDWHVDSUHIL[FLOBZKHUHFL
LQGLFDWHVLWLVDQLQSXWFRPPXQLFDWRU,ILWZHUHDQRXWSXW
FRPPXQLFDWRU$'$06&DUZRXOGXVHFROLQGLFDWHVLWLVIRUWKH
OHIWVLGHRIDV\PPHWULFDOSDLU,ILWZHUHIRUWKHULJKWVLGH
$'$06&DUZRXOGXVHDQUFLU,ILWZHUHDVLQJOH
FRPPXQLFDWRULWZRXOGKDYHDQVFLV
,I\RXFUHDWHDPRXQWSDUW$'$06&DUDXWRPDWLFDOO\FUHDWHVDQ
LQSXWFRPPXQLFDWRURIWKHFODVVPRXQW,WXVHVWKHQDPHRIWKH
PRXQWSDUWDVWKHQDPHRIWKHFRPPXQLFDWRUDQGDSSHQGVWKH
SUHIL[FL>OUV@BWRLWGHSHQGLQJRQZKHWKHURUQRWLWLVDOHIW
ULJKWRUVLQJOHFRPPXQLFDWRU)RUH[DPSOHLI\RXFUHDWHDPRXQW
SDUWRIPWOBUDFNBPRXQW$'$06&DUFUHDWHVDQLQSXW
FRPPXQLFDWRUZLWKWKHQDPHFLOBUDFNBPRXQWZKHUHWKHOLQGLFDWHV
LWLVIRUWKHOHIWVLGH1RWH<RXFDQQRWFUHDWHDPRXQWLQSXW
FRPPXQLFDWRUE\LWVHOI<RXPXVWFUHDWHDPRXQWSDUWDQG
$'$06&DUZLOODXWRPDWLFDOO\FUHDWHWKHFRPPXQLFDWRUIRU\RX
$V\RXQDPHFRPPXQLFDWRUV\RXVKRXOGHQVXUHWKDWDQ\LQSXWDQG
RXWSXWFRPPXQLFDWRUVWKDWH[FKDQJHLQIRUPDWLRQKDYHPDWFKLQJ
QDPHV)RUH[DPSOHWKHQDPH\RXJLYHWRFRPPXQLFDWRUVWKDW
H[FKDQJHDSDUWQDPHGXULQJDVVHPEO\PLJKWEH
FL>OUV@BVWUXWBPRXQWDQGFR>OUV@BVWUXWBPRXQW,QDGGLWLRQLI\RX
DUHZRUNLQJZLWK0',WHPSODWHV\RXPXVWHQVXUHWKDW\RXXVH
WKHVDPHQDPLQJFRQYHQWLRQVDVWKH0',WHPSODWHV
150 Communicators
0DWFKLQJ&RPPXQLFDWRUV'XULQJ$VVHPEO\
)RUDSDLURIFRPPXQLFDWRUVWRH[FKDQJHLQIRUPDWLRQGXULQJ
DVVHPEO\WKHFRPPXQLFDWRUVPXVW
1 Have matching names.
2 Be of opposite types (one input, one output).
3 Be of the same symmetry type (left, right, or single).
4 Be of the same class (exchange the same type of information); for example, mount.
5 Have the same minor role or be assigned a role of any.
,IDQLQSXWFRPPXQLFDWRUGRHVQRWKDYHDFRUUHVSRQGLQJRXWSXW
FRPPXQLFDWRU$'$06&DUUHWXUQVDZDUQLQJPHVVDJHDQGLI
WKHLQSXWFRPPXQLFDWRUEHORQJVWRWKHFODVVPRXQW$'$06&DU
DVVLJQVWKHPRXQWSDUWWRJURXQG$'$06&DUJLYHV\RXDZDUQLQJ
PHVVDJHEHFDXVH\RXULQSXWFRPPXQLFDWRUGRHVQRWKDYHWKH
LQIRUPDWLRQLWUHTXLUHVDQGWKXV\RXUDVVHPEO\PD\QRWKDYHDOO
RIWKHLQIRUPDWLRQLWQHHGVWRZRUNSURSHUO\
2QWKHRWKHUKDQGLIDQRXWSXWFRPPXQLFDWRULVQRWOLQNHGXSZLWK
RQHRUPRUHLQSXWFRPPXQLFDWRUV\RXZLOOQRWJHWDZDUQLQJXSRQ
DVVHPEOLQJ\RXUVXEV\VWHPVEHFDXVHVLPSO\SXEOLVKLQJLQIRUPDWLRQ
KDVQRGLUHFWHIIHFWRQWKHRSHUDWLRQRI\RXUDVVHPEO\
<RXFDQVWLOODQDO\]HWKHPRGHOLILWGRHVQRWKDYHPDWFKLQJ
FRPPXQLFDWRUV,QIDFW\RXPD\ILQGWKLVKHOSIXOLI\RXZDQWWR
UXQDQDQDO\VLVRIDVXEV\VWHPZLWKRXWDWWDFKLQJDQRWKHU
VXEV\VWHPWRLW
Communicators 151
0DWFKLQJ&RPPXQLFDWRUV'XULQJ$VVHPEO\
)RUH[DPSOHWKHIROORZLQJSDLUVRILQSXWDQGRXWSXW
FRPPXQLFDWRUVPDWFKDQGH[FKDQJHDSDUWQDPHGXULQJDVVHPEO\
3 1
The pair: Belongs to the class: From minor role: To minor role:
2 cil_strut_mount mount 4 front 5
col_strut_mount mount front
cil_strut_mount mount any
col_strut_mount mount front
cil_strut_mount mount front
col_strut_mount mount any
,QDGGLWLRQDQLQSXWFRPPXQLFDWRUFDQRQO\EHPDWFKHGZLWKRQH
RXWSXWFRPPXQLFDWRUEXWRQHRXWSXWFRPPXQLFDWRUFDQEH
PDWFKHGZLWKDQXQOLPLWHGQXPEHURILQSXWFRPPXQLFDWRUV7KLVLV
EHFDXVHLQSXWFRPPXQLFDWRUVQHHGDOORIWKHLQIRUPDWLRQSURYLGHG
E\DVLQJOHRXWSXWFRPPXQLFDWRUDQGLIWKHUHLVPRUHWKDQRQH
VSHFLILHGWKHLQSXWFRPPXQLFDWRUZLOOQRWNQRZZKLFKRQHWR
FKRRVH
$OWHUQDWLYHO\RXWSXWFRPPXQLFDWRUVMXVWSXEOLVKLQIRUPDWLRQDQG
FDQJLYHWKLVLQIRUPDWLRQWRZKDWHYHULQSXWFRPPXQLFDWRUQHHGVLW
<RXVKRXOGDOZD\VFKHFNWKHZDUQLQJPHVVDJHVGXULQJWKH
DVVHPEO\HVSHFLDOO\LIWKHZDUQLQJVUHIHUWRDQLQSXW
FRPPXQLFDWRURIFODVVPRXQWWKDWGRHVQRWJHWDVVLJQHGDQGLV
WKHUHIRUHDWWDFKHGWRJURXQG
152 Communicators
0DWFKLQJ&RPPXQLFDWRUVZLWK7HVW5LJV
:KHQ\RXFUHDWHDWHPSODWH\RXPXVWPHHWWKHIROORZLQJ
FRQGLWLRQVWRHQVXUHWKDWDQDO\VHVZLOOZRUNZLWK\RXUQHZ
WHPSODWH
■ The template must be compatible with other templates and with the test rigs, for
example, the .__MDI_SUSPENSION_TESTRIG.
■ The template must contain the proper output communicators.
,IWKHWHPSODWHLVDVXVSHQVLRQWHPSODWHWKDWLVLWVPDMRUUROHLV
VXVSHQVLRQLWPXVWFRQWDLQDVXVSHQVLRQSDUDPHWHUVDUUD\7KH
VXVSHQVLRQSDUDPHWHUVDUUD\LGHQWLILHVWRWKHVXVSHQVLRQDQDO\VLV
KRZWKHVWHHUNLQJSLQD[HVVKRXOGEHFDOFXODWHGDQGZKHWKHUWKH
VXVSHQVLRQLVLQGHSHQGHQWRUGHSHQGHQW
)RUH[DPSOHIRUDVXVSHQVLRQWHPSODWHWREHFRPSDWLEOHZLWK
BB0',B6863(16,21B7(675,*WKHVXVSHQVLRQWHPSODWHPXVW
FRQWDLQWKHIROORZLQJRXWSXWFRPPXQLFDWRUV,QWKHWDEOHWKH
SUHIL[>OU@LQGLFDWHVWKDWWKHUHLVERWKDOHIWDQGULJKW
FRPPXQLFDWRURIWKHVSHFLILHGQDPH
2XWSXW&RPPXQLFDWRUVLQ6XVSHQVLRQ7HPSODWH
The communicator: Belongs to the class: From minor role:
co[lr]_suspension_mount mount inherit
co[lr]_wheel_center location inherit
co[lr]_toe_angle parameter_real inherit
co[lr]_camber_angle parameter_real inherit
Communicators 153
0DWFKLQJ&RPPXQLFDWRUVZLWK7HVW5LJV
7KHFR>OU@BVXVSHQVLRQBPRXQWRXWSXWFRPPXQLFDWRUVSXEOLVKWKH
SDUWVWRZKLFKWKHWHVWULJZKHHOVVKRXOGPRXQW$V\RXFUHDWH
WKHVHFRPPXQLFDWRUVPDNHVXUHWKDW\RXVHWWKHLUPLQRUUROHWR
LQKHULW%\VHWWLQJWKHPLQRUUROHWRLQKHULWWKHFRPPXQLFDWRU
WDNHVLWVPLQRUUROHIURPWKHPLQRUUROHRIWKHVXEV\VWHPVWKDW
XVH\RXUVXVSHQVLRQWHPSODWH
7KHFR>OU@BZKHHOBFHQWHURXWSXWFRPPXQLFDWRUVSXEOLVKWKHORFDWLRQ
RIWKHZKHHOFHQWHUVWRWKHWHVWULJVRWKHWHVWULJFDQORFDWH
LWVHOIUHODWLYHWRWKHVXVSHQVLRQ$V\RXFUHDWHWKHVHW\SHVRI
FRPPXQLFDWRUVPDNHVXUHWKDW\RXDOVROHDYHWKHLUPLQRUUROHVHW
WRLQKHULW
7KHWRHDQGFDPEHUFRPPXQLFDWRUVFR>OU@BWRHBDQJOHDQG
FR>OU@BFDPEHUBDQJOHSXEOLVKWRWKHWHVWULJWKHWRHDQGFDPEHU
DQJOHVVHWLQWKHVXVSHQVLRQVRWKHWHVWULJFDQRULHQWWKHZKHHOV
FRUUHFWO\
)RUPRUHLQIRUPDWLRQVHHWKHJXLGH%XLOGLQJ7HPSODWHVLQ
$'$06&DU
154 Communicators
:RUNVKRS³*HWWLQJ,QIRUPDWLRQ$ERXW&RPPXQLFDWRUV
XI XII I
X II
IX
VIII IV
III
VII VI V
In this workshop, you learn how to perform tests and display information that will help you
understand communicators.
*HWWLQJFRPPXQLFDWRULQIRUPDWLRQ
7RJHWLQIRUPDWLRQDERXWDFRPPXQLFDWRULQ\RXUWHPSODWH
■ From the Build menu, point to Communicator, and then select Info.
Note: In Model Names, your current open template will automatically be selected.
7ROLVWLQIRUPDWLRQDERXWDOOWKHFRPPXQLFDWRUVLQ\RXUWHPSODWH
1 In the Communicators Info dialog box, set Entity to All.

2 Select OK.
The Information window lists information for all communicators:
Communicators 155
■
&KHFNLQJFRPPXQLFDWRUV
In this section, you set up your workspace such that you can see how the communicators in your
rack and pinion template match up with those in a suspension template.
You will open an existing template you know your new template will be connected to when you
run analyses. This allows you to see which communicators the other template requires to
function together with your template. You need to open a suspension template to do this.
Note: Make sure that all templates you want to test are open in your ADAMS/Car session.
7RRSHQDWHPSODWH

2 Right-click the Template Name text box, point to Search, and then select
<shared>\templates.tbl.
3 Double-click _double_wishbone_torsion.tpl.
The template opens as a new model, unassociated with your rack and pinion template,
which is still open.
The double-wishbone suspension appears in your workspace.
7RSHUIRUPDFRPPXQLFDWRUWHVW
1 From the Build menu, point to Communicator, and then select Test.
2 Right-click the Model Names text box, point to Model, point to Guesses, and then select
_double_wishbone_torsion.
3 Repeat Step 2 to select _rack_pinion_steering.
156 Communicators
■
■
4 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.
Note: Each communicator has a minor role, which by default is one of the following:
any, front, rear, trailer, or inherit. The inherit minor role specifies that when
ADAMS/Car 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 area provides the communicators with their minor role. For
example, if you assign the template susp_02, a minor role of front in the Minor
Roles text area, the communicator test also changes the minor role of any
communicators in susp_02 whose minor role is inherit to the role of front.
5 If you’ve used the Information window before, select Clear Information Window.
6 If you want to save the results, select Save Test Results to File.
7 In the File Name text box, enter a file name.
8 Select OK.
The Information window, as shown next, lists the communicators that match other
communicators and 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.
In this case, note that the communicators rack_housing_to_suspension_subframe and
tierod_to_steering are matched. However, communicators such as rack_to_body, and
max_rack_force are unmatched, because the particular templates which require this
information were not selected (and unopened).
Communicators 157
■
To get to know the topology of the communicators within a template, study the inputs and
outputs and look to see how they link with other templates. When you create
communicators in a new template, a good way to create the communicators is to open an
existing template and create the same communicators.
A final tip is to remember that output communicators publish information. Therefore, they
are passive and do not affect subsystem behavior. However, input communicators search
for information. They affect your simulation, particularly if they do not match.
For more tips on how to get information about communicators, see Article 8924,
Investigating Existing Templates in the Knowledge base, at: http://support.adams.com/kb/
faq.asp?ID=kb8924.html.
158 Communicators
■
86,1*)/(;,%/(%2',(6
In this module, you will learn how to create flexible bodies in your models, as
well as how to swap a rigid body for a flexible body.
:KDW·VLQWKLVPRGXOH
■ Flexible Body Overview, 160
■ Limitations of Flexible Bodies, 161
■ Getting Flexible Bodies, 162
■ Workshop 11—Flex Tutorial, 163
159
Go over briefly.
Large displacement code vs. FEA (small displacement)
Systems based for mechanical systems
GUI just makes .adm for solver
)OH[LEOH%RG\2YHUYLHZ
$'$06)OH[XVHVDQDVVXPHGPRGHVPHWKRGRIPRGHOLQJIOH[LEOH
ERGLHVFDOOHGPRGDOIOH[LELOLW\0RGDOIOH[LELOLW\DVVLJQVDVHWRI
PRGHVKDSHVWRDIOH[LEOHERG\7KLVPRGDOPHWKRGRIPRGHOLQJ
IOH[LELOLW\FDQEHYHU\XVHIXOLQSUREOHPVWKDWDUHFKDUDFWHUL]HG
E\KLJKHODVWLFLW\DQGPRGHUDWHGHIOHFWLRQV7KDWLVGHIOHFWLRQV
OHVVWKDQRIDFKDUDFWHULVWLFOHQJWKRIWKHERG\
%\LQWHJUDWLQJIOH[LEOHERGLHVLQWR\RXUPRGHO\RXFDQ
■ Capture inertial and compliance properties during handling and comfort simulations.
■ Predict loads with greater accuracy by allowing ADAMS to account for flexibility
during simulations.
■ Study deformation.
■ Examine the linear system modes of a flexible model when you use ADAMS/Flex
with ADAMS/Linear.
<RXVKRXOGXVHIOH[LEOHERGLHVZKHUHYHU\RXH[SHFWFRPSRQHQW
IOH[LELOLW\WRDIIHFWWKHG\QDPLFEHKDYLRURI\RXUPRGHORUZKHQ
\RXUHTXLUHDFFXUDWHLQIRUPDWLRQDERXWWKHGHIRUPDWLRQVRID
FRPSRQHQWLQ\RXUPRGHO
160 Using Flexible Bodies

/LPLWDWLRQVRI)OH[LEOH%RGLHV
:KHQ\RXXVHIOH[LEOHERGLHVUHPHPEHUWKDWIOH[LEOHERG\
GHIRUPDWLRQVDUHDOLQHDUFRPELQDWLRQRIGHIRUPDWLRQVKDSHV
&RQVHTXHQWO\WDNHVSHFLDOSUHFDXWLRQVZKHQPRGHOLQJKLJKHURUGHU
GHIRUPDWLRQVVXFKDVWKRVHWKDWRFFXUZKHQGHIRUPDWLRQVDUH
ODUJHRUZKHQDWWHPSWLQJWRFRUUHFWO\PRGHOFHQWULIXJDO
VWLIIHQLQJRIURWDWLQJV\VWHPV<RXFDQRYHUFRPHWKHVHOLPLWDWLRQV
E\GLYLGLQJDIOH[LEOHERG\LQWRPXOWLSOHIOH[LEOHERGLHVDQG
DVVHPEOLQJWKHPLQ$'$06&DU
$OVRQRWHWKDWIOH[LEOHERGLHVDUHQRWSDUDPHWULF,I\RXZDQWWR
VXEVWLWXWHDQHZIOH[LEOHERG\LQ\RXUV\VWHP\RXPXVWFUHDWHD
QHZIOH[LEOHERG\
Using Flexible Bodies 161

*HWWLQJ)OH[LEOH%RGLHV
7ZRZD\VWRFUHDWHIOH[LEOHERGLHV
■ Importing modal neutral files (.mnf) - To create a new flexible body, go to Build ->
Part -> Flexible Body. ADAMS/Car imports the .mnf file and creates the flexible
body.
■ Creating .mnf files with Autoflex - With the additional module (it requires a separate
license), a flexible body can be generated without access to an external FEA package.
Specify the cross section, center line, and attachment points. This tool generates the
flexible body, just like importing an .mnf file.
)OH[LEOHERGLHVUHTXLUHDVSHFLDOSDUW
■ Creating interface parts - At every location on the flexible body where you intend to
attach a joint or a force, you should place an interface part. Place the interface parts
on nodes of the flexible body. This works as a dummy part that is attached to the
flexible body with a fixed joint. You can apply other elements to these interface parts.
Note: When picking nodes for the interface parts, the interface part dialog box needs
left and right nodes and then creates left and right interface parts.
They place an interface part in Step 12, on page 166.

:RUNVKRS³)OH[7XWRULDO
XI XII I
X II
IX
VIII IV
III
This workshop takes about one and a half hours to complete.
VII VI V
In this workshop, you swap a rigid lower control arm with a flexible control arm.
First, in ADAMS/Car Template Builder, open the double-wishbone suspension template.
&UHDWLQJDIOH[LEOHERG\
Create the flexible body on top of the rigid part, and swap the connections from the rigid to the
flexible body. When nothing is referenced by the rigid part, you can delete it.
7RFUHDWHWKHIOH[LEOHORZHUFRQWURODUP
1 From the Build menu, point to Parts, point to Flexible Body, and then select New.
2 Enter the following user-entered location for the left control arm: -266.0, 0.0, -30.0 mm.
The symmetry rule automatically puts the right control arm at the same location, but with
the opposite y value. The flexible body uses the local part reference frame (LPRF) that was
set in the FEA program to be the origin.
3 Point to the files LCA_left_shl.mnf, and LCA_right_shl.mnf, located in the shared database.
4 Select the color you want on the graphics for the flexible body. The graphics for the
flexible body reside in the .mnf file. To get a nice flexible body, you may need a very
large .mnf file.
5 Select OK.
ADAMS/Car displays the flexible bodies on top of the rigid bodies when in wireframe
mode.
■
&UHDWLQJLQWHUIDFHSDUWV
Now you create interface parts at every location where you have a connection to another
element in the model. In this case, you have two connection points to the chassis. If you just
want one revolute joint to the chassis, you only need one interface part for the revolute joint, but
if you want a bushing for the front and rear attachment points, you need two interface parts, one
at each bushing. You also need one attachment to the damper, and finally, you need one
attachment for the upright. You then substitute the corresponding interface parts that you create
for the rigid parts in the attachments.
7RFUHDWHLQWHUIDFHSDUWV
1 From the Build menu, point to Parts, point to Flexible Body, point to Interface Part, and then
select New.
Supply the following data:
■ The name of the interface part.
■ If it’s a left, right, or single.
■ What flexible body it’s attaching to.
■ Left and right node ID, or the single node ID.
Use the Pick command to do this; use the mouse to highlight nodes on your flexible
body.
■ Geometry radius. An interface part is represented by a sphere, so this radius is the
radius of the sphere.
■ Color of the sphere.
2 Repeat this for each of the attachment points.
■
$OWHULQJFRQQHFWLRQV
You now change the connections from the rigid body to the interface part by modifying each
attachment.
7RPRYHWKHFRQQHFWLRQV
1 Right-click on the front bushing that connects the lower control arm to the subframe and
select Modify.
2 In the I Part text box, replace the part gel_lower_control_arm with the name for your left
interface part.
3 Select OK.
4 Make sure you modify all attachments at that location. For example, if you have a joint
that is only active in kinematic mode, you also need to modify the bushing at the same
location. The graphical topology might help you find all of the connections.
5 To get to the graphical topology, go to Tools, point to Database Navigator, and then select
Graphical Topology.
6 When you’re done, delete the rigid lower control arm. If you forgot any attachments,
ADAMS/Car will issue a warning and prompt you to select one of the following:
■ Continue - ADAMS/Car deletes the entity you selected anyway, and any other objects
dependent on your selected object.
■ Highlight & List Dependents - ADAMS/Car lists all dependencies that still exist in the
model. These dependencies will also be highlighted.
■ Cancel - ADAMS/Car takes no action. If you select Cancel, you must delete the
dependencies manually before ADAMS/Car can delete this entity.
Note: Only one revolute joint exists in the model for the rigid body. The flex body requires two at the ends
of the control arm.
7 Edit the switch part.
This model contains a switch part that is used for an anti-roll bar (ARB). Therefore, you
must replace the gel_lower_control_arm part with the appropriate interface part in the
switch part. Because the other part in the switch part list is the upright, you’ll use the
interface part used to connect the upright, as well as the same location.
8 The suspension parameter array also contains the part: gel_lower_control_arm which will
be replaced by the appropriate interface part. However, the suspension parameter array
can only be set for one configuration, so you have to delete it first and then set it with the
new interface part.
Make the following changes to the suspension parameters array (geometric):
■ I Part: interface part
■ J Part: gel_upper_control_arm
■ I Coordinate Reference: hpl_lca_outer
■ J Coordinate Reference: hpl_uca_outer

9 Delete the part gel_lower_control_arm.
10 Switch to Standard Interface and create a new subsystem and suspension assembly.
11 Run a suspension analysis.

12 If time allows, perform the Tutorial for ADAMS/Flexible Body Generator, on page 93 in
the guide, Getting Started Using ADAMS/Car.

5(48(676
This module introduces requests, which are the primary method of output in
ADAMS/Car.
:KDW·VLQWKLVPRGXOH
■ Creating New Requests, 168
■ Types of Requests, 169
167
&UHDWLQJ1HZ5HTXHVWV
7RFUHDWHQHZUHTXHVWVLQ7HPSODWH%XLOGHUJRWR%XLOG!
5HTXHVWV!1HZ<RXFDQRQO\FUHDWHUHTXHVWVLQ7HPSODWH
%XLOGHU
The results set names appears in the

Request list in ADAMS/PostProcessor
The other attributes appear

in the Component list
168 Requests
Building requests must be done in template builder

7\SHVRI5HTXHVWV
7\SHVRIUHTXHVWV
■ User subroutine
■ Type and markers based
■ Function expression
1RWHWKDWWKHQDPHILOHQDPDFWVDVNH\E\PDWFKLQJ,'·VZLWK

UHTXHVWQDPHV<RXFDQHGLWWKHQDPILOHWRFKDQJHWKHQDPHRI
FHUWDLQUHTXHVWVDQGWKHZD\WKH\DSSHDULQ
$'$063RVW3URFHVVRU
)RUGHWDLOVVHHWKH5(48(67VWDWHPHQWLQWKHJXLGH
8VLQJ$'$066ROYHU
Requests 169
1RWHV
170 Requests
7,5(6
This module provides an overview of the calculation of tire forces and the
available models.
:KDW·VLQWKLVPRGXOH
■ Tire Overview, 172
■ ADAMS/Tire Modules, 173
■ Tire Models, 175
■ Tire Analyses, 176
■ Workshop 12—Building a Wheel Template, 177
171
7LUH2YHUYLHZ
$'$067LUHFDOFXODWHVWKHIRUFHVDQGPRPHQWVWKDWWLUHVH[HUW
RQWKHYHKLFOHDVDUHVXOWRIWKHLQWHUDFWLRQEHWZHHQWKHWLUHVDQG
URDGVXUIDFH
Process flow
Key:
Data input
ADAMS/Solver ADAMS/Tire
.adm .tir .rdf

GFORCE, [MODEL] METHOD=‘2D’
DIFF, PROPERTY_FILE_FORMAT=‘PAC89’ [ SINUSOIDAL ]
ARRAY, Amplitude = 20mm
UC1 = 1.0
STRING
UC2 = 2.0
UC3 = …
172 Tires
$'$067LUH0RGXOHV
7RSHUIRUPWLUHFDOFXODWLRQV\RXQHHGRQHRUPRUHRIWKH
IROORZLQJPRGXOHV
■ ADAMS/Tire Handling module - Incorporates the following tire models for use in
vehicle dynamic studies:
◆ Delft-Tyre model from the Netherlands Organization for Applied Scientific
Research (TNO) (DTM 95, DTM 96, our most advanced models)
◆ Pacejka ’89 and Pacejka ’94 models
◆ Fiala tire model (least advanced)
ADAMS/Tire Handling uses a point-follower method to calculate tire normal force and
is limited to two-dimensional roads.
■ ADAMS/Tire Durability module - Uses a three-dimensional equivalent volume
method to calculate tire normal force on three-dimensional roads for use in predicting
vehicle loads for durability studies. When you purchase ADAMS/Tire Durability
separately, you can use only the Fiala model to calculate tire handling forces and
moments.
■ ADAMS/Tire FTire module - The FTire module is the latest addition to
ADAMS/ Tire. A new tire model for durability and ride and handling applications,
FTire:
◆ Offers an effective compromise between model fidelity and detail, and
computational speed.
◆ Provides valid results up to 120 Hz in the frequency domain.
◆ Lets you easily derive model parameters from tire measurement data.
◆ Provides valid results for short obstacles with wavelengths down to half the size
of the tire-road contact patch.
Tires 173
$'$067LUH0RGXOHV
◆ Provides highly accurate solutions when passing through potholes and over cleats.
■ FTire is a 2½D nonlinear tire model. The tire belt is represented as a ring of small
elements. Typically there are 50 to 100 elements. The elements are connected to each
other through stiff springs and dampers. This ring of elements can be bent in any
direction relative to the wheel rim.
■ FTire conforms to the TYDEX Standard Tire Interface (STI).
:KHQ\RXSXUFKDVH$'$067LUH'XUDELOLW\ZLWK$'$067LUH
+DQGOLQJ\RXFDQXVHWKH'HOIW7\UH3DFHMND·3DFHMND·
RU)LDODPRGHOVWRFDOFXODWHWKHWLUHKDQGOLQJIRUFHVDQGPRPHQWV
ODWHUDOIRUFHORQJLWXGLQDOIRUFHDOLJQLQJWRUTXHDQGVRRQ
174 Tires
7LUH0RGHOV
7LUHGDWD
Tire data is essential to obtain accurate tire forces during a simulation. If you use the Fiala
model, you can generate the tire property file by hand. If you use a different tire model, you must
use a fitting routine to obtain the coefficients for the tire property file. This is usually done by
the testing facility that tests the physical tire. Unless the tire you want to use is tested already, a
test must be performed to obtain the tire data necessary for a tire property file.
Table 2. ADAMS/Tire Modules and Features
ADAMS/Tire Modules:
ADAMS/Tire Features:
Handling and
Handling Durability
Durability
Handling Force Models
Fiala ■ ■ ■
Pacejka ‘89 ■ ■
Pacejka ‘94 ■ ■
Delft MF-Tyre (Pacejka ‘96) ■ ■
Normal Force Models
Linear spring force ■ ■ ■
Road Contact Models
2D point follower (flat surface) ■ ■ ■
3D equivalent volume (discrete surface) ■ ■
Miscellaneous
Uses ADAMS/Solver GFORCE interface ■ ■ ■
Meets STI v. 1.4 architecture standards ■ ■ ■
Supports user-written STI tire models ■ ■ ■
Tires 175
Improve this workshop for the future: Run a simulation with a simple 2D flat road simulation and plot a result. Run
the same simulation with a Pacejka tire model and plot the same result. Compare the ease of use and the accuracy.
Run a 3D road to see how to change from Handling to Durability. How about using a flat sine road and a 3D sine road
and compare tire forces. Here, the point is to see why and when to use 2D vs. 3D roads/tires.
7LUH$QDO\VHV
$'$067LUHUHDGVWKHPRGHOEORFN>02'(/@SRUWLRQRIWKHWLUH
WLUDQGURDGGDWDILOHUGIWRGHWHUPLQHZKLFKWLUHPRGHODQG
URDGFRQWDFWPRGHOWRXVHZKHQFDOFXODWLQJWKHWLUHIRUFHVDQG
PRPHQWV
'XULQJDQDQDO\VLV$'$067LUHFDOOVWKHWLUHPRGHOWRFDOFXODWH
WKHWLUHIRUFHVDQGPRPHQWV,QWKLVSURFHVVWKHWLUHPRGHOFDOOV
WKHURDGPRGHOWRFDOFXODWHWKHWLUHFRQWDFWSRLQWDQGORFDOURDG
QRUPDODQGXVHVWKHVHYDOXHVZLWKWKHWLUHYHORFLW\DQG
RULHQWDWLRQWRFDOFXODWHWKHIRUFHVDQGPRPHQWV
$'$067LUHWKHQUHWXUQVWKHIRUFHVDQGPRPHQWVWR
$'$066ROYHUZKLFKDSSOLHVWKHIRUFHVDQGPRPHQWVWRWKH
ZKHHOSDUW
176 Tires
:RUNVKRS³%XLOGLQJD:KHHO7HPSODWH
XI XII I
X II
IX
VIII IV
III
VII VI V
In this workshop, you create a wheel template that sets up the interface to your tire model.
&UHDWLQJDWHPSODWH
7RFUHDWHWKHZKHHOWHPSODWH
1 From the File menu, select New.

2 Name the template anything you want.
3 Set Major Role to wheel.
4 Select OK.
&UHDWLQJFRPPXQLFDWRUV
7RFUHDWHFRPPXQLFDWRUV
1 Create two input communicators for toe and camber angles. They should be of type
parameter_real and be named toe_angle and camber_angle.
2 Create an input location communicator that receives the wheel center location. This
communicator positions the wheel at the location dictated by the suspension. The
corresponding output communicator, wheel_center, resides in the MacPherson
suspension you created in Workshop 9—Template-Builder Tutorial, on page 144.
Tires 177
&UHDWLQJFRQVWUXFWLRQIUDPHVDQGPRXQWSDUWV
7RFUHDWHWKHFRQVWUXFWLRQIUDPHDQGPRXQWSDUW
1 Create a construction frame to be used as the spin axis. Locate this construction frame on
an input communicator, which should match the output communicator from the
suspension. This construction frame should also be dependent on two communicators for
toe and camber angles. (See the different orientation dependency options.) Verify that the
spin axis is defined right, such that the z-axis points out from the vehicle (this should be
done automatically for you).
2 Create the mount part that will attach to the suspension.
&UHDWLQJWKHZKHHOSDUW
7RFUHDWHWKHZKHHOSDUW
1 From the Build menu, point to Wheel, and then select New.
2 Create the wheel part with the following data:
■ Mass: 20.0 kg
■ Ixx Iyy: 5E4 kg-mm**2
■ Izz: 1E4 kg-mm**2
■ Property File: mdi_tire01.tir
■ Contact Type: handling
■ Coord ref loc: cfl_spin_axis
■ Location: 0, 0, 0 mm
■ Coord ref ori: cfl_spin_axis
■ Orientation: 0, 0, 0 deg
Note: ADAMS/Car automatically creates a pair and sets the tire geometry in the
property file.
178 Tires
9LHZLQJWLUHJHRPHWU\
7RYLHZWKHWLUHJHRPHWU\
1 To view the tire property file, select the View File tool .
2 Search for the data block named DIMENSIONS.
&RQQHFWLQJPRXQWDQGZKHHOSDUWV
7RFRQQHFWWKHPRXQWSDUWWRWKHZKHHOSDUW
■ Create a fixed joint between the tire and the mount part located at the cfl_spin_axis.
7HVWLQJFRPPXQLFDWRUV
7RWHVWFRPPXQLFDWRUV
■ Test the communicators and select this tire template and the suspension template you
intend to use (make sure that you have these templates open in your session).
Note that this template has been developed to be used with the MacPherson suspension
template you created in Workshop 9—Template-Builder Tutorial, on page 144. If you
use this template with another suspension, there might be other communicators you
must match.
Tires 179
To check communicators:
Create a generic assembly: Tools -> Command Navigator -> acar -> files -> assembly -> new -> generic. Set:
■ assembly class - generic
■ subsystems - wheel and macpherson
180 Tires
(;3/25,1*7(03/$7(6
Before you build or modify templates, it is important that you know how
templates are built and organized. This includes not only how parts are
connected with joints, motions, and forces, but also how the templates
exchange information with communicators. This chapter introduces methods
of exploring templates to enable you to modify existing templates for you own
use and create new templates which are compatible with others.
:KDW·VLQWKLVPRGXOH
■ Investigating Templates, 182
■ Understanding Templates, 183
■ About the Database Navigator, 184
■ Workshop 13—Exploring and Completing Templates, 186
181
,QYHVWLJDWLQJ7HPSODWHV
,QYHVWLJDWLQJWHPSODWHVSULPDULO\LQYROYHV
■ Getting information about the template components. Once you understand what
components make up a template and how they relate to each other, you can modify
the components to make your template unique.
■ Getting information about communicators. Understanding how the template works
internally is not enough: you must also understand how it communicates with other
templates and test rigs. This understanding will help you connect your templates
correctly.
182 Exploring Templates

8QGHUVWDQGLQJ7HPSODWHV
*XLGHOLQHVWRKHOS\RXXQGHUVWDQGKRZDWHPSODWHLVEXLOW
1 Right-click the component for which you want to obtain information, point to the
component name, and then select Modify.
The Modify Component dialog box appears. Note the information displayed in the dialog
box, such as attachment and positioning information.
2 You can use the Template Builder’s Build menu to list all components by type, as well as
their specifications, such as mass, location, orientation, and so on. When requesting
information for most components, your template-based product displays the Entity
Information dialog box. From this dialog box you can select the type of component on
which you request information.
3 When requesting information for communicators, your template-based product displays
the Communicators Info dialog box. Use the Communicator Info dialog box to list the
communicators in different templates and test rigs.
4 Use the Database Navigator to explore your template.
Exploring Templates 183

$ERXWWKH'DWDEDVH1DYLJDWRU
'LVSOD\LQJWKH'DWDEDVH1DYLJDWRU
You can display the Database Navigator by doing any of the following:
■ From the Tools menu, select Database Navigator.
■ From the Edit menu, execute an editing command, such as Modify, when no object is
currently selected.
■ From the Edit pop-up menu, request to view information about an object using the
Info command.
■ Using the Browse command, browse for the name of an object to enter in a dialog
box.
The Database Navigator has several modes in which you can display object information. You
can set it to just let you browse for objects or you can set it to view information about the objects,
such as view how an object relates to other objects, and view dependencies. The Database
Navigator only displays the types of objects that are appropriate for the command you are
executing. For example, if you are renaming a model, it only displays models in your database.
On the other hand, if you are searching for any modeling object in the database, it displays all
types of modeling objects. You can also set a filter for the types of objects that the Database
Navigator displays.
The Database Navigator shows objects in their database hierarchy.

$ERXWWKH'DWDEDVH1DYLJDWRU
9LHZLQJ0RGHO7RSRORJ\
You can use the Database Navigator to display information about the parts in your model. You
can:
■ View the topology of a model - When you request information about a model’s
topology, ADAMS/View determines what constraints are owned by the model and
what parts the constraints connect. There are two different ways in which you can
show the part connection information: by part and by connection. For more
information on the two ways, see the guide, Learning ADAMS/View Basics.
■ Graphically view the topology - In graphical topology, the Database Navigator
displays a representation of the selected part and shows its connections to other parts.
The connections represent the joints or forces between the parts. Each time you select
a different part in the tree list of the Database Navigator, the graphical display
changes to show the selected part at the center of the display.

:RUNVKRS³([SORULQJDQG&RPSOHWLQJ7HPSODWHV
XI XII I
X II
IX
VIII IV
III
VII VI V
This workshop tests some of the topics about template building, including defining
communicators and joints, and investigating your template with the database navigator.
We recommend that whenever possible, you modify existing templates, rather than create new
ones. To be able to modify existing templates and to customize them for your use, you must be
able to understand them very well.
'HILQLQJ\RXUWHPSODWH
7RGHILQH\RXUWHPSODWH
1 Copy _steer_training.tpl to the template.tbl directory of your choice (for example, place it in
private.cdb/templates.tbl).
2 Open _steer_training.tpl in template-builder mode.
A rack and pinion steering template appears. The template is incomplete: it needs joints to
be defined, as well as communicators and mount parts. Use the Database Navigator to
investigate the template by looking at the parts and icons, and try to determine what yet
needs to be defined for this template.
3 Make the necessary changes to define your template properly. To initiate exploration of
your model and challenge yourself to determine what entities still need to be defined, first
see General steps to define your template on page 187. If you have trouble or would like
to check your work, see Detailed steps to define your template on page 187 to determine
what changes should be made.
If you are not able to get to this workshop, or the students have trouble finishing, then the
steer_final.tpl template should be made available for the Workshop 15—Full-Vehicle As-
sembly on page 205.
*HQHUDOVWHSVWRGHILQH\RXUWHPSODWH
1 Constrain the motion of the steering columns to each other.

2 Constrain the motion of the steering wheel to the steering column (Hint: Use a gear to do
this. To learn more about gears, press F1 when the cursor is in the window, and then click
anywhere on the dialog box.)
3 Constrain the motion of the steering shaft to the rack housing.
4 Constrain the motion of the steering shaft to the rack (Hint: Use a gear to do this).
5 Constrain the motion of the rack to the rack housing.
6 Create a mount part for the rack housing.
7 Make sure the rack will be able to connect to the MacPherson template you created
earlier. If necessary, create any mount parts or communicators.
8 Check that the steering column housing will mount properly. If necessary, create any
mount parts or communicators.
'HWDLOHGVWHSVWRGHILQH\RXUWHPSODWH
1 Create two hooke (universal) joints: one between the steering column and the intermediate
shaft, and one between the intermediate shaft and the steering shaft.
2 Create a reduction gear to constrain the revolute joint for the steering wheel to the
cylindrical joint of the steering column.
3 Create a revolute joint between the end of the steering shaft and the rack housing.
4 Create a reduction gear that constrains the rotational motion of the steering shaft to the
translational motion of the rack.
5 Create a translational joint between the rack and the rack housing.
6 Create a mount part that will attach to the body.

7 Open the MacPherson template created earlier, and check the mount parts and mount
communicators at the tierods. The mount input communicator tierod_to_steering in the
MacPherson template requires that a mount output communicator named
tierod_to_steering, which outputs the rack part, be defined in the template steer_training.
8 The steering column is already attached to a mount part named
steering_column_to_body. Edit a body template in Workshop 15—Full-Vehicle Assembly
on page 205 to make sure these communicators match properly.
Your template should look like steer_final.tpl, which your instructor will have, and will be
used in the final full-vehicle workshop.
9 If time allows, add location communicators to your template. See knowledge base
article 9184, Position one template (part) relative to another template.

7LSVIRUH[SORULQJWHPSODWHV
Note: Because you perform many steps in this section in the Database Navigator, make sure
you have the Database Navigator displayed (Tools -> Database Navigator).
,QYHVWLJDWLQJPRGHOWRSRORJ\
7ROLVWSDUWVDQGFRQQHFWLRQV
■ To see parts and connections, set the option menu at the bottom of the Database
Navigator to Bodies, Constraints, or Forces.
■ Set the option menu at the top to the type of information you want to see.
7RYLHZWKHWRSRORJ\RISDUWV
1 From the option menu at the top of the dialog box, select Topology by Parts or Topology by
Connections.
2 From the tree list or view window, select an object.
The topology of the object appears in the text box to the right.
7RJUDSKLFDOO\YLHZWKHWRSRORJ\RISDUWV
1 From the option menu at the top of the dialog box, select Graphical Topology.
A graphical display of the object’s topology appears in the text box to the right.

9LHZLQJWKHDVVRFLDWLYLW\RIREMHFWV
You can use the Database Navigator to display the objects that a selected object uses. For
example, you can select a joint in the tree list to show the I and J markers that the joint uses. You
can also select to view the objects that use the selected object.
7RYLHZWKHDVVRFLDWLYLW\RIREMHFWV
1 From the option menu at the top of the dialog box, select Associativity.
2 Set the associativity:
◆ To show the objects that the selected object uses, select Uses.
◆ To show the objects that use the selected object, select Is Used By.
The objects associated with the selected object appear in the text box to the right.
7RVHWXSDXWRPDWLFQDYLJDWLRQRIWKHREMHFWV
■ To see what objects are dependent on a certain object, select Auto Navigate.
7RVDYHWKHFXUUHQWDVVRFLDWLYLW\LQIRUPDWLRQWRDILOH
■ Select Save to File.

9LHZLQJREMHFWLQIRUPDWLRQWKURXJKWKH'DWDEDVH1DYLJDWRU
You can use the Database Navigator just as you would the Information window to display
information about the selected object.
7RGLVSOD\REMHFWLQIRUPDWLRQ
1 Set the option menu at the top of the Database Navigator to Information.
The information about the object appears in the text box to the right.
7RVDYHWKHLQIRUPDWLRQWRDILOH
■ Select Save to File.
7ROLVWWKHW\SHRIFRPPXQLFDWRUV
1 From the Build menu, point to Communicator, and then select Info.
2 Set Type to Input.
3 Set Entity to All.
4 Select OK.
7RVHHZKDWLVGHSHQGHQWRQDFRPPXQLFDWRU
1 From the Tools menu, select Database Navigator.

2 In the Filter text box, enter ci*.
3 Set the option menu at the top of the dialog box to Associativity.
4 To get the relevant information, select Uses and Is Used By.

/RFDWLRQDQGRULHQWDWLRQSDUDPHWULFV
To find out how the parametric dependencies are set up, you can regard two entities as starting
points: hardpoints and input communicators.
Hardpoints have no dependencies. Therefore, you can regard them as starting points for
parametrics. You can parameterize construction frames and other components to hardpoints.
You use parameter variables to parameterize the location and orientation of construction
frames. For more information, see the guide, Learning ADAMS/View Basics.
7RVHHZKDWLVGHSHQGHQWRQDKDUGSRLQW
1 In the Filter text box, enter hp*.

2 Select a hardpoint.
3 Select Apply.
The Information window appears, displaying hardpoint location values.
4 In the Database Navigator, set the option menu at the top of the dialog box to Associativity
to see a list of dependents. Also, you can select Highlight to see the hardpoint position.
5 You can right-click each construction frame and select Info or Modify. The information
displayed includes information for the parametric locations in the template. For
construction frames, you look both at the expression to see how the construction frame is
parametric to other construction frames and hardpoints, and what is dependent on the
construction frame.
7RVHHZKDWLVGHSHQGHQWRQFRQVWUXFWLRQIUDPHV
1 In the Filter text box, enter cf*.

2 Set the option menu at the top of the dialog box to Associativity.
7ROLVWGHSHQGHQFLHVIRUSDUDPHWHUYDULDEOHV
1 In the Filter text box, enter pv*.

2 To see the parameter variables, set the option menu at the top of the dialog box to
Information.
3 To see a list of dependents, set the option menu at the top of the dialog box to
Associativity.

$'',7,21$/$33/,&$7,216
Other applications offered by Mechanical Dynamics are compatible with

ADAMS/Car to provide additional analysis capabilities. The following
describes how these applications fit in and affect the vehicle simulations in
ADAMS/Car. For more information, refer to the documentation for each
application.
:KDW·VLQWKLVPRGXOH
■ Conceptual Suspension Module and Driveline, 194
■ Linear and Controls, 196
■ Insight and Hydraulics, 197
■ Vibration and Durability, 198
193
&RQFHSWXDO6XVSHQVLRQ0RGXOHDQG'ULYHOLQH
$'$06&RQFHSWXDO6XVSHQVLRQ0RGXOH&60
CSM is a method of implementing functional suspension behavior in ADAMS/Car through
predefined trajectories followed by the wheel carrier during suspension travel (vertical and
steer) and external forces. You benefit from using CSM because it concentrates only on final
effects (wheel carrier position and orientation) of the suspension layout, regardless of the way
in which they have been mechanically obtained. It allows you to have a reduced 14 degree-of-
freedom vehicle model that can be quickly assembled, and includes all the primary nonlinear
elasto-kinematic effects of a multibody suspension model. In addition, conceptual suspension
modeling allows you to share suspension characteristics files (.scf) with others, such as
suppliers, without worrying about confidentiality.
$'$06'ULYHOLQH
ADAMS/Driveline is a new ADAMS module that you can use to quickly build and test
functional virtual prototypes of complete drivelines or driveline components.
ADAMS/Driveline is implemented as an add-on module to ADAMS/Car, has the same look and
feel as ADAMS/Car, and it allows you to perform the same kinds of analyses.
You can use the virtual prototypes created with ADAMS/Driveline for performance analyses,
component fatigue life estimation, and NVH characteristics. You can also import those virtual
prototypes into ADAMS/Car to study full-vehicle dynamics with a driveline included.
Similar to other automotive applications, such as ADAMS/Car and ADAMS/Engine, ADAMS/
Driveline has two operational modes:
■ Standard Interface – Allows designers and analysts to build up driveline designs from
a database of available templates, fill in the design-specific numerical values, and run
tests.
■ Template Builder – Allows experienced users to modify templates, or create new
ones, to accommodate specific corporate needs.
194 Additional Applications

&RQFHSWXDO6XVSHQVLRQ0RGXOHDQG'ULYHOLQH
Application areas for ADAMS/Driveline include:

■ Conceptual tool for driveline layout
■ Full-vehicle handling analysis in front-wheel drive, rear-wheel drive, and all-wheel
drive configurations
■ Torque transfer and torque distribution studies
■ Vibration analysis at the system level and the component level
■ Component fatigue life prediction
■ Control system design and verification
■ Driveline packaging studies
■ Studies of secondary motion at high operating speeds
■ Studies of the influence of flexible components
ADAMS/Driveline template libraries provide a wide range of components, including clutches,
flexible shafts, synchronized gear pairs, bearings, viscous couplings, differentials, backlash, and
gears.
ADAMS/Driveline catalog of tests and analyses includes split m, uphill and downhill driving,
impulse, step, and ramp torques, tip-in tip-out, gear shift, rock cycle, and clutch misuse.
Additional Applications 195

/LQHDUDQG&RQWUROV
$'$06/LQHDU
ADAMS/Linear’s key function is to linearize nonlinear ADAMS equations. The resulting set of
equations enables you to calculate the natural frequencies (eigenvalues) and mode shapes
(eigenvectors) associated with your mechanical design. ADAMS/Linear also helps bridge the
gap between control systems design and ADAMS mechanical simulation capabilities by
allowing you to generate state space matrices (the plant model), which relate the measured
outputs of the system to the controlled input.
$'$06&RQWUROV
Control algorithms can now be used in the vehicle model. For example, including automatic
controls in the suspension and handling design of a vehicle makes it possible to avoid an
obstacle on wet pavements. The control system designer can tune the controller for the
particular vehicle design on the computer, with confidence that the ADAMS model provides
accurate results. ADAMS/Controls allows the designer to see the effect of each change on the
computer, even comparing control strategies that would be too expensive or time-consuming to
test on a physical prototype. This interface allows you to model control algorithms in Matlab,
MatrixX, or Easy5.

,QVLJKWDQG+\GUDXOLFV
$'$06,QVLJKW
When using ADAMS/Insight together with ADAMS/Car, you can plan and run a series of
experiments for measuring the performance of your suspension or vehicle. ADAMS/Insight will
help you to understand your designs better by distinguishing between key and insignificant
design parameters. In addition, you will be able to see the impact of design decisions on a broad
range of customer requirements, as well as improving design robustness by considering
manufacturing variations up front. To learn how to use ADAMS/Car with ADAMS/Insight, see
the guide, Using ADAMS/Insight with ADAMS/Car.
$'$06+\GUDXOLFV
This module allows you to smoothly integrate system-level motion simulation and hydraulic
system design. For example, auto companies need to know the effects of hydraulic system
failures on vehicle performance and safety – especially since high ratings in these areas are key
competitive advantages. Example: How is a sudden change in power steering authority sensed
by the driver while negotiating a curve at top speed? Answering this question requires failure
analyses using simulations that include not just mechanical systems, but also hydraulic systems
and other control system designs.
After this module, have students go through the tutorial, Using ADAMS/Insight with ADAMS/Car.
9LEUDWLRQDQG'XUDELOLW\
$'$069LEUDWLRQ1HZLQ
ADAMS/Vibration is a new plug-in module, which allows you to analyze system modes
including attachment characteristics, include effects of hydraulics and controls on system
behavior, and analyze vibratory behavior in different configurations. Moreover, it allows you to
study forced vibrations within your ADAMS models using frequency domain analysis. For
example, you can drive an ADAMS model of an automobile over a bumpy road and measure its
response. Both inputs and outputs are described as vibrations in the frequency domain.
$'$06'XUDELOLW\1HZLQ
ADAMS/Durability allows you to perform fatigue analyses using a virtual test rig, by providing
an interface to MTS and nCode products. The virtual test rig loads will be based on empirical
data to provide better virtual test results and to allow better corroboration when the actual testing
is performed.

:RUNVKRS³8VLQJ$'$06/LQHDUZLWK$'$06&DU
XI XII I
X II
IX
VIII IV
III
VII VI V
In this workshop, you use ADAMS/Linear to analyze the mode shapes of a full-vehicle about
an operating point.
ADAMS/Linear will linearize your vehicle model about an operating point, and return the
eigenvalues and eigenvectors to help validate your model or investigate excited frequencies in
your vehicle. For example, a sweep of animations of the modes will help indicate that parts are
connected properly. To get the eigenvalues and eigenvectors, use an .acf file in ADAMS/Car to
submit the LINEAR commands. ADAMS/View can perform this analysis from the toolbar,
because it has an interface for this function. Because ADAMS/Car doesn’t have this interface,
the most straightforward method is to use an .acf file with the external ADAMS/Solver. The first
part of the workshop will generate this .acf file.

*HQHUDWLQJWKHDFIILOH
7RJHQHUDWHWKHDFIILOH
1 In ADAMS/Car, open MDI_Demo_Vehicle.asy.

2 From the Simulate menu, point to Full-Vehicle Analysis, point to Straight-Line Behavior, and
then select Acceleration.
3 Fill in the acceleration simulation dialog box with the following parameters:
◆ Output Prefix: linear_example
◆ End Time: 5
◆ Number Of Steps: 100
◆ Mode of Simulation: files_only

Specify files_only, because you do not need to run the simulation yet. This step is used
to simply set up the vehicle model and create the .adm, .acf, and .dcf files. Here,
ADAMS/Car will read in the property files and store the relevant data in the .adm file,
because if you submit an analysis through the interface in ADAMS/Car, the property
files are loaded for you automatically. If you want to load the property files manually,
you can do this with View Commands (acar analysis read property_files).
◆ Road Data File: <shared>\roads.tbl\mdi_2d_flat.rdf
◆ Initial Velocity: 10 km/hr
◆ Start Time: 1
◆ Open-Loop Throttle
◆ Throttle Ramp: 10
◆ Gear Position: 2
◆ Steering Input: locked

4 Select OK.
ADAMS/Car displays the following message:
Reading in property files...
Reading of property files completed.
Setting up the vehicle assembly for Driving Machine maneuver...
Setup of vehicle assembly completed.
Writing assembly information to ADAMS/Solver dataset...
ADAMS/Solver files written successfully.
ADAMS/Car writes the files to your current working directory. To check where
ADAMS/Car saved the files, go to File --> Select Directory)
To set up your .acf file, you simply insert the LINEAR solver command after your analysis,
specifying whatever options you want (see the ADAMS/Solver documentation for
LINEAR). ADAMS will linearize about the operating point (the states) that it sees at the end
of the analysis. For example, here is the .acf file you just created:
file/model=linear_example_accel
output/nosep
control/function=user(906,2,29,33,22,3,23,1)
!
stop
5 Edit the linear_example_accel.acf file to include an eigensolution.
Your .acf file should look like:
file/model=linear_example_accel
output/nosep
control/function=user(906,2,29,33,22,3,23,1)
linear/eigensol
!
STOP
!
You are almost ready to run the linear analysis. First, you must make sure you save the
proper output file. To save your mode shape results, you have to turn on the results file
(.res), which is usually turned off for ADAMS/Car. To produce the results file, you can do
this in the Output Files dialog box by selecting Results File Contents (that is, Settings -->
Solver --> Output Files). In the window that appears, make sure that the Linear box is
checked.
Note: You must do this before you export the .adm file.
Alternatively, you can simply put the RESULTS/ statement at the end of your .adm file.

6 Edit the .adm file by putting the RESULTS/ statement at the end of the .adm file.
!----------------------------- ANALYSIS SETTINGS -------------------------------
!
INTEGRATOR/
, GSTIFF
, ERROR = 0.01
!
OUTPUT/
, REQSAVE
, GRSAVE
, NOPRINT
!
RESULTS/
END
5XQQLQJWKHPRGHOZLWKWKHH[WHUQDOVROYHU
7RUXQWKHPRGHOZLWKWKHH[WHUQDOVROYHU
1 Enter your alias to start ADAMS at your command line (for example, adams110, adams11).
Note: Aliases can vary. The alias simply points to the mdi.bat file, so if you find no
alias, run the mdi.bat file found in $install_dir/common/mdi.bat.
2 To see the ADAMS/Car options, enter acar.
3 To run the ADAMS/Car solver, enter ru-solver.
4 To enter your solver commands, enter linear_example_accel.acf.
Note: Make sure that this file and all others are in the directory in which you are running
ADAMS.
The simulation should start. It will produce output files, including the results file which has
the eigensolution output in it. Alternatively, you can submit the simulation directly by
entering:
◆ UNIX: adams11 -c acar ru-solver linear_example_accel.acf exit
◆ NT: adams11 acar ru-solver linear_example_accel.acf exit

5HYLHZLQJPRGHVKDSHVLQ$'$063RVW3URFHVVRU
7RUHYLHZPRGHVKDSHV
1 Open ADAMS/Postprocessor.
2 From the File menu, point to Import, and then select Analysis Files.
3 In the File Name text box, enter one of the three files, linear_example_accel.gra,
linear_example_accel.res, or linear_example_accel.req. Entering one will pick up all three,
based on the root name.
You should see your vehicle model loaded into ADAMS/PostProcessor.
4 Right-click in the empty space around the model and select Load mode shape animation.
5 When you get a message that the animation will be deleted, select OK.
6 Review the mode shapes by entering the respective mode shape number of interest in the
Mode Number text box. To review the eigenvalues corresponding to the mode shapes,
select Table of Eigenvalues. For example, select mode 160, and use the play tool to animate
the mode shape. You should see in the eigenvalue table that this mode has real and
imaginary values for the eigenvalue:
EIGEN VALUES (Time = 5.0)
FREQUENCY UNITS: (hz)
MODE UNDAMPED NATURAL DAMPING
NUMBER FREQUENCY RATIO REAL IMAGINARY
160 8.826190E+000 6.391413E-001 -5.641182E+000 +/- 6.788129E+000

%DFNJURXQGLQIRUPDWLRQDERXW$'$066ROYHU
)LOHVLQ$'$066ROYHU
■ ADAMS/Solver dataset files (.adm) - Statements define an element of a model such
as a part, constraint, force, and so on.
■ ADAMS/Solver command files (.acf) - Commands define an action that needs to be
taken during a simulation.
6LPXODWLRQVLQVWDQGDORQH$'$066ROYHU
■ Interactive
■ Not scripted - Enter commands one by one
■ Scripted - Use an ADAMS/Solver command file (.acf)
■ Batch - Run multiple jobs in the background using an ADAMS/Solver command file
(acf).
Note: ADAMS/Solver command files must start with the name of the model to be analyzed
and must end with a STOP command.
You can run simulations externally in ADAMS/Solver from within ADAMS/View.

:25.6+23³)8//9(+,&/($66(0%/<
XI XII I
X II
IX
VIII IV
III
This workshop takes about six hours to complete.
VII VI V
This workshop is intended to combine the knowledge you have attained throughout the course
and challenge your knowledge of different topics. The major steps for this workshop are
described, but the exact steps are omitted. If you have questions, please refer to previous
sections or ask the instructor.
At this point, you should have the following templates done:
■ MacPherson suspension (be sure to use the one you created rather than the one in the
shared database, because these have topological differences)
■ Rack and pinion
■ Wheel
You should also have access to _double_wishbone.tpl, which is located in the shared database.
Before you build the assembly, you must create the body. You then attach the front and rear
suspensions, together with the steering system, to the body. You also create appropriate
communicators.
&UHDWLQJWKHERG\
7RFUHDWHWKHERG\
■ In Template Builder, open the template body_training.tpl, which you will get from the
instructor. This template has one rigid body that will act as the chassis.
Workshop 15—Full-Vehicle Assembly 205

:RUNVKRS³)XOO9HKLFOH$VVHPEO\
&UHDWLQJDQGWHVWLQJFRPPXQLFDWRUV
7RFUHDWHDQGWHVWFRPPXQLFDWRUV
1 Make sure the front suspension hooks up to the body. For the MacPherson suspension, you
have the following input communicators:
■ ci[lr]_strut_to_body mount
■ ci[lr]_subframe_to_body mount
■ ci[lr]_tierod_to_steering mount
2 The communicators of interest are strut_to_body and subframe_to_body, which are mount
communicators. You must convey to the front suspension what part the upper strut should
attach to. In this case it’s the body, since that is the only part in the chassis template.
3 Create a new output communicator of type mount, that will match the ci[lr]_strut_to_body,
by either entering the same name or entering the same matching name.
4 Edit the communicator for strut_to_body to have a matching name for subframe_to_body.
5 Test the communicators. Remember that you must have the templates open to be able to
test them.
6 Set up the steering and body template so that they will attach to each other. That is, make
sure that the steering column housing and rack housing are attached to the body. The rack
housing should really be attached to the suspension subframe, but since you don’t have a
subframe for the MacPherson suspension, use the body instead.
7 Display the body template and create an output communicator of type mount single with
the name steering_column_to_body or with a matching name of the corresponding input
communicator in the steering template.
8 Modify the same single output communicator to include the matching name
rackhousing_to_body.
9 Test the communicators.
10 Make sure that the rear suspension hooks up to the body. Look in the ADAMS/Car
documentation: Help -> ADAMS/Car Guides -> Building Templates in ADAMS/Car -> Template
Descriptions -> Double-Wishbone Suspension.
11 Make sure that the strut attaches to the body. This is the same communicator you created
for the front suspension, so you don’t have to create it again. It should pass the
information to both the front and the rear mount parts at the same time.
206 Workshop 15—Full-Vehicle Assembly

12 Open the rear suspension template and go to Build -> Communicator -> Info, select Input and
Many, and then select mount.
13 Select OK.
ADAMS/Car displays a list of all input communicators in the double-wishbone suspension

template.
14 Modify the left/right body communicator in the body to pass information to the
uca_to_body input communicator located in the double-wishbone suspension template.
15 You must modify the left/right body communicator to include tierod_to_steering. If you
want this suspension to work as a steerable suspension, you must make sure it is attached
to the steering system. To keep the wheels going straight, hook up the tierods to the body,
so then the wheels won’t turn.
16 Modify the single body output communicator to include the matching name
subframe_to_body for the double-wishbone suspension.
17 These suspensions also need to pass on the information to what part the wheels should
attach to. You must edit output communicators, in the suspensions, named
suspension_mount to include the matching name wheel_mount.
18 Remember to check the test rig, SDI_testrig. There is one mount input communicator that
expects information from the body.
19 Test all the communicators for all the templates that you will use for the full vehicle.
20 When testing these communicators, you must specify what the templates’ minor roles
will be when you will build the subsystems. Assign minor roles to templates, as shown
next:
Template: Minor role:
.__MDI_SDI_TESTRIG any
._new_tire front
._new_tire rear
._body_training any
._double_wishbone rear
._steer_training front
._macpherson front

21 The following is a listing of the most important mount and location communicators for
this workshop. You may use this as a guide if you are having difficulties or would like to
check your work.
Listing of input communicators in _body_training:
----------------------------------------------------------------
Communicator Name: Class: From Minor Role: Matching Name:
(the body template shouldn’t need input communicators for this exercise)
’_body_training’ contains:
0 input communicators of type ’location’
0 input communicators of type ’mount’
Listing of output communicators in ’_body_training’
----------------------------------------------------------------
Communicator Name: Class: To Minor Role: Matching Name:
(need an output communicator of type mount to output the body part)
symmetry, matching names needed:
lr, strut_to_body (macpherson, dwb)
lr, subframe_to_body (macpherson)
s, subframe_to_body (dwb)
lr, uca_to_body (dwb)
lr, tripot_to_differential (dwb) (unless have powertrain template)
s, steering_column_to_body (rack and pinion)
s, rackhousing_to_body (rack and pinion)
s, body_subsystem (SDI_testrig)
’_body_training’ contains:
0 output communicators of type ’location’
0 output communicators of type ’mount’
Listing of input communicators in ’_new_tire’
----------------------------------------------------------------
1. ci[lr]_wheel_center location inherit wheel_center
2. ci[lr]_wheel_mount mount inherit wheel_mount
Should have matching name of "suspension_mount" for _macpherson template.
’_new_tire’ contains:
Listing of output communicators in ’_new_tire’

----------------------------------------------------------------
’_new_tire’ contains:
Listing of input communicators in ’_steer_final’
----------------------------------------------------------------
1. cis_rackhousing_to_body mount inherit rackhousing_to_body
Should connect to the body template. Alternatively, you could change this to connect the
rack housing to the suspension subframe. However, the macpherson template we created
does not have a subframe, so you would have to use another template to do this.
2. cis_steering_column_to_body mount inherit
steering_column_to_body
Should connect to the body template.
’_steer_final’ contains:
Listing of output communicators in ’_steer_final’
----------------------------------------------------------------
1. co[lr]_tierod_to_steering mount inherit tierod_to_steering
Should connect to the macpherson template. Outputs the "rack" part.
(could create an output communicator of type location to locate the tierod to the end of the
rack; see KB 9182 for example of this)
Listing of input communicators in ’_macpherson’
----------------------------------------------------------------
1. ci[lr]_strut_to_body mount inherit strut_to_body
2. ci[lr]_subframe_to_body mount inherit subframe_to_body
3. ci[lr]_tierod_to_steering mount inherit tierod_to_steering
Should connect to the rack and pinion template.
(could create input communicator of type location to locate the tierod to the end of the rack;
see KB 9182 for example of this)
’_my_mac’ contains:

Listing of output communicators in _macpherson:
----------------------------------------------------------------
1. co[lr]_wheel_center location inherit wheel_center
Outputs the location to the wheel template.
2. co[lr]_suspension_mount mount inherit suspension_mount
Should have matching name of "wheel_mount" for wheel template. Outputs the "hub" part.
’_my_mac’ contains:
Listing of input communicators in _double_wishbone:
----------------------------------------------------------------
1. ci[lr]_ARB_pickup location inherit arb_pickup
Don’t worry about this one since we don’t have an ARB.
2. ci[lr]_strut_to_body mount inherit strut_to_body
Body template needs to have an output communicator with itself as the output part.
3. ci[lr]_tierod_to_steering mount inherit tierod_to_steering
Body template needs to have an output communicator with itself as the output part in order
to fix the steering in the rear.
4. ci[lr]_tripot_to_differential mount inherit tripot_to_differential
This should be connected to the body, as above. However, when adding a powertrain, the
body communicator should be removed.
5. ci[lr]_uca_to_body mount inherit uca_to_body
Body needs output communicator with itself as the output part.
6. cis_subframe_to_body mount inherit subframe_to_body
Body needs output communicator with itself as the output part.
’_double_wishbone’ contains:

Listing of output communicators in _double_wishbone:
----------------------------------------------------------------
1. co[lr]_tripot_to_differential location inherit tripot_to_differential
You don’t need to worry about this one. This will tell the powertrain where to locate itself
if you use one.
2. co[lr]_wheel_center location inherit wheel_center
This feeds the wheel center communicator in the wheel template.
3. co[lr]_arb_bushing_mount mount inherit arb_bushing_mount
You don’t need to worry about this one since we don’t have an ARB.
4. co[lr]_droplink_to_suspension mount inherit droplink_to_suspension
You don’t need to worry about this one since we don’t have an ARB.
5. co[lr]_suspension_mount mount inherit suspension_mount
Should have matching name of "wheel_mount" for wheel template. Outputs the "spindle"
part.
6. co[lr]_suspension_upright mount inherit suspension_upright
Don’t worry about this one. Outputs the "upright" part.
7. cos_engine_to_subframe mount inherit engine_to_subframe
Don’t worry about this one.
8. cos_rack_housing_to_suspension_subframe mount inherit
rack_housing_to_suspension_subframe
You may want to hook this up to your rack housing in your rack and pinion template if you
want to hook the rack housing to the subframe. Otherwise, just connect the rack housing
to the body, which is probably simpler in this case. Outputs the "subframe" part.
’_double_wishbone’ contains:

Listing of input communicators in __MDI_SDI_TESTRIG:
----------------------------------------------------------------
cis_body_subsystem mount inherit body_subsystem
’__MDI_SDI_TESTRIG’ contains:
1 input communicator of type ’mount’
22 Create new subsystems for all templates.
23 Create a new full-vehicle assembly with the new subsystems you just made. Make sure
that none of the critical communicators appear in the warning message about unmatched
communicators.
24 Adjust the different subsystems so they appear in the right location relative to each other.
Shift the front and the rear suspensions by this amount:
Front suspension aft 250 mm
up 230
Rear suspension aft 2800 mm
up 37.3 mm
25 View only the double-wishbone suspension.
26 From the Adjust menu, select Driveline Activity.
27 Set Current Mode to Inactive.
28 Run a full-vehicle steering analysis.
In the open-loop steering events, because there is no powertrain, there will be no acceleration. You can, however, run
these events with initial velocity.
$ (;$03/($1$/<6(6
This appendix provides a basic outline of how you can use ADAMS/Car to
analyze your vehicle.
:KDW·VLQWKLVDSSHQGL[
■ Types of Analyses, 214
■ Gather Data for the Model, 215
■ Packaging Analysis on Suspension, 216
■ Kinematic Analysis on Suspension, 217
■ Suspension-Compliance Analysis, 219
■ Static-Loading Durability Analysis, 220
■ Dynamic-Loading Durability Analysis, 222
■ Front Suspension Analyses, 223
■ Full-Vehicle Design and Analysis, 224
213
7\SHVRI$QDO\VHV
%HORZLVDOLVWRIDQDO\VHVWKDW\RXFDQSHUIRUP$'$06&DU
■ Packaging analysis on suspension
■ Kinematic analysis on suspension
■ Suspension-compliance analysis on suspension
■ Static-loading durability analysis on suspension
■ Dynamic-loading durability analysis on suspension
■ Full-vehicle design and analysis
,QWKHIROORZLQJSDJHVDJXLGHLVJLYHQWRSHUIRUPWKHVHDQDO\VHV
7KLVJXLGHRQO\OLVWVDVXEVHWRIWKHDQDO\VHVDYDLODEOHLQ
$'$06&DU0RUHRYHUVRPHDGGLWLRQDOPRGXOHVPD\EH
QHFHVVDU\IRUWKHDQDO\VHVOLVWHGIRUH[DPSOH
$'$06'XUDELOLW\)RUPRUHLQIRUPDWLRQRQDSDUWLFXODUDQDO\VLV
VHHWKHGRFXPHQWDWLRQ
214 Example Analyses

*DWKHU'DWDIRUWKH0RGHO
&ROOHFWWKHGDWDQHFHVVDU\WRJHQHUDWHDQ$'$06PRGHORIWKH
SURSRVHGVXVSHQVLRQFRQFHSW$IWHU\RX·YHFROOHFWHGWKHGDWDIURP
YDULRXVVRXUFHV&$'GDWDIRUJHRPHWU\EXVKLQJGDWDIURP
LQWHUQDOWHVWLQJIDFLOLWLHVRUIURPEXVKLQJVXSSOLHUVKRFNGDWD
DQGVRRQ\RXFDQFUHDWHDQ$'$06&DUPRGHO
Example Analyses 215

3DFNDJLQJ$QDO\VLVRQ6XVSHQVLRQ
2QFH\RX·YHFUHDWHGWKH$'$06PRGHO\RXSXWWKHYLUWXDO
VXVSHQVLRQRQDYLUWXDOWHVWIL[WXUHVWDQGDUGSDUWRI
$'$06&DUDQGUXQWKURXJKDVHULHVRIHYHQWVWRH[DPLQH
SDFNDJLQJDQGLQWHUIHUHQFHLVVXHV7KHJRDORIWKLVDQDO\VLVLVWR
VKRZWKDWSDUWVGRQRWFROOLGHGXULQJMRXQFHDQGUROOWUDYHO
$OVRLIERG\JHRPHWU\LVDYDLODEOHEHDEOHWRGHPRQVWUDWHWKDW
WLUHDQGZKHHOZHOOFOHDUDQFHVFRQIRUPWRFRUSRUDWHVWDQGDUGV
7KHJRDORIWKLVSKDVHRIWKHDQDO\VLVLVWRJLYHDFXUVRU\FKHFN
RIWKHSDUWFROOLVLRQVZLWKLQWKH$'$06&DUHQYLURQPHQW
)XUWKHULQYHVWLJDWLRQVDUHSRVVLEOHE\EULQJLQJWKH$'$06UHVXOWV
IRUWKHZKHHOHQYHORSHGXULQJPD[LPXPMRXQFHUHERXQGUROOWUDYHO
LQWR\RXU&$'SDFNDJH<RXFDQXVHWKHVROLGJHRPHWU\RIWKH
ZKHHOHQYHORSHLQ\RXU&$'SDFNDJHWRHDVLO\ILQGFOHDUDQFH
LVVXHVDQGWREHWWHUYLVXDOL]HWKHWRWDOZKHHOHQYHORSHQHHGHGE\
\RXUVXVSHQVLRQFRQFHSW

.LQHPDWLF$QDO\VLVRQ6XVSHQVLRQ
$IWHU\RX·YHDQDO\]HGWKHVXVSHQVLRQSDFNDJLQJLVVXHVSXWWKH
YLUWXDOVXVSHQVLRQRQDYLUWXDOWHVWIL[WXUHDQGUXQWKURXJKD
VHULHVRIHYHQWVWRXQGHUVWDQGWKHNLQHPDWLFSURSHUWLHVRIWKH
VXVSHQVLRQ7ZRDQDO\VHVKHOS\RXXQGHUVWDQGWKHVXVSHQVLRQ
NLQHPDWLFVSDUDOOHOZKHHOWUDYHOZKHHOVPRYLQJYHUWLFDOO\LQ
SKDVHDQGUROOWUDYHOZKHHOPRYLQJYHUWLFDOO\RXWRISKDVH
7KHSDUDOOHOZKHHOWUDYHODQDO\VLVDOVRFDOOHGWKHULGHWUDYHO
HYHQWH[DPLQHVWKHIROORZLQJVXVSHQVLRQPHWULFV
■ Toe (also called bump steer)
■ Caster
■ Camber
■ Longitudinal recession
■ Lateral recession
Wheel rate (vertical force from suspension springs versus amount of suspension vertical
deflection)
7KHUROOWUDYHODQDO\VLVH[DPLQHVWKHIROORZLQJVXVSHQVLRQ
PHWULFV
■ Roll steer (degrees of toe per degree of suspension roll)
■ Roll stiffness

.LQHPDWLF$QDO\VLVRQ6XVSHQVLRQ
7KHJRDORIWKHNLQHPDWLFDQDO\VLVLVWRWXQHWKHJHRPHWU\RIWKH
VXVSHQVLRQWRDWWDLQVDWLVIDFWRU\NLQHPDWLFEHKDYLRU,INLQHPDWLF
LVVXHVDULVHGHVLJQUHFRPPHQGDWLRQVFDQWKHQEHPDGHWRWKH
ORFDWLRQRIVXVSHQVLRQMRLQWVDQGEXVKLQJVWKHOHQJWKVRIWKH
FRQWURODUPVDQGRWKHUJHRPHWULFSURSHUWLHVWKDWDIIHFWWKH
NLQHPDWLFVRIWKHVXVSHQVLRQ
$OVRVXVSHQVLRQVSULQJSURSHUWLHVFDQEHH[DPLQHGWREHVXUH
WKDWWKHRYHUDOOYHKLFOHUHTXLUHPHQWVZLOOEHPHWIRUVXVSHQVLRQ
VSULQJVGXULQJULGHDQGUROO8VHRIDGGLWLRQDOVXVSHQVLRQ
FRPSRQHQWVVXFKDVDQDQWLUROOEDUFDQEHH[DPLQHGLQFOXGLQJ
UHFRPPHQGDWLRQVDERXWWKHVL]LQJIRUWKHDQWLUROOEDU

6XVSHQVLRQ&RPSOLDQFH$QDO\VLV
$IWHU\RXDQDO\]HWKHVXVSHQVLRQJHRPHWU\DQGWKHGHVLJQVKRZV
JRRGNLQHPDWLFEHKDYLRU\RXFDQH[DPLQHVXVSHQVLRQFRPSOLDQFH
7KHYLUWXDOVXVSHQVLRQPRGHOZLOOEHSODFHGRQWKHVXVSHQVLRQWHVW
ULJDQGUXQWKURXJKWKHFRPSOLDQFHDQDO\VLVIRUH[DPSOHVWDWLF
ORDGLQJ7KHIROORZLQJPHWULFVDUHJHQHUDWHGZLWKWKLVDQDO\VLV
■ Lateral force versus toe (for both parallel and opposing lateral force)
■ Lateral force versus camber (for both parallel and opposing lateral force)
■ Lateral force versus lateral displacement (for both parallel and opposing lateral force)
■ Longitudinal force versus toe (braking and acceleration forces)
■ Longitudinal force versus longitudinal displacement (braking and acceleration forces)
■ Aligning torque versus toe (parallel and opposing torques)
7KHJRDORIWKHVXVSHQVLRQFRPSOLDQFHDQDO\VLVLVWRWXQHWKH
VXVSHQVLRQEXVKLQJVVXFKWKDWDGHTXDWHVXVSHQVLRQFRPSOLDQFHLV
DWWDLQHG1RWHWKDWEDOOMRLQWVDUHQRWLQILQLWHO\VWLIIDQGWKH\
GRIDFWRULQWRWKHVXVSHQVLRQSHUIRUPDQFH7KXVLWPD\EHD
JRRGLGHDWRUHSODFHLGHDOL]HGEDOOMRLQWVLQ\RXUPRGHOZLWK
EXVKLQJUHSUHVHQWDWLRQV

6WDWLF/RDGLQJ'XUDELOLW\$QDO\VLV
7KHQH[WVWHSLQDQDO\]LQJWKHVXVSHQVLRQLVWRDSSO\VWDWLF
ORDGFDVHVWRWKHZKHHOVLQ$'$06&DUDQGH[DPLQHWKHUHVXOWLQJ
ORDGVRIWKHVXVSHQVLRQHOHPHQWVVXVSHQVLRQEXVKLQJVVXVSHQVLRQ
VSULQJVDQGVRRQ7KLVFRQWULEXWHVWRDEHWWHUXQGHUVWDQGLQJRI
WKHGXUDELOLW\RIWKHVXVSHQVLRQ
7\SLFDOO\DVHWRIUHTXLUHPHQWVIRUVWDWLFORDGVDUHXVHGZKLFK
WDNHWKHIRUPRIDZRUVWFDVHORDGLQJFRQGLWLRQWKDWDVXVSHQVLRQ
PXVWZLWKVWDQG7KHVHORDGLQJFRQGLWLRQVRUORDGFDVHVWDNHWKH
IRUPRIQXPEHURIJ
VRIORDGLQJ)RUH[DPSOHDVXVSHQVLRQ
UHTXLUHPHQWPLJKWEHWKDWLWPXVWZLWKVWDQGJ
VRIYHUWLFDO
ORDGJ
VRIORQJLWXGLQDOORDGDQGJRIODWHUDOORDG6XFKD
ORDGLQJFRQGLWLRQLVRIWHQUHIHUUHGWRDVDJORDGFDVH
7KHXVHRIJ
VGHVFULEHVWKHWRWDOYHKLFOHZHLJKWGLYLGHGE\WKH
IURQWWRUHDUORDGGLVWULEXWLRQ,QWKLVZD\DORDGFDVH
UHTXLUHPHQWLQJ
VRIORDGFDQEHXVHGDFURVVGLIIHUHQWYHKLFOHV
RIYDULRXVVL]HVDQGZHLJKWV
7KHJRDORIWKHORDGFDVHDQDO\VLVLVWRJLYHWKHGHVLJQDQG)($
DQDO\VWDUHSRUWZKLFKVKRZVWKHZRUVWFDVHORDGLQJRQHDFKRI
WKHVXVSHQVLRQFRPSRQHQWVFRQWURODUPEXVKLQJVVSULQJDQGVR
RQ7KLVGDWDFDQWKHQEHIHGLQWRD)($PRGHORIWKHFRPSRQHQW
EXVKLQJFRQWURODUPVSULQJDQGVRRQWRVKRZWKDWWKH
FRPSRQHQWZLOOZLWKVWDQGDJLYHQDPRXQWRIVWDWLFORDGLQJ$
VWUXFWXUHGUHSRUWZLOOEHJHQHUDWHGWKURXJKWKHXVHRIWKH
ORDGFDVHSRVWSURFHVVRUZKLFKZLOOVKRZWKHDPRXQWRIORDGLQJRQ
WKHVXVSHQVLRQHOHPHQWVDQGXVLQJWKLVUHSRUWWKHORDGLQJGDWD
FDQEHLPSRUWHGLQWRWKH)($VRIWZDUH1$675$1$16<6
$%$486DQGVRRQ

6WDWLF/RDGLQJ'XUDELOLW\$QDO\VLV
,WLVUDUHWKDWWKHGHVLJQHQJLQHHUFDQKDYHDFFHVVWRWKLVOHYHO
RIGDWDHDUO\LQWKHSURJUDPVRWKHVWDWLFORDGFDVHDQDO\VLV
SURYLGHVWKHILUVWLQVLJKWWRUHDOZRUOGORDGLQJFRQGLWLRQVIRUWKH
SDUWV7KLVPHWKRGLVFRDUVHDQGGRHVQRWSURYLGHWKHILQDO
DQVZHUWRWKHGXUDELOLW\UHTXLUHPHQWVRIWKHVXVSHQVLRQ
FRPSRQHQWVEXWHDUO\LQWKHGHVLJQDQGDQDO\VLVWKLVLQIRUPDWLRQ
LVH[WUHPHO\YDOXDEOH

'\QDPLF/RDGLQJ'XUDELOLW\$QDO\VLV
$IWHUWKHVWDWLFGXUDELOLW\DQDO\VLVLVFRPSOHWHGDPRUHLQWHQVLYH
LQYHVWLJDWLRQLQWRWKHUXEEHUPRXQWVEHJLQV,QWKLVSKDVHDURDG
SURILOHZLOOEHDVVXPHGIRUWKHVXVSHQVLRQIRUH[DPSOHDSRWKROH
RUUDQGRPZKLWHQRLVHURDGLQSXWDQGXWLOL]HGRQDYLUWXDOIRXU
SRVWVKDNHUHYHQWZLWKLQ$'$06&DU7KH$'$06G\QDPLF
ORDGLQJKLVWRULHVRIWKHPRXQWVZLOOWKHQEHLPSRUWHGLQWR)($
VRIWZDUHIRUILQDOVWUXFWXUDODQDO\VLV

)URQW6XVSHQVLRQ$QDO\VHV
%HVLGHVWKHDQDO\VHVDOUHDG\OLVWHGVSHFLILFWRWKHIURQW
VXVSHQVLRQVWHHULQJV\VWHPPHWULFVZLOODOVREHH[DPLQHGWR
XQGHUVWDQGWKHRYHUDOOVWHHULQJUDWLRVWHHULQJOLQHDULW\
$FNHUPDQDQGVWHHULQJFROXPQXQLYHUVDOMRLQWSKDVLQJHQVXUHWKDW
WKHVWHHULQJIHHOLVQRWOXPS\

)XOO9HKLFOH'HVLJQDQG$QDO\VLV
2QFHWKHUHDUVXVSHQVLRQIURQWVXVSHQVLRQDQGVWHHULQJV\VWHP
VXEV\VWHPVKDYHEHHQPRGHOHGLQ$'$06&DUWKHQH[WVWDJHRI
WKH)XQFWLRQDO'LJLWDO&DUSURFHVVLVWRDQDO\]HWKHIXOOYHKLFOH
EHKDYLRU%HFDXVHWKHYDULRXVVXVSHQVLRQVXEV\VWHPPRGHOVKDYH
EHHQGHYHORSHGLQWKHHDUOLHUVWDJHVRIWKHSODQLWZLOOEHD
VLPSOHPDWWHUWRDVVHPEOHWKHVHVXEV\VWHPVLQWRDIXOOYHKLFOH
$'$06&DUPRGHO
7KLV$'$06&DUPRGHOZLOOEHGULYHQRQDVHWRIYLUWXDOWHVW
WUDFNVWRXQGHUVWDQGYDULRXVIXOOYHKLFOHPHWULFV([DPSOHWHVW
DQDO\VHVZRXOGEH
■ Static vehicle trim analysis to trim the vehicle to a particular ride height
■ Double lane change (Moose Test) to examine rollover propensity in an accident-
avoidance maneuver
■ Constant radius to examine understeer/oversteer behavior of the vehicle and generate
an understeer budget report
■ Brake drift to examine amount of lateral drift during a moderate-braking maneuver
■ Brake in a turn to examine dynamic braking and turning stability issues
([DPSOHWHVWHYHQWV
■ Step steer to examine lateral acceleration and yaw rate overshoot during highly
dynamic maneuver
■ Frequency response to examine vehicle dynamics metrics in the frequency domain
■ Dynamic durability to determine the behavior of the vehicle as it drives over potholes,
bumps, and other three dimensional road obstacles

% )28532679(57,&$/(;&,7$7,217(67
This tutorial teaches you how to work with custom ADAMS/Car test rigs,
custom simulation procedures, and how to create a private ADAMS/Car
binary.
You will work with an existing test rig created in ADAMS/Car Template
Builder. This tutorial will overview the internal workings of the test rig, cover
the steps used in making it, and then detail how to edit it and create a custom
ADAMS/Car binary containing the test rig.
To go through this tutorial, you must have access to the six four-post test rig
model, macro, and interface files: acar_build.cmd, acme_3PostRig.cmd,
acme_four_sim.cmd, macros_ana.cmd, mac_ana_ful_fou_sub.cmd, and
acme_4PostRig.cmd.
■ Introduction, 226
■ Creating a test rig template in ADAMS/Car, 230
■ Preparing to create a private binary, 239
■ Creating an assembly using the test rig, 243
■ Adding custom analysis procedures to ADAMS/Car, 247
225
Have them go through the guide, Getting Started Using ADAMS/Insight.

)RXU3RVW9HUWLFDO([FLWDWLRQ7HVW
,QWURGXFWLRQ
The objective of this exercise is to investigate the vertical dynamics of the full vehicle and its
suspension systems. The test results can be postprocessed in the frequency domain to study the
damped natural frequencies of various ride modes and their respective damping levels.
Additional insight can also be gathered into the influences of the vehicle’s vertical dynamics’
effects on handling behavior by gaining a further understanding of system dynamic responses
including:
■ Front to rear modal balance
■ Suspension to body transfer function gain and phase
■ Suspension to tire transfer function gain and phase
■ Tire contact patch vertical load variation
The test is conducted by assembling a standard full-vehicle model to a special four-post test rig.
The test rig is simply defined by four parts representing the tire pads that support the vehicle.
These tire pads are constrained to move in only the vertical direction and a displacement
actuator (motion controller) controls their vertical motion. The only constraint between the pads
and the vehicle’s tires is the friction of the tire itself. Because the Delft tire model supports zero
velocity tire friction, this is all that is required to constrain the vehicle during the dynamic
portion of the simulation.
226 Four-Post Vertical Excitation Test

The vertical actuators are each controlled by an analytical function. The analytical functions are
used to describe the displacement profile of the actuator in the time domain and they are limited
to constant amplitude sinusoidal input that sweeps over a predetermined frequency range in a
set amount of time. When using the analytical function control there exist four excitation modes
described below:
■ Heave: all tire pads move vertically in phase.
■ Pitch: the front tire pads move 180 degrees out of phase with the rear tire pads.
■ Roll: the left tire pads move 180 degrees out of phase with the right tire pads.
■ Warp: the left-front and right-rear tire pads move 180 degrees out of phase with the
right-front and left-rear pads.
7HVWULJGHVFULSWLRQ
The four-post test rig was created in
ADAMS/Car Template Builder and is
named __acme_4PostRig.tpl. What
follows is a brief description of how it
works and how it relates to the standard
ADAMS/Car simulation types.
The major role of the four-post test rig
template is analysis and it contains four
general parts. There are four tire pads
and four actuators for each of the
vertical translation joints on each pad.
The location of all of the pads and their
respective constraints, actuators, and
so on, are parameterized in the ground
plane (X and Y) to a wheel center location communicator that comes from the suspension
systems. The vertical location is parameterized to the Z location of the std_tire_ref marker. The
std_tire_ref marker has its Z height set automatically during the assembly process so that it
represents the vehicles average tire contact patch height.
Four-Post Vertical Excitation Test 227

8VHULQSXWUHTXLUHPHQWVVLPXODWLRQGHVFULSWLRQ
The analysis input parameters are grouped in two categories: one group of parameters is
common to all analyses, while the other group consists of input specific to this four-post test.
The four-post simulation input requirements are controlled by the user in order to define the
boundary conditions of the desired vertical excitation test.
Always required:
■ Output Prefix
■ End Time
■ Number of Steps
■ Type of Analysis (Interactive, Background)
■ Analysis Log File (Yes, No)
Four-post simulation input requirements:
■ Peak Displacement
■ Displacement Units (m, mm, inch, and so on)
■ Frequency Range (Units hardcoded to Hz)
■ Excitation Mode (Heave, Pitch, Roll, Warp)
$VVHPEO\DQGVLPXODWLRQSURFHVVUHTXLUHPHQWV
The following steps outline what the test rig simulation process is doing internally after a
simulation has been requested. The vehicle/test rig assembly process is similar regardless of the
user input parameters outlined in the previous section of the document. However, the
modifications made to the assembled model will vary depending on these parameters.
Assembly process:
1 Same subsystem level check as in any full-vehicle maneuver with possibly an extra check
to ensure there are no more then four wheels and two suspensions.
2 Assemble vehicle with test rig. Location communicators will locate the pads in the X and
Y plane.

3 Loop over the tires and reassign the GFORCE reference markers to the appropriate
respective pad. The left front tire’s reference marker needs to belong to the gel_front_pad
part of the test rig for example.
4 Assign the Z location of the std_tire_ref marker based on the average contact patch
location of all of the tires (the same as it is done in a full-vehicle simulation).
5 Set the tire property file to a hardcoded value of mdi_2d_flat.rdf for each of the tires
without generating any road geometry.
6 Modify the actuator’s (jmf_left_front_actuator, jmf_right_front_actuator, and so on)
analytical functions according to the user input data:
The following functions need to be assigned to each actuator based on the analytical drive
signal:
Left Front = LF_phase*Peak_Amplitude*sin(1/2*360D*Freq_Range/End_Time*Time**2)
Right Front = RF_phase*Peak_Amplitude*sin(1/2*360D*Freq_Range/End_Time*Time**2)
Left Rear = LR_phase*Peak_Amplitude*sin(1/2*360D*Freq_Range/End_Time*Time**2)
Right Front = RR_phase*Peak_Amplitude*sin(1/2*360D*Freq_Range/End_Time*Time**2)
Where the following values are assigned to the phase variables:
■ Heave Mode: LF_Phase, RF_Phase, LR_Phase, RR_Phase = 1.0
■ Pitch Mode: LF_Phase, RF_Phase = 1.0 & LR_Phase, RR_Phase = -1.0
■ Roll Mode: LF_Phase, LR_Phase = 1.0 & RF_Phase, RR_Phase = -1.0
■ Warp Mode: LF_Phase, RR_Phase = 1.0 & RF_Phase, LR_Phase = -1.0
The test rig then goes through the following simulation process:
■ Submit the simulation to the solver using a similar process as the full-vehicle
simulation. The simulation needs one static equilibrium, an initial velocity = 0.0, and
then a dynamic simulation equal to the end. The hmax on the integrator should also
be set to at least 1/10 of the maximum frequency range. For example, if the frequency
range set by the user is 20Hz then the hmax should be 1/10*1/20 = 1/200 (0.005).
This is necessary to avoid aliasing of the input during the simulation.

&UHDWLQJDWHVWULJWHPSODWHLQ$'$06&DU
A minimum prerequisite for the task of adding a test rig to ADAMS/Car is a thorough
understanding of all aspects of ADAMS/Car Template Builder. It is very important that users
attempting to create test rigs in ADAMS/Car have a firm understanding of the concepts of
communicators and actuators. You should reference the guide, ADAMS/Car Templates as you
work through this section. It might also be beneficial to examine the test rigs that are included
in standard ADAMS/Car.
A test rig in ADAMS/Car is almost completely comparable to a template in ADAMS/Car. Test
rigs differ from templates mainly because test rigs contain actuator elements, such as motions
and forces, to excite the assembly.
The procedure for creating a test rig template in ADAMS/Car is just like the procedure of
creating a normal template, with a few differences. The steps for creating a test rig template are:
■ Creating a test rig template
■ Saving the test rig template
■ Modifying the test rig template
*HWWLQJVWDUWHG
A test rig template is created in the template builder in ADAMS/Car. Like a regular template, a
test rig template can contain parts attached together via attachments and forces. Unlike most
templates, the test rig template will also contain actuators to excite the system. The test rig
template, like normal templates, will also contain communicators to enable the exchange of
information with other templates.
Because templates and test rigs are so similar, it would be redundant to fully describe how to
create test rigs. Instead, see the guide, ADAMS/Car Templates for specific information about
building templates and communicators.
ADAMS/Car works with test rigs as templates. However, in order to incorporate a test rig for
use on an assembly, the test rig must be converted to a test rig model file (.cmd) and a private
ADAMS/Car binary created. You can, of course, create a new test rig template from the
ADAMS/Car interface very easily, but it is often best to work with existing templates in order
to better understand the capabilities of ADAMS.
You start by modifying an existing test rig model file (.cmd) in the template builder. Start by
locating the file acme_3PostRig.cmd. This is a test rig model file (.cmd) that contains a test rig
currently equipped with three active posts.

/RDGLQJDWHVWULJPRGHOILOHFPGLQWRWKH$'$06&DU7HPSODWH%XLOGHU
If you want to open an existing test rig model (.cmd) file and edit it using ADAMS/Car
Template Builder, follow the steps outlined in this section. Try these steps out on the
acme_3postrig.cmd file. Note that you should be careful if using a private or site ADAMS/Car
binary when editing a test rig template. If you already made a test rig and a private binary
incorporating it, you cannot edit the test rig of the same name.
7RORDGDWHVWULJPRGHOILOH
1 Move the test rig model file, acme_3postrig.cmd file, to your private car database under the
templates table (for example, C:\private.cdb\templates.tbl\).
2 Rename the file from acme_3postrig.cmd to __acme_4PostRig.tpl.
3 Open the file in a text editor.
4 Insert the header as follows:
■ Note that the template name must match the file name exactly (excluding the
extension).
■ Note that there is a variable called "date" inside the acme_4postrig.cmd file. This
must be set to the same date as the header:
$---------------------------------------------------------------------MDI_HEADER
[MDI_HEADER]
FILE_TYPE = ’tpl’
FILE_VERSION = 13.4
HEADER_SIZE = 9
(COMMENTS)
{comment_string}
’ADAMS/Car analysis template’
$----------------------------------------------------------------TEMPLATE_HEADER
[TEMPLATE_HEADER]
TEMPLATE_NAME= ’__acme_4PostRig’
MAJOR_ROLE = ’analysis’
TIMESTAMP = ’1998/08/28,09:23:05’
HEADER_SIZE = 6

5 There is a variable inside the acme_4postrig.cmd file called model_class. Search for
model_class. Change this variable assignment to look like the following (this variable
must be set to template for Template Builder to use it):
variable create &
variable_name = .__acme_4PostRig.model_class &
string_value = "template" &
comments = "Memory for ADAMS/Car model class"
!
2SHQLQJWKHWHVWULJLQ$'$06&DU7HPSODWH%XLOGHU
The file that you just specified as an ADAMS/Car template contains a model of a test rig with
only three active posts. In this section, you activate the fourth (left-front) post.
7RRSHQWKHWHVWULJ
1 Make sure that your .acar.cfg file specifies you as an expert user so you can start the
ADAMS/Car Template Builder.
2 Start ADAMS/Car and select the template-builder mode at the prompt.
4 Right-click the Template Name text box, point to Search, and then select <private>/
templates.tbl.
5 Select the __acme_4PostRig.tpl template file, and then select OK twice.
6 Make sure icon visibility is on, the view is set to Front Iso and the view is zoomed to fit.

0RGLI\LQJWKHWHVWULJLQ$'$06&DU7HPSODWH%XLOGHU
To make the actuator active, you will add a variety of items to the test rig: a bumpstop, a
reboundstop, a joint attachment, a joint motion actuator, and a joint force actuator.
7RDGGDEXPSVWRS
1 From the Build menu, point to Bumpstop, and then select New.
2 In the Bumpstop Name text box, enter front_extension_stop.
3 Specify the I Part as gel_front_pad by typing it in or by right-clicking the text box, pointing
to Part, selecting Pick, and then choosing the part gel_front_pad.
4 Specify the J Part as ground by right-clicking the text box, pointing to Guesses, and then
selecting ground.
5 Specify the I Coordinate Reference as cfl_Front_Actuator_Base.
6 Specify the J Coordinate Reference as cfl_Front_Pad.
7 Ensure that the Property File text box specifies <shared>\bumpstops.tbl\mdi_0001.bum as the
property file.
8 In the Clearance text box, enter 127.
9 Select OK.
Note that because of symmetry relations, not only is a bumpstop immediately created on
the left front actuator base, but one is also created on the right front.
7RFUHDWHDUHERXQGVWRS
1 From the Build menu, point to Reboundstop, and then select New.
2 In the Reboundstop Name text box, enter front_retract_stop to enforce a consistent naming
convention.
3 Set I Part to gel_front_pad.
4 Set J Part to ground.
5 Set I Coordinate Reference to cfl_Front_Actuator_Base.
6 Set J Coordinate Reference to cfl_front_pad.
7 Ensure that the Property File text box points to <shared>\reboundstops.tbl\mdi_0001.reb.

8 In the Clearance text box, enter 127.
9 Select OK.
Note that because of symmetry relations, not only is a reboundstop immediately created on
the left front actuator base, but one is also created on the right front.
7RDGGDQDWWDFKPHQWEHWZHHQWKHDFWXDWRUSDGDQGDFWXDWRUEDVH
1 From the Build menu, point to Attachments, point to Joint, and then select New.
2 Specify the Joint Name as left_front_pad.
3 Specify the I Part as ground.
4 Specify the J Part as gel_front_pad.
5 Set the Type to single.
6 Set Joint Type to translational.
7 Set Location Dependency to Delta location from coordinate.
8 Set Location Coordinate Reference to cfl_front_pad.
9 Set Location to 0,0,0 in local.
10 Set Orientation Dependency to Delta orientation from coordinate.
11 Set Construction Frame to cfl_front_pad.

12 Set Orientation to 0,0,0.
13 Select OK.
7RPDNHWKHMRLQWPRWLRQDFWXDWRU
1 From the Build menu, point to Actuators, point to Joint Motion, and then select New.
2 Specify the Actuator Name as left_front_actuator to enforce consistent naming.
3 Specify the joint as jostra_left_front_pad by picking the joint you just created.
4 In the Application text box, enter pad_excitation.
5 In the Identifier text box, enter left_front_actuator.
6 In the Function text box, enter 15*sin(720d*time).
7 Specify the Time Derivative as displacement.

8 Set the Force Limits to -5e4,5e4.
9 Set the Displacement Limits to -1000,1000.
10 Set the Velocity Limits to -1e4,1e4.
11 Set the Acceleration Limits to -9.8e4,9.8e4.

12 In the Units text box, enter mm.
13 Select OK.
7RPDNHWKHMRLQWIRUFHDFWXDWRU
1 From the Build menu, point to Actuators, point to Joint Force, and then select New.
2 Specify the Actuator Name as lf_force_actuator.
3 Pick the Joint as jostra_left_front_pad.
4 In the Application text box, enter Left front actuator force.
5 In the Identifier text box, enter Left front actuator force.
6 In the Function text box, right-click and point to Function Builder.
7 Paste the following into the text box:
(STEP(TIME,0,1,0.002,0)*
(1e5)*VARVAL(lf_actuator_disp))
+STEP(VARVAL(lf_actuator_vel),-pvs_Friction_Saturation_Velocity,
-pvs_Friction_Saturation_Force,pvs_Friction_Saturation_Velocity
,pvs_Friction_Saturation_Force)
-VARVAL(lf_actuator_force)
8 Select OK.

6DYLQJWKHWHVWULJWHPSODWH
The test rig template is saved to a file just like a regular template. The test rig template should
be saved in an ASCII format to facilitate the modifications that are required and described in the
next section. Storing the template in ASCII format also ensures portability from one machine to
another. It allows, for example, the same file to be used when building a site binary on either a
UNIX or NT machines.
7RVDYHWKHWHPSODWH
1 From the File menu, select Save.

2 Make sure the file format is set to ASCII, and that Zero Adams Ids is selected.
3 Select Close Template.
4 Select OK, don’t save a backup copy when prompted.
0DNLQJDWHVWULJPRGHOILOHFPGIURPDQ$'$06&DUWHPSODWH

You must manually modify the file of the test rig template to make it into a test rig model file
(.cmd). There are two modifications that you must do to the ASCII template file generated from
ADAMS/Car.
If you want to take a test rig built in the template builder and then use it as a test rig, you should
basically perform the steps in Loading a test rig model file (.cmd) into the ADAMS/Car Template
Builder on page 231 in reverse order:
7RPDNHDWHVWULJIURPDWHPSODWH
1 Outside of ADAMS/Car, from your private database, copy the file __acme_4PostRig.tpl
from the templates.tbl table to your private directory (C:\acar_private) or another directory.
2 Rename the file to acme_4PostRig.cmd.
3 Using a text editor, open acme_4PostRig.cmd.

4 There is a variable inside __acme_4PostRig.tpl named model_class. Change this variable
assignment to look like the following (this variable must be set to test rig in order for it to
be used as one):
variable create &
string_value = "testrig" &
!
5 Remove the header information that is added at the beginning of the ASCII template file.
This header must be removed because the command file reader will not understand the
information stored in this header and will output errors. A typical header from an ASCII
was shown in Loading a test rig model file (.cmd) into the ADAMS/Car Template Builder
on page 231.
6 Remove all the lines from the beginning of the file up to and including the line containing
the HEADER_SIZE attribute.
7 Save the file
$'$069LHZYDULDEOHVUHTXLUHGLQDWHVWULJ
Templates and test rigs in ADAMS/Car 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 have an additional
ADAMS/View variable named assembly class.
All the variables required in a test rig are described below. The first three variables: role,
minor_role, and model_class are all created automatically when the test rig template is created.
You must manually create the variable testrig_class, which is unique to test rigs, as described
above.
Major role
The major role of ADAMS/Car templates and test rigs is stored in an ADAMS/View variable
named role. The major role of a test rig is always analysis. When creating a test rig in
ADAMS/Car, it is important to ensure that this value is set properly.
variable create &
variable_name = .__acme_4PostRig.role &
string_value = "analysis" &
comments = "Memory for ADAMS/Car major role"

Minor role
The minor role of ADAMS/Car templates and test rigs is stored in an ADAMS/View variable
named minor_role. The minor role of a test rig is typically any. Setting the minor role to any is
extremely important if you are designing a test rig that is supposed to work with other
subsystems that can have different minor roles. For example, a suspension test rig should work
with either front, rear, or trailer type suspensions. If the minor role of the test rig is defined as
any in this case, the communicators will not hook up properly between the test rig and
suspension subsystem.
variable create &
variable_name = .__acme_4PostRig.minor_role &
string_value = "any" &
comments = "Memory for ADAMS/Car minor role"
Model class
Every model in ADAMS/Car has a specific model class. The model class of a model is stored
in an ADAMS/View variable named model_class. This variable is automatically created at the
time the model is created. Currently, in ADAMS/Car, there are four model classes defined:
template, subsystem, test rig, and assembly.
variable create &
string_value = "testrig" &
Test rig class
All test rigs in ADAMS/Car can be associated with a particular class of assembly. For example,
the __MDI_SUSPENSION_TESTRIG test rig is associated with suspension assemblies. The test
rig class of a test rig is stored in an ADAMS/View variable called testrig_class.
variable create &
variable_name = .__acme_4PostRig.testrig_class &
string_value = "full_vehicle" &
comments = "Memory for ADAMS/Car testrig class"
The testrig_class variable is used directly in the graphical user interface. For example, this
variable is used in the new suspension assembly and new full-vehicle assembly dialog boxes.
These two dialog boxes each contain an option menu from which you select the test rig to be
included in the new assembly. This option menu will only contain test rigs that are compatible
with that class of assembly. The option menu on the new suspension assembly dialog box, for
example, will only list those test rigs that have a test rig class of suspension.

3UHSDULQJWRFUHDWHDSULYDWHELQDU\
You can now add both your new test rig model file acme_4PostRig.cmd) and the macro files
attached to this tutorial to build a custom private ADAMS/Car binary which can implement this
new test rig. The process of creating private and site binary files is outlined next:
1 If the directory does not exist, create a directory C:\acar_private (ADAMS always looks
for this when running a private binary).
2 In this directory, copy the five attached ACSII files into C:\acar_private:
■ acar_build.cmd
■ acme_4postrig.cmd
■ macros_ana.cmd
■ mac_ana_ful_fou_sub.cmd
■ acme_four_sim.cmd
A description of each of these follows:
acar_build.cmd
This is the file upon which ADAMS will call when building a private binary. In general, this
file contains any commands to:
■ modify the ADAMS car interface
■ import the test rig model files
■ add libraries (which show up in the command navigator)
■ add macros
■ as well as some standard commands which should be in any acar_build.cmd file
Reproduced below is the text of the acar_build.cmd file:
!---- Create custom libraries for storage ----
library create library_name=.ACME
library create library_name=.ACME.macros
The two lines above create special storage for all the acme macros that will be created.

!---- Read analysis macros and model ----
file command read file="C:\acar_private\macros_ana.cmd"
file command read file="C:\acar_private\acme_4postrig.cmd"
file command read file="C:\acar_private\acme_four_sim.cmd"
It is now necessary for acar_build.cmd to call upon any other files that are desired for building
a custom binary. In this case, we will call upon three other cmd files (described later in this
document). Note that these files’ location is hard-coded into the acar_build.cmd file. The rest of
this command file consists of standard commands to undisplay items:
!---- Standard command to undisplay model
model display model=(NONE)
!---- Standard Command for Message Box
interface dialog execute &
dialog_box_name=.gui.msg_box &
undisp=yes
acme_4PostRig.cmd
This file contains the test rig model file (.cmd) that you just created. This test rig model will be
imported into your private binary and now be available to any future assemblies.
macros_ana.cmd
This file serves as a pointer to mac_ana_ful_fou_sub.cmd. It contains a hard-coded file
location. It is good practice to use pointers like this rather than to import the simulation macros
themselves. This allows for easy modification.
mac_ana_ful_fou_sub.cmd
This is a macro that instructs ADAMS/Car on how to simulate the model. This file is discussed
in depth in Adding custom analysis procedures to ADAMS/Car on page 247.
acme_four_sim.cmd
This is a custom dialog box modification, which also adds a special Acme Four Post Simulation
item under the Tools menu. This was built with a text editor, and is commented. The commands
that make the menu items appear at the end of the file. It is easy to create your own dialog boxes
and menus, but it is often helpful to have a file like this for reference.

$GGLQJWKHIRXUSRVWDQDO\VLVWRDSULYDWHELQDU\
7RFUHDWHWKHSULYDWHELQDU\
■ From the Start menu, point to Run ADAMS 11.0, point to ADAMS/Car, point to Advanced,
and then enter cr-privatebin at the prompt.
5XQQLQJ$'$06&DUZLWKDSULYDWHELQDU\
7RUXQ$'$06&DUZLWK\RXUSULYDWHELQDU\
1 From the Start menu, point to Run ADAMS 11.0, point to ADAMS/Car, point to Advanced, and
then enter ru-private at the prompt.
2 You could also create a shortcut to this containing the path: C:\Program Files\ADAMS
11.0\common\mdi.bat acar ru-private.
Note: When you want to build a binary with a second test rig later, you will have to make
sure that acar_build.cmd calls both your new files and these old files!

,QWHUIDFHV
The easiest way to test the four-post analysis macro is to access it from the Command Navigator.
The command to be issued is the user_entered_command specified in the acar_build.cmd file
shown above. When you access the four-post macro from the Command Navigator,
ADAMS/Car automatically creates a graphical user interface (or dialog box) based on the
parameters in the macro. You can use this dialog box to execute the macro and submit the
four-post analysis:

It is also easy to create your own interface. Open the file acme_four_sim.cmd in a text editor.
This is a custom dialog box modification, which also adds a special Acme Four Post Simulation
item under the Tools menu. Output is shown next:
&UHDWLQJDQDVVHPEO\XVLQJWKHWHVWULJ
At this point you should have made a test rig template, test rig model file (.cmd), analysis macro,
private binary, and custom interface. You are now ready to run a four-post simulation on a
full-vehicle assembly.
7RFUHDWHDQDVVHPEO\
1 Start ADAMS/Car with your private binary by selecting ADAMS 11.0 - > ADAMS/Car
-> Advanced, from the Start menu.
2 At the prompt that appears, enter ru-private.
3 Make sure you select Standard Interface if ADAMS/Car prompts you about which interface
is desired.
4 From the File menu, point to New, and then select Full-Vehicle Assembly.
5 In the Assembly Name text box, enter test_4post_vehicle.

6 Right-click the Front Susp Subsystem text box, point to Search, point to <shared>/
subsystems.tbl and left-click to open up a selection window with the various available
vehicle subsystems displayed. Select TR_Front_Suspension.sub.
7 Right-click the Rear Susp Subsystem text box, and follow the instructions above to select
TR_Rear_Suspension.sub.
8 In the Steering Subsystem text box, select TR_Steering.
9 In the Front Wheel Subsystem text box, select TR_Front_Tires.sub.
10 In the Rear Wheel Subsystem text box, select TR_Rear_tires.sub.
11 In the Body Subsystem text box, select TR_Body.sub.

12 Make sure that Powertrain Subsystem is not selected.
13 Make sure that Brake Subsystem is not selected.
14 Set Vehicle Test Rig to __acme_4PostRig.
15 Select OK.
It will take some time for the assembly to complete. When it is done, you will still need to
switch the tire model to Delft, because it supports zero-velocity friction.
7RVZLWFKWKHWLUHPRGHOWR'HOIW
1 Right-click the mouse on the vehicle’s left-front wheel, point to Wheel:whl_wheel, and then
select Modify.
2 Change the Property File to <shared>\tires.tbl\mdi_delft01.tir.
3 Select OK.
4 Right-click the mouse on the vehicle’s left-rear wheel, point to Wheel:whl_wheel, and then
select Modify.
5 Change the Property File to <shared>\tires.tbl\mdi_delft01.tir.
6 Select OK.

7 From the View menu, select Assembly, and select OK to make sure that the top level is
selected.
Notice that the wheels on the right side of the car automatically adjust because of symmetry
relations. The model should now look something like this:

5XQQLQJDIRXUSRVWVLPXODWLRQ
7RUXQDVDPSOHIRXUSRVWVLPXODWLRQ
1 From the Tools menu, select Acme Four-Post Analysis.

2 Fill in the dialog box so it looks as follows:
3 Select OK.
The simulation will take some time to run.
7RUHYLHZWKHDQLPDWLRQ

2 Press the Play tool.
You can also review plots of simulation results by selecting Postprocessing Window from
the Review menu. When done, return to ADAMS/Car by selecting Exit.
You should now save this assembly and exit.
7RVDYHWKHDVVHPEO\DQGH[LW
1 From the File menu, point to Save, and then select Assembly.
2 Select Close assembly after save.
3 Select OK.
ADAMS/Car saves this assembly in your private database.

0RGLI\LQJH[LVWLQJIXOOYHKLFOHDVVHPEOLHV
7RRSHQWKHDVVHPEO\ILOHMXVWFUHDWHGDQGVHHKRZWKHWHVWULJLV
VSHFLILHG
1 Outside of ADAMS/Car, find your private database, and open the assemblies table.
2 In a text editor, open the file test_4post_vehicle.asy.
3 Scroll down until you find the text:
$------------------------------------------------------------------------TESTRIG
[TESTRIG]
USAGE = ’__acme_4PostRig’
4 Close the file.
Note that if you had an existing assembly with the test rig specified as
__MDI_SVT_TESTRIG, you could just edit the assembly file and change it to read
__acme_4PostRig.
$GGLQJFXVWRPDQDO\VLVSURFHGXUHVWR$'$06&DU
A minimum prerequisite of adding an analysis to ADAMS/Car is a thorough understanding of
the ADAMS/View macro language. You should also reference Customizing the ADAMS/Car
Interface on page 11 of the guide, Customizing ADAMS/Car as you work through this section.
ADAMS/Car is designed with an open architecture to facilitate extensions based on customer
requirements. Most often users desire to extend the analysis capabilities of ADAMS/Car to
include an analysis type or maneuver that is typical within their company, but not included in
the ADAMS/Car product. All analyses in ADAMS/Car are defined using macros. Therefore,
adding a new analysis to ADAMS/Car can be as simple as adding a new macro. A custom
graphical interface to the new macro may also be created to facilitate usage, but is not required.
This example will provide you with step-by-step instructions to create your own macro from a
given user scenario. The objective of the analysis is described in detail in the attached Four-Post
Vertical Excitation Test document. Each of the steps outlined in the above Analysis Macro
Structure section will be followed to put together the complete macro. The user scenario is
described in an attached Four-Post Vertical Excitation Test case study, and concerns the
implementation of a user macro to analyze a full-vehicle mounted on a four-post shaker table
with vertical motion inputs.

*HWWLQJVWDUWHG
The best way to get started creating a new analysis is not to start from scratch. There is a broad
range of analyses that are possible within the ADAMS/Car product as it is shipped. Examine the
existing functionality to find an analysis that closely suites the analysis you want. Once you
have selected an existing macro, simply modify it to suite your needs. If you don’t know how to
examine existing macros in ADAMS/Car, see Customizing the ADAMS/Car Interface on
page 11 of the guide, Customizing ADAMS/Car.
Where possible, existing utility macros should be used in custom analysis macros. Using the
existing utilities macros shipped within ADAMS/Car has a few benefits. First, these macros are
already written and tested by MDI. Second, using these macros reduces the amount of work
required to add a custom analysis to ADAMS/Car. Third, these macros provide a common basis
for customization, facilitating maintenance and debugging between different projects.
Any of the standard macros may be viewed via the macro editor inside ADAMS/Car. From the
ADAMS/Car menu, choose Tools->Macro->Edit->Modify to bring up the database navigator,
at which point you may select the macro you want to display. Selecting mac_ana_ful_fou_sub
from the database navigator, for instance, will allow you to view the standard macro for
submitting a full-vehicle four-post analysis.
$QDO\VLVPDFURVWUXFWXUH
In general, all the analysis macros within ADAMS/Car are structured the same. This is
especially true if you are looking only at a particular class of analysis macros. For example, all
the open-loop full-vehicle analysis macros are surprisingly similar. The same holds true for all
the full-vehicle analysis macros based on the Driving Machine. Typically, a small section
within a macro is what makes that macro and the resulting analysis unique. Every analysis
macro in ADAMS/Car has the same basic structure.
3DUDPHWHUGHILQLWLRQ
Parameters are the means by which the end user inputs values into the macro. They are
placeholders for information that the end user provides when the macro is executed. Macro
parameters are described in detail in Automating Your Work Using Macros on page 53 of the
guide, Customizing ADAMS/View.

Two parameters that are common in all analysis macros within ADAMS/Car are the assembly
and output_prefix parameters. The assembly parameter is used to specify which ADAMS/Car
assembly within the session will be analyzed. The output_prefix parameter is used to specify the
unique prefix to be added when creating output files specific to the analysis. These parameters
are usually defined first in the analysis macro as seen in the example.
The parameters for the four-post maneuver were determined from the attached Four-Post
Vertical Excitation Test document. A description is included for the parameters whose values
are important for the success of the four-post simulation.
! $assembly:t=model
! $output_prefix:t=string
! $comment:t=string:d=""
! $end_time:t=real:gt=0
! $number_of_steps:t=integer:gt=0
! $analysis_mode:t=list(interactive,graphical,background):d=interactive
! $peak_displacement:t=real:gt=0
! $units:t=list(mm):d=mm
! $frequency_range:t=real:gt=0
! $excitation_mode:t=list(heave,pitch,roll,warp):d=heave
! $load_results:t=list(yes,no):u=yes
! $brief:t=list(on,off):u=off
! $log_file:t=list(yes,no):u=yes
! $error_variable:t=variable:d=.ACAR.variables.errorFlag
Parameter descriptions:
■ assembly: This parameter expects the user to specify an existing model.
■ analysis_name: A string value indicating the name prefix for all files common to this
analysis.
■ end_time: A real value telling ADAMS/Solver the end time of the four-post
maneuver.
■ number_of_steps: An integer value telling ADAMS/Solver the number of output
steps.
■ analysis_mode: A string value to specify the mode of the analysis. The two valid
modes are interactive or background.
■ peak_displacement: The maximum amplitude of the shaker pad vertical
displacement.

■ units: Hardcoded to mm for tutorial, can be expanded to include other units.
■ frequency_range: A real value indicating the frequency range of the actuator motion
functions.
■ excitation_mode: A list value indicating the direction of the shaker pad motions.
■ log_file: Indicates if an analysis log file should be generated.
(UURUKDQGOLQJ
The error handling section of each analysis macro should contain checks to identify
inappropriate assemblies or invalid user-entered values. The error handling section should also
contain checks to ensure the assembly contains subsystems that are required to perform a
desired maneuver. For example, if you are creating an analysis macro to perform a full-vehicle,
straight-line braking maneuver, a check should be performed to ensure that a brake subsystem
exists within the assembly. The error handling section should also have checks to ensure that
the values specified by the user for specific parameters are realistic.
The four-post analysis must be performed with the __acme_4PostRig test rig described in the
attached case study. The setup of the assembly and test rig, described in a later section, perform
actions based on the elements known to exist in the __acme_4PostRig test rig. In addition to
verifying that the correct test rig is used, the macro also determines if the analysis name is
unique for this assembly.
variable set variable_name=$error_variable integer=0
!---- Check to ensure the assembly has the proper testrig ----
if condition=($assembly.original_testrig_name != "__acme_4PostRig")
acar toolkit warning &
w="Analysis cannot be submitted!", &
"The assembly does not have the proper testrig. This analysis only", &
"works with assemblies using the ’__acme_4PostRig’ testrig."
return
end
!---- Check if analysis name already exists ----
if condition=(db_exists("$assembly.$’output_prefix’_fourpost"))
if condition=(alert("question","An analysis called
\’$’output_prefix’_fourpost\’ already exists. Overwrite it?","Yes","No","",2) == 2)
return
end
end

The acar toolkit warning utility macro used in the above example will display the user message
in a small window that will remain open until you select OK. This utility macro is used
throughout ADAMS/Car to inform the user they have entered an error condition.
5HDGLQJRISURSHUW\ILOHV
Many force elements within ADAMS/Car get their nonlinear characteristics from property files.
This information must be updated immediately before an analysis is performed. If the property
files are not read, the force elements will typically contain inappropriate information that will
directly affect the accuracy of the analysis results.
After validation of the assembly, property file information must be read in and assigned. The
following example can be used directly within a user’s analysis macro. The $assembly
parameter must be an ADAMS/Car assembly as described above. Property files are read in via
a user function as described in the following example. This example also demonstrates how to
use the acar toolkit message utility macro to descriptive text to the message window. It is very
important that the property files are read before the analysis is submitted to ADAMS/Solver.
!---- Clear out message window ----
acar toolkit message &
message=" " append=no display=no closeable=yes echo_to_logfile=no
!---- Read property files ----
message="Reading in property files..."
variable set variable_name=$_self.readEm &
integer_value=(eval(read_property_file($assembly)))
message="Reading of property files completed."
6HWXSRIDVVHPEO\DQGWHVWULJ
The setup of the assembly and test rig is the section of the analysis macro that is unique from
other analysis macros. Within this section of the macro, the macro modifies elements of the test
rig and assembly based on the type of maneuver being performed and the parameters specified
by the user.
The setup of the assembly and test rig is the section of the four-post analysis macro that is unique
from other analysis macros. Within this section of this macro, elements of the test rig and
assembly are modified specific to the four-post maneuver and user input. The code fragments
for the four-post setup are shown below, with a description for each section where needed.

!---- Setup the assembly for the maneuver ----
message="Setting up vehicle assembly for four post shaker..."
The tire reference markers need to be assigned to the appropriate test pad on the shaker table.
The naming conventions of the communicator variables for the reference markers are
considered fixed, in that the macro looks for the communicators known to exist in the four-post
test rig. Note that the setup of the tire reference markers will only occur once for a particular
assembly; if the same assembly is used for multiple four-post analyses, the initial setup will be
valid for each analysis.
For each wheel, the tire reference marker is assigned to a shaker pad. The first step is to find
each tire in the full-vehicle assembly. The reassignment occurs via an output communicator in
the test rig. For more information on communicators, see Setting Up Communication Between
Subsystems and Test Rigs on page 29, in the guide, Building Templates. The communicator
holds the name of the part on the shaker pad where the tire reference marker should be attached.
if condition=(!db_exists("$assembly.fourpostSetup"))
!---- Parameterize the 4post pad height to the global road height marker just previously
adjusted ----
marker modify &
marker_name=$assembly.testrig.ground.std_tire_ref &
location=($assembly.ground.std_tire_ref.location) &
relative_to=$assembly.testrig.ground
variable set variable=$_self.frontWheel &
object_value=(eval(subsystem_lookup($assembly,"wheel","front")))
variable set variable=$_self.leftFrontWheel &
object_value=(eval(db_filter_name(db_children($_self.frontWheel[1],"ac_tire"),"til_*")))
variable set variable=$_self.rightFrontWheel &
object_value=(eval(db_filter_name(db_children($_self.frontWheel[1],"ac_tire"),"tir_*")))
variable set variable=$_self.rearWheel &
object_value=(eval(subsystem_lookup($assembly,"wheel","rear")))
variable set variable=$_self.leftRearWheel &
object_value=(eval(db_filter_name(db_children($_self.rearWheel[1],"ac_tire"),"til_*")))
variable set variable=$_self.rightRearWheel &
object_value=(eval(db_filter_name(db_children($_self.rearWheel[1],"ac_tire"),"tir_*")))
marker modify &
marker_name=(eval($_self.leftFrontWheel.object_value.ref_marker.object_value)) &
new_marker_name=(eval($assembly.testrig.col_front_pad_mount[1]//"."//
$_self.leftFrontWheel.object_value.ref_marker.object_value.name))

marker modify &
marker_name=(eval($_self.rightFrontWheel.object_value.ref_marker.object_value)) &
new_marker_name=(eval($assembly.testrig.cor_front_pad_mount[1]//"."//
$_self.rightFrontWheel.object_value.ref_marker.object_value.name))
marker modify &
marker_name=(eval($_self.leftRearWheel.object_value.ref_marker.object_value)) &
new_marker_name=(eval($assembly.testrig.col_rear_pad_mount[1]//"."//
$_self.leftRearWheel.object_value.ref_marker.object_value.name))
marker modify &
marker_name=(eval($_self.rightRearWheel.object_value.ref_marker.object_value)) &
new_marker_name=(eval($assembly.testrig.cor_rear_pad_mount[1]//"."//
$_self.rightRearWheel.object_value.ref_marker.object_value.name))
variable set variable=$assembly.fourpostSetup &
integer_value=1
end
The motion actuators driving the displacement of the shaker pads must be reset for each
individual four-post analysis. This is in contrast to the tire reference marker setup described
above, which needs to occur only once for a particular assembly, and remains valid for all
successive four-post analyses. The four excitation modes are heave, pitch, roll, and warp. Each
of the four shaker pads will have the same magnitude of motion, but a specific excitation mode
will determine the direction of the motion. In heave mode, all four shaker pads will move in the
same direction. In pitch mode, the front and rear tires will move in opposite directions. For roll
mode, the left and right tires have motion in opposite directions. When warp mode is specified,
the left front and right rear tires will move opposite to the direction traveled by the right front
and left rear tires. The different excitation modes are achieved by specifying a "1" or "-1"
multiplier at the beginning of the actuator function definition.
!---- Assign actuator functions based on excitation mode ----
!-Heave Excitation
if condition=("$excitation_mode" == "heave")
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_front_actuator &
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
actuator=$assembly.testrig.jms_right_front_actuator &
actuator=$assembly.testrig.jms_left_rear_actuator &

actuator=$assembly.testrig.jms_right_rear_actuator &
!-- Pitch Excitation
elseif condition=("$excitation_mode" == "pitch")
function="-1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
!-- Roll Excitation
elseif condition=("$excitation_mode" == "roll")
!-- Warp Excitation
elseif condition=("$excitation_mode" == "warp")

end
6XEPLWWLQJWKHDQDO\VLV
A common requirement of submitting the analysis to ADAMS/Solver is the existence of an
ADAMS dataset file (.adm) and an ADAMS command file (.acf). The two basic types of
analyses within ADAMS/Car are suspension and full-vehicle analyses. In both of these cases, a
utility macro is used to generate the ADM and ACF files and submit the analysis to
ADAMS/Solver. These utility macros are executed from within each of the suspension or
full-vehicle analysis macros.
After setting up the assembly, it is ready to be submitted for the four-post analysis. Since this is
a full-vehicle assembly, the corresponding full-vehicle submission utility macro is used. In this
case, two additional parameters are specified to have non-default values for the four-post
simulation: generate_road_geometry and simulation_type.
The code fragment for calling the four-post full-vehicle submission macro is shown, with the
important associated parameters described below.
!---- Perform the analysis ----
acme analysis full_vehicle four_post submit &
assembly=$assembly &
analysis_name="$’output_prefix’_fourpost" &
end_time=$end_time &
number_of_steps=$number_of_steps &
analysis_mode=$analysis_mode &
load_results=$load_results &
brief=$brief &
road_data_file="BEDPLATE" &
generate_road_geometry=no &
simulation_type=fourpost

Parameter descriptions:
■ assembly: This parameter expects the user to specify an existing model.
■ analysis_name: A string value indicating the name prefix for all files common to this
analysis.
■ end_time: A real value telling ADAMS/Solver the end time of the maneuver.
■ number_of_steps: An integer value telling ADAMS/Solver the number of output

steps.
■ analysis_mode: A string value to specify the mode of the analysis. The two valid
modes are interactive or background.
■ load_results: A string value that specifies if the results of the analysis should be read
in after the analysis is complete. Expected values are yes or no.
■ road_data_file: Hardcoded to BEDPLATE to indicate that the car will not be driven
across a road surface. ADAMS/Car will internally interpret and understand this
hardcoded value.
■ generate_road_geometry: Set to no to indicate that ADAMS/Car should not generate
a geometric representation of the data found in the road_data_file.
■ simulation_type: Hardcoded to fourpost to indicate that the full-vehicle will be
attached to a four-post shaker table. ADAMS/Car will internally interpret and
understand this hardcoded value to produce the correct .adm and .acf files.
/RJJLQJWKHDQDO\VLV
Many users consider it very important to generate a log describing the analysis that is
performed. Generation of the log file is important because it provides historical data that can be
stored along with the results of the analysis. The stored data can be useful and is sometimes
required to allow a user to regenerate the results of a particular analysis. These utility macros
are executed from within each of the suspension or full-vehicle analysis macros.
Utility macros exist that can be used within your custom analysis macro to generate a log file.
A utility macro exists for both suspension and full-vehicle analyses. With the analysis
completed, the results may be logged to a file. In addition, final diagnostic messages may be
displayed to the message window.

if condition=($log_file)
acar analysis full_vehicle log &
assembly=$assembly &
analysis_name="$’output_prefix’_fourpost" &
analysis_type="Four Post Shaker Test" &
analysis_log_file="$’output_prefix’_fourpost.log" &
comment=$comment &
end_time=$end_time &
number_of_steps=$number_of_steps &
road_data_file="BEDPLATE" &
initial_velocity=0.0 &
velocity_units="m_sec" &
input_parameters="general input" &
parameter_values=("$number_of_steps")
end
if condition=("$analysis_mode" != "background")
message="Simulation is complete."
end
)LQLVKLQJXS
Finally, it is important to ensure all local variables created in the macro using the $_self
nomenclature are deleted.
variable delete variable_name=(eval(db_children($_self,"variable"))


& $'$06&$5),/(6
■ ADAMS/Car Configuration Files, 260
■ ADAMS/Car Data Files, 260
259
■
$'$06&DU)LOHV
Table 3. ADAMS/Car Configuration Files
The file: Contains:
.acar.cfg Information that ADAMS/Car reads during startup to correctly

initialize the session. There are private, shared, and site
configuration files.
acar.cmd Commands for starting ADAMS/Car.
acarAS.cmd Preferences you set. The AS stands for After Startup, meaning
that ADAMS/Car reads it after it reads other setup files.
acarBS.cmd Preferences you set. The BS stands for Before Startup,

meaning that ADAMS/Car reads it before it reads other setup
files.
Table 4. ADAMS/Car Data Files
The file: Does the following:
Aero_force (.aer) Contains wind-force mappings.
Assembly (.asy) Lists the subsystems that make up ADAMS/Car assemblies.
Autoflex input Describes a section+centerline+attachment points (an

(.afi) extruded solid). The executable, afi2mnf.exe, processes the
file to create a modal neutral file (MNF) flexible body.
ADAMS/Car Directory that serves as the ADAMS/Car database.

database (.cdb)
Driver control Contains maneuver descriptions for the Driving Machine.

(.dcf)
Driver data (.dcd) Contains data for the Driving Machine.
Differential (.dif) Defines the slip speed-torque characteristics of a differential.
Driver loadcase Contains driving signals used in a data-driven, full-vehicle

(.dri) analysis. The driver loadcase specifies inputs to the vehicle.
Loadcase (.lcf) Contains data used in suspension analyses.
260 ADAMS/Car Files
■
$'$06&DU)LOHV
Table 4. ADAMS/Car Data Files (continued)
The file: Does the following:
Model (.mdl) Obsolete
Plot configuration Defines a suite of plots to be automatically generated after

(.plt) completion of an analysis.
Powertrain (.pwr) Defines the engine speed-torque relationship at different

throttle positions.
Property Contains force properties for the entities:

■ Bump stops (.bum)
■ Bushings (.bus)
■ Dampers (.dpr)
■ Reboundstop (.reb)
■ Spring (.spr)
■ Tire (.tir)
Road Data (.rdf) Contains data on road.
Subsystem (.sub) Contains information unique to the specific instance of the

template the subsystem file references.
Suspension curves Used in the Conceptual Suspension Modeling add-on

(.scf) module.
Steering_assist Contains torsion bar data relating torsion bar deflection to

(.ste) both torque and pressure.
Tables (.tbl) Subdirectory in the ADAMS/Car database called tables.

Each subdirectory contains files for specific types of
components, such as springs and dampers, or files for
performing tests, such as loadcases and wheel envelopes.
Template file (.tpl) Defines the topology and major role (for example,
suspension or steering) of ADAMS/Car models.
Wheel envelope Contains location vector information that represents the

(.wen) wheel center location and orientation in space. Used for
wheel envelope analyses.
ADAMS/Car Files 261
■
$'$06&DU)LOHV
262 ADAMS/Car Files

Tutorial MSC MD Adams R3

Uploaded by

Copyright:

Available Formats

Tutorial MSC MD Adams R3

Uploaded by

Document Information

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

Tutorial MSC MD Adams R3

Uploaded by

Copyright:

Available Formats

ADAMS/Car

Visit us at: www.adams.com

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

:HOFRPH WR $'$06&DU 7UDLQLQJ7

Welcome to ADAMS/Car training. In this course, you learn how to use

■ About Mechanical Dynamics, 9

■ Referencing Online Guides, 10

■ Getting Help at Your Job Site, 12

■ A Review of Basic ADAMS Terminology, 13

8 Welcome to ADAMS/Car Training

Give outline of class – module with workshop at end

Welcome to ADAMS/Car Training 9

10 Welcome to ADAMS/Car Training

Search and select text in Acrobat Reader:

Welcome to ADAMS/Car Training 11

■ Help tool on the Documentation Road Maps

12 Welcome to ADAMS/Car Training

The Knowledge Base is a database of solved problems/answered questions

Welcome to ADAMS/Car Training 13

14 Welcome to ADAMS/Car Training

This module discusses the advantages of using ADAMS/Car, as well as the

■ Database Structure—A Directory Hierarchy, 21

■ Workshop 1—Open and Run an Assembly, 23

Test lab Engine Advanced

Driveline Chassis Body

Test lab Engine Advanced

Driveline Chassis Body

:LWKLQWKH$'$06&DUFRQILJXUDWLRQILOH DFDUFIJ WKH

Here, the database is called “private”; cdb = car database.

You can set USERMODE to expert or standard

◆ To create a directory named acar, type mkdir acar.

◆ From the toolbar, select the ADAMS/Car tool .

For Step 3, tell students explicitly what path to use.

1 From the Review menu, select Animation Controls.

2 To animate the assembly, select the Play tool .

1 Change No Trace to Trace Marker.

1 Change Fixed Base to Base Part.

■ Bump Travel: 100

■ Rebound Travel: -100

1 From the Review menu, select Animation Controls.

1 Change No Trace to Trace Marker.

■ Major and Minor Roles, 33

■ Workshop 2—Templates versus Subsystems, 35

An assembly is just a list of pointers to subsystems and a test rig.

Subsystem File Creation

Default MacPherson Strut Template Specific Mass Properties

Suspension test rig assembled with

Suspension test rig alone

Explain symmetry (left and right)

Cut out some text and add a picture (low priority)

1 From the File menu, select Open.

1 From the File menu, select Save As.

The template is basically an ADAMS/View command file with a header.

Characteristic: Templates: Subsystems:

Used to define structure of model Yes No

An ADAMS/Car template is an ADAMS model built by an expert ADAMS/Car user in the

Make a new table

■ Adjusting Parameter Variables, 44

■ Adjusting Mass Properties, 45

■ Adjusting Springs and Dampers, 46

:HOFRPH WR $'$06&DU 7UDLQLQJ7

:LWKLQWKH$'$06&DUFRQILJXUDWLRQILOHDFDUFIJWKH

:KHQ\RXLPSRUWWKHDQDO\VLVUHTXHVWVILOHUHTLQ