Adams Car Analysis

Running Analyses
Using Adams/Car to analyze a virtual prototype is much like ordering a test of a physical prototype. You
specify the virtual prototype by opening or creating an assembly that contains the appropriate
components, or subsystems, that make up the prototype. For example, you create suspension assembly
containing suspension and steering subsystems and the suspension test rig.
In Adams/Car, you can run suspension and full-vehicle analyses.
214 Adams/Car
Running Suspension Analyses

You perform suspension analyses, which in Adams/Car are quasi-static equilibrium analyses, to learn
how a suspension controls the wheel motions and transmits load from the wheels to the chassis. To
perform a suspension analysis, you first create or open a suspension assembly that contains the selected
subsystems and the test rig. To create a suspension assembly, you can select any subsystem that has either
a suspension or a steering major role.
Using Adams/Car, you can:
• Easily modify the topology and the properties of the components of your suspension.
• Run a standard set of suspension and steering maneuvers.
• View suspension characteristics through plots. Learn about suspension characteristics.
For a suspension analysis, you can specify inputs to:

• Move the wheels through bump-rebound travel and measure the toe, camber, wheel rate, roll
rate, side-view swing-arm length, and other characteristics.
• Apply lateral load and aligning torque at the tire contact path and measure the toe change and
lateral deflection of the wheel.
• Rotate the steering wheel from lock to lock and measure the steer angles of the wheels and the
amount of Ackerman, which is the difference between the left and right wheel steer angles.
You specify the inputs to the analysis by typing them directly into an analysis dialog box or by selecting
a loadcase file that contains the desired inputs.
During the analysis, the test rig articulates the suspension assembly in the specified number of steps and
applies the inputs you specified. At each step, Adams/Car calculates over 38 suspension characteristics,
such as toe and camber angle, track change, wheel-base change, wheel rate (vertical stiffness), and fore-
aft wheel center stiffness. You can plot these characteristics and use them to determine how well the
suspension controls the motions of the wheels. Based on the results, you can alter the suspension
geometry or spring rates and analyze the suspension again to evaluate the effects of the alterations.
The following figure shows an overview of the suspension analysis process.
Running Analyses 215
Setting up Suspension Analyses

Before you submit a suspension analysis, you must set the Suspension Parameters that Adams/Car uses
when calculating suspension characteristics.
To set parameters:
1. From the Simulate menu, point to Suspension Analysis, and then select Set Suspension
Parameters.
2. Enter the necessary parameters as explained in the dialog box help for Suspension Analysis: Setup
Parameters.
3. Select OK.
To set up suspension analyses:

1. From the Simulate menu, point to Suspension Analysis, and then select the analysis you want to
set up.
2. Enter the vertical wheel travel and the other parameters needed to control the analysis.
3. Optionally, select one or more loadcase files (.lcf) from an Adams/Car database. Loadcase files
are text files that contain the vertical wheel travel and other parameters needed to control a
suspension analysis. If you regularly perform several kinds of suspension analyses using the same
ranges of travel, you should consider creating loadcase files for these. You can then submit all the
analyses without having to reenter travel parameters each time.
As you perform an analysis for which you did not create a loadcase file, Adams/Car temporarily
creates one for you and deletes it after the analysis.
4. Specify the number of Solution Steps in the analysis.
5. Select OK.
External-File Analyses
You can perform two types of external-file analyses:
• Loadcase Analysis
• Wheel-Envelope Analysis
Loadcase Analysis
A loadcase analysis reads the analysis inputs (for example, vertical wheel travel, steering travel, and
static loads) from one or more existing loadcase files. When you supply more than one loadcase file,
Adams/Car performs one analysis for each loadcase file. See an Example Suspension Loadcase File.
A loadcase analysis requires a suspension subsystem.
Each loadcase analysis produces a separate set of output files, such as .gra, .req, and .out.
216 Adams/Car
To set up a loadcase analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select External Files.
2. Enter the necessary parameters as explained in the dialog box help for External Files.
3. Select OK.
Wheel-Envelope Analysis
A wheel-envelope analysis generates wheel-center positions and orientations for use in packaging the
wheel/tire within the wheel well (fender). The analysis sweeps the wheels through their vertical and
steering travel in fixed increments based on information stored in a wheel-envelope input file (.wen). The
positions and orientations for the left and right wheel centers are output to a wheel-envelope output file
(.wev) for import into computer-aided design (CAD) packages. See an Example Wheel-Envelope Input
File and Example Wheel-Envelope Output File.
A wheel-envelope analysis requires suspension and steering subsystems.

A wheel-envelope input file has the same format as a static loadcase file, however, Adams/Car ignores
columns three through ten: left and right lateral force, aligning torque, brake force, and driving force.
You can create or modify wheel-envelope input files using the Curve Manager.
To set up a wheel-envelope analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select External Files.
2. Specify one or more wheel-envelope input files that define the vertical wheel and steering inputs.
3. Press F1 and then follow the instructions in the dialog box help for External Files.
4. Select OK.
Roll & Vertical Force Analysis

A roll and vertical force analysis sweeps the roll angle while holding the total vertical force constant. The
total vertical force is the sum of the vertical forces on the left and right wheels. You can specify the total
vertical force used by the left and right actuators to move the wheels.
In contrast to the opposite wheel-travel analysis, the roll and vertical force analysis allows the wheels to
seek their own vertical position.
To set up a roll & vertical force analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select Roll & Vertical Force.
2. Enter the necessary parameters as explained in the dialog box help for Suspension Analysis: Roll
& Vertical Force.
3. Select OK.
Static Load Analysis

Depending on the type of load you input, the static load analysis applies static loads to the spindle and
the tire contact patches between the specified upper and lower load limits. A static load analysis requires
a suspension subsystem.
To set up a static load analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select Static Load.
2. Enter the necessary parameters as explained in the dialog box help for Suspension Analysis: Static
Loads.
3. Select OK.
Steering Analysis
A steering analysis steers the wheels over the specified steering-wheel angle or rack travel displacement
from the upper to the lower bound. The application of steering motion results in a wheel displacement at
the specified wheel height.
A steering analysis requires a suspension and a steering subsystem.
To set up a steering analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select Steering.
2. Enter the necessary parameters as explained in the dialog box help for Suspension Analysis:
Steering.
3. Select OK.
Wheel-Travel Analyses
A wheel-travel analysis allows you to look at how the characteristics of a suspension change throughout
the vertical range of motion of the suspension.
You can perform three types of wheel-travel analyses. As a minimum, all wheel-travel analyses require
a suspension subsystem. These analyses can also include a steering subsystem.
• Opposite Wheel-Travel Analysis
• Parallel Wheel-Travel Analysis
• Single Wheel-Travel Analysis
The force limits for the left/right_vertical jack force are implemented as real numbers and are defaulted
to -2.0E+04 and 4.0E+04 Newton.
You can modify the force limits in the Template Builder using the actuator modify dialog box (because
actuators in Adams/Car are a topological element) or using the Command Navigator and modifying the
corresponding variables.
218 Adams/Car
For example, to modify the left-side actuator force limits from the default values in the Standard Interface
after having an assembly already opened, you go to: Tools -> Command Navigator -> Variable -> Modify.
In the Variable Modify dialog box, select the desired limit variable
(.assembly.testrig.jfl_jack_force.force_limits, in this case) and modify the values to the new force limits.
Opposite Wheel-Travel Analysis

An opposite wheel-travel analysis moves the left and right wheel through equal, but opposite, vertical
amounts of travel to simulate body roll. The left and right wheels move over the specified jounce and
rebound travel, 180o out of phase with each other. You specify the parameters to define the vertical wheel
travel and the fixed steer value when you submit the analysis.
To set up an opposite wheel-travel analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select Opposite Wheel
Travel.
2. Enter the necessary parameters as explained in the dialog box help for Opposite Wheel Travel
Analysis.
3. Select OK.
Parallel Wheel-Travel Analysis

A parallel wheel-travel analysis keeps the left wheel and right wheel heights equal, while moving the
wheels through the specified bump and rebound travel.
To set up a parallel wheel-travel analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select Parallel Wheel Travel.
Parallel Travel.
3. Select OK.
Single Wheel-Travel Analysis

A single wheel-travel analysis moves one wheel, either the right or left, through the specified jounce and
rebound travel while holding the opposite wheel fixed in a specified position.
To set up a single wheel-travel analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select Single Wheel Travel.
2. Enter the necessary parameters as explained in the dialog box help for Single Wheel-Travel
Analysis.
3. Select OK.
Computation of Suspension and Steering Characteristics

During suspension analyses, Adams/Car computes 38 different characteristics. The suspension and
steering characteristics that Adams/Car computes are based on the suspension geometry, the suspension
compliance matrix, or both. Suspension geometry refers to the position and orientation of suspension
parts relative to ground as the suspension is articulated through its ride, roll, and steer motions. For
example, the orientation of the spindle axes is used to compute the toe and camber angles.
The suspension compliance matrix refers to incremental movements of the suspension due to the
application of incremental forces at the wheel centers. Adams/Car computes the suspension compliance
matrix at each solution position as the suspension is articulated through its motion. Characteristics such
as suspension ride rate and aligning torque camber compliance are computed based on the compliance
matrix.
The suspension and steering characteristics are based on:
• Steer Axis Computation
• Definition of Compliance Matrix
Definition of Compliance Matrix

The compliance matrix for a system, [C], is defined as the partial derivatives of displacements with
respect to applied forces:
[C] = [∂X/∂F]
If a system is assumed to be linear, the compliance matrix can be used to predict the system movement
due to force inputs:
 X  =  C   F 
From this perspective, matrix element cij is the displacement of system degree of freedom i due to a unit
force at degree of freedom j.
Adams/Car uses a 12 x 12 matrix relating the motion of the left and right wheel centers to units forces
and torques applied to the wheel centers. This matrix has the form shown next:
220 Adams/Car
For example, element C(3,3) is the vertical motion of the left wheel center due to a unit vertical force
applied at the left wheel center. Element C(3,9) is the vertical motion of the left wheel center due to a unit
vertical force applied at the right wheel center. For an independent suspension without a stabilizer bar,
C(3,9) is zero since a vertical force on the right wheel will not cause motion of the left wheel. The other
elements of the compliance matrix are defined similarly.
Steer Axis Computation

Adams/Car needs the steer axis of a suspension to compute suspension characteristics, such as caster
angle, kingpin inclination, scrub radius, and caster moment arm or caster trail. When you create a
suspension template in Adams/Car, you must select the method Adams/Car will use to compute the steer
axis and provide the necessary input information.
Adams/Car offers two methods for calculating suspension steer axes:
• Geometric Method
• Instant Axes Method
Both methods give accurate results, but the instant axis method is more general, because it can be used
when the steer axis cannot be determined geometrically, such as in a five-link suspension. Currently, for
a new suspension template the default is the geometric method.
Geometric Method
Using the geometric method, Adams/Car calculates the steer axis by passing a line through two non-
coincident points located on the steer axis. To use the geometric method, you must identify a part or parts
and two hardpoints that fix the steer axis.
For example, in a double wishbone suspension you might identify the wheel carrier part and Hardpoints
located at the upper and lower ball joints. For a MacPherson strut suspension, you might identify the
wheel carrier part and a hardpoint located at the lower ball joint for one point, and the strut rod and a
hardpoint located where the strut attaches to the body for the second point.
Instant Axes Method

Using the instant axes 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 in all directions (3 forces and 3 torques). 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.
To use the instant axes method, you must identify a part and a hardpoint where Adams/Car should lock
the spring travel. Adams/Car locks the spring travel by locking the vertical motion of the part you identify
at the chosen hardpoint location. You can use any part and hardpoint, provided that locking the vertical
motion of that part at that location locks the spring travel. For example, in suspensions using coil or leaf
springs, a good choice is the lower spring seat (such as, the part and hardpoint where the spring acts on
the suspension). For a double wishbone suspension sprung by a torsion bar on the lower control arm,
choose the lower control arm at its connection to the wheel carrier. Locking the vertical motion of the
lower control arm at this location eliminates rotation in the torsion bar. Do not choose the wheel center
location and wheel carrier. If you do, Adams/Car calculates inaccurate steer axes.
In almost all suspensions, the wheel center lies outboard of the steer axis and the steer axis is angled
rearward (caster angle > 0) and inward (kingpin inclination > 0) relative to vertical. When the wheels are
steered (for example, rotated about the steer axis), the motion of the wheel centers has a vertical
component. Locking the vertical motion of the wheel carrier at the wheel center eliminates this vertical
component and gives an inaccurate steer axis.
When no steering subsystem is present, the steer axis that the instant axis method calculates is typically
inaccurate for a steerable suspension because the inner tie rods attach to ground and are not free to move
laterally. Therefore, when a steering subsystem is present, the motion Adams/Car excites by applying an
aligning torque to the wheel carrier is not comparable to the steering motion.
Dynamic Analysis
A dynamic analysis actuates the suspension at the contact patch via user defined runtime function
expressions or by referencing existing RPC3 files.
It is also possible to define a runtime function expression for the steering motion, therefore combining
vertical excitation with steering sweeps.
222 Adams/Car
Note that the Computation of Suspension and Steering Characteristics is currently not available for
dynamic suspension analyses.
To set up a dynamic analysis:

1. From the Simulate menu, point to Suspension Analysis, and then select Dynamic.
Dynamic.
3. Select OK.
Example Suspension Loadcase File

In Adams/Car, you can use loadcase files to specify different types of suspension analyses. The following
is an example loadcase file.
$-----------------------------------------------MDI_HEADER
[MDI_HEADER]
FILE_TYPE = 'lcf'
FILE_VERSION = 4.0
FILE_FORMAT = 'ASCII'
$-----------------------------------------------UNITS
[UNITS]
LENGTH = 'mm'
ANGLE = 'degrees'
FORCE = 'newton'
MASS = 'kg'
TIME = 'second'
$
$Generation Parameters: (Do Not Modify!)
$ loadcase = 1
$ nsteps = 10
$ bump_disp = 100.00 rebound_disp = -100.00
$ steering_input = angle
$ stat_steer_pos = 0.00
$
$-----------------------------------------------mode
[MODE]
STEERING_MODE = 'angle'
VERTICAL_MODE = 'length'
$-----------------------------------------------data
[DATA]
$COLUMN: input type: type of input data: side:
$ (c1) wheel z disp / force left
$ (c2) wheel z disp / force right
$ (c3) lateral force (y) left
$ (c4) lateral force (y) right
$ (c5 aligning torque (z-axis) left
$ (c6) aligning torque (z-axis) right
$ (c7) brake force (y) left
$ (c8) brake force (y) right
$ (c9) driving force (y) left
$ (c10) driving force (y) right
$ (c11) steering force / steer angle / rack travel
{ whl_z_l whl_z_r lat_l lat_r align_l align_r brake_l brake_r drive_l drive_r steer}
-100.0000 -100.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
-80.0000 -80.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
-60.0000 -60.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
-40.0000 -40.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
-20.0000 -20.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.000
20.0000 20.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
40.0000 40.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
60.0000 60.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
80.0000 80.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
100.0000 100.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
Example Wheel-Envelope Input File

The following is an example of a wheel-envelope input file (.wen) that you can use to control a wheel-
envelope analysis.
Note: For wheel-envelope input files, Adams/Car ignores columns three through ten: (left and
right) lateral force, aligining torque, brake force, and driving force.
$--------------------------------------------MDI_HEADER
[MDI_HEADER]
FILE_TYPE = 'wen'
FILE_VERSION = 5.0
FILE_FORMAT = 'ascii'
$--------------------------------------------UNITS
[UNITS]
LENGTH = 'mm'
FORCE = 'newton'
ANGLE = 'deg'
MASS = 'kg'
TIME = 'sec'
$--------------------------------------------MODE
[MODE]
STEERING_MODE = 'angle'
VERTICAL_MODE = 'length'
$--------------------------------------------GRID
[GRID]
BOUNDARY_STEERING_GRID = 100.0
BOUNDARY_WHEEL_GRID = 20.0
INTERIOR_STEERING_GRID = 100.0
INTERIOR_WHEEL_GRID = 20.0
$--------------------------------------------DATA
[DATA]
$COLUMN: input type: type of input data: side:
$ (c1) wheel z disp / force left
$ (c2) wheel z disp / force right
$ (c3) lateral force (y) left
$ (c4 lateral force (y) right
$ (c5) aligning torque (z-axis) left
$ (c6) aligning torque (z-axis) right
$ (c7) brake force (y) left
$ (c8 brake force (y) right
$ (c9) driving force (y) left
224 Adams/Car
$ (c10) driving force (y) right

$ (c11) steering steer angle / rack travel
$ {whl_z_l whl_z_r lat_l lat_r align_l align_r brake_l brake_r
drive_l drive_r steer}
-120.0 -120.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -500.0
80.0 80.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -500.0
90.0 90.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -300.0
120.0 120.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 -200.0
120.0 120.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 200.0
85.0 85.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 350.0
80.0 80.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 500.0
60.0 60.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 500.0
30.0 30.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 450.0
-30.0 -30.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 450.0
-75.0 -75.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 500.0
-120.0 -120.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 500.0
Example Wheel-Envelope Output File

A wheel-envelope output file (.wev) contains a header and a data table, as explained next.
The first three lines comprise the header and contain the following information, in this order:
• Type of file
• Adams dataset title
• Date and time of file creation
The table that follows the header contains the following information:
• The first column shows the solution step number
• Columns 2-4 show the data for the left wheel center x, y, z
• Columns 5-7 show the data for the left wheel axis point x, y, z
• Columns 8-10 show the data for the right wheel center x, y, z
• Columns 11-13 show the data for the right wheel axis point x, y, z
The following is an example of a wheel-envelope output file:

Adams/Car Wheel Envelope Analysis Output File - acar_v10.0
Adams/Car Assembly
2000-01-19 16:41:21
1 -4.2702 -673.57 205.00 -348.83 -1611.7 170.29 7.0293 670.69 205.00 303.63 1620.7 107.88
2 -4.6463 -681.45 225.00 -344.63 -1621.7 206.15 6.7629 678.55 225.00 307.97 1628.3 139.91
3 -4.9532 -687.82 245.00 -340.16 -1630.0 239.60 6.5706 684.92 245.00 311.28 1634.4 170.26
4 -5.2433 -692.82 265.00 -334.67 -1637.0 271.40 6.3755 689.93 265.00 314.35 1639.0 198.89
5 -5.5240 -696.55 285.00 -328.07 -1643.0 301.70 6.1779 693.66 285.00 317.43 1642.1 225.76
6 -5.7905 -699.08 305.00 -320.38 -1648.0 330.44 5.9864 696.18 305.00 320.67 1643.8 250.76
7 -6.0372 -700.45 325.00 -311.59 -1652.1 357.51 5.8099 697.55 325.00 324.25 1644.1 273.76
8 -6.2583 -700.71 345.00 -301.72 -1655.3 382.78 5.6583 697.79 345.00 328.31 1643.0 294.55
9 -6.4469 -699.89 365.00 -290.74 -1657.8 406.03 5.5424 696.93 365.00 333.04 1640.3 312.88
10 -6.5953 -698.01 385.00 -278.64 -1659.4 426.98 5.4752 695.00 385.00 338.63 1636.2 328.39
... .......
226 Adams/Car
Output of Suspension Analyses

Adams/Car analyses output the following general suspension characteristics for all suspensions:
• Aligning Torque - Steer and Camber Compliance
• Camber Angle
• Caster Angle
• Dive Braking/Lift Braking
• Fore-Aft Wheel Center Stiffness
• Front-View Swing Arm Length and Angle
• Kingpin Inclination Angle
• Lateral Force - Deflection, Steer, and Camber Compliance
• Lift/Squat Acceleration
• Percent Anti-Dive Braking/Percent Anti-Lift Braking
• Percent Anti-Lift Acceleration/Percent Anti-Squat Acceleration
• Ride Rate
• Ride Steer
• Roll Camber Coefficient
• Roll Caster Coefficient
• Roll Center Location
• Roll Steer
• Side-View Angle
• Side-View Swing Arm Length and Angle
• Suspension Roll Rate
• Toe Angle
• Total Roll Rate
• Wheel Rate
For steered suspensions, Adams/Car analyses also output the following steering characteriscs:
• Ackerman
• Ackerman Angle
• Ackerman Error
• Caster Moment Arm (Mechanical Trail)
• Ideal Steer Angle
• Outside Turn Diameter
• Percent Ackerman
• Scrub Radius
• Steer Angle
• Steer Axis Offset

• Turn Radius
Aligning Torque - Steer and Camber Compliance
Note: This help file is shared by several Adams products.
Description The aligning torque steer compliance is the change in steer angle due to unit
aligning torque on the wheel. The aligning torque camber compliance is the
change in camber angle due to a unit aligning torque on the wheel.
A positive aligning torque acts to steer the wheel to the left. For a positive
steer angle, the wheel turns to the left. For a positive camber angle, the top
of the wheel tilts away from the body.
Units degrees/(force*length)
Request Names • alt_steer_compliance.left
• alt_steer_compliance.right
• alt_camber_compliance.left
• alt_camber_compliance.right
Method alt_steer_compliance.left = C(6,6) + C(6,12)
alt_steer_compliance.right = C(12,6) + C(12,12)
alt_camber_compliance.left = C(4,6) + C(4,12)
alt_camber_compliance.right= -C(10,6) + C(10,12)
Figure 1 Aligning Torque Loading for Steer and Camber

Compliances
228 Adams/Car
Camber Angle
Description Camber angle is the angle the wheel plane makes with respect to the vehicle's
vertical axis. It is positive when the top of the wheel leans outward from the
vehicle body.
Note that the inclination angle, a measurement available in full-vehicle analyses,

is the angle the wheel plane makes with respect to the road surface. The inclination
angle is used for tire calculations.
Units Degrees or angle
Request Names • camber_angle.left
• camber_angle.right
Inputs Wheel-center axis (spin axis) unit vectors, left and right
Method camber_angle = -arcsin  Sˆ Ẑ 
Figure 2 Camber Angle
Caster Angle

Description Caster angle is the angle in the side elevation (vehicle XZ plane) between the
steering (kingpin) axis and the vehicle's vertical axis. It is positive when the
steer axis is inclined upward and rearward.
Adams computes the steer axis using the geometric or instant axis method.
Units Degrees
Request Names • caster_angle.left
• caster_angle.right
Inputs • Steer (kingpin) axis unit vectors - left and right
• Road vertical unit vector (z)
• Road longitudinal unit vector (x)
Method Adams uses the direction cosines in the x- and the z-directions of the kingpin
axis to calculate caster angle, such that:
sx = steer_axis road_x_axis
sz = steer_axis road_z_axis
caster_angle = rtod * arctan(sx/sz)
Figure 3 Caster Angle
Dive Braking/Lift Braking

230 Adams/Car
Description Dive braking is the amount of front suspension compression per G of vehicle
braking. Included in dive is suspension compression due to weight transfer plus
suspension extension due to brake forces. Positive dive indicates that the front
suspension compresses in braking.
Lift braking is the amount of rear suspension extension per G of vehicle braking.
Included in lift is suspension extension due to weight transfer plus compression
due to brake forces. Positive lift indicates that the rear suspension extends in
braking.
Units mm
Request Names • dive.left
• dive.right
Inputs • Compliance matrix

• Fraction of braking applied at this axle
• Loaded tire radius
• Tire stiffness
• Whole vehicle CG height
• Total vehicle weight
• Wheelbase
Method Adams first computes the longitudinal force percentage due to braking:
Fleft = Fright = Brake Ratio / 2.0

and then the vertical force percentange due to weight transfer:
Wleft = Wright = Whole vehicle CG height/ (2 x

Wheelbase)
For rear anti-lift, the weight transfer is a negative value.
These are forces at each wheel per unit total braking force.
Vertical deflections due to the vertical force are:
Zwleft = Wleft x C(3,3) + Wright x C(3,9)

Zwright = Wleft x C(9,3) + Wright x C(9,9)
Vertical deflections due to tractive forces are as follows, where Rl is the loaded
radius of the tire:
ZFleft = Fleft [C(3,1) - Rl x C(3,5)] +

Fright[C(3,7) - Rl x C(3,11)]
ZFright = Fleft [C(9,1) - Rl x C(9,5)] +
Fright[C(9,7) - Rl x C(9,11)]
The dive is:
dive.left = (ZFleft + ZWleft + Wleft / Kt) Vehicle

Weight
dive.right = (ZFright + ZWright + Wright / Kt)
Vehicle Weight
Fore-Aft Wheel Center Stiffness

232 Adams/Car
Description The stiffness of the suspension in the fore-aft direction is relative to the body,
measured at the wheel center.
Units Newtons/mm
Request Names • fore_aft_wheel_center_stiffness.left
• fore_aft_wheel_center_stiffness.right
Inputs Compliance matrix
Method Adams applies equal unit forces acting longitudinally at the wheel centers. It
calculates the fore-aft wheel center stiffness as follows:
fore_aft_wheel_center_stiffness.left = 1 /
C(1,1)
fore_aft_wheel_center_stiffness.right = 1 /
C(7,7)
Front-View Swing Arm Length and Angle
Description The swing arm is the imaginary arm extending from the wheel's front elevation
instant center of rotation to the wheel center. The swing arm has a positive
length when the instant center is inward of the wheel center. The angle of the
swing arm is the angle it makes to the horizontal. A positive angle is when the
arm slopes outward and upward from the center of rotation to the wheel center.
The magnitude of the swing-arm length is limited to a maximum of 1000 meters.

Units Length - mm; angle - degrees
Request Names • fr_view_swing_arm_angle.left
• fr_view_swing_arm_angle.right
• fr_view_swing_arm_length.left
• fr_view_swing_arm_length.right
Method The change in vertical and lateral position and the front view rotation of the left
wheel center due to a unit vertical force at the left wheel center is:
Y left = C  2, 3 
Z left = C  3, 3 
 left = C  4, 3 
The left front view swing arm length and angle are:
2 2 12
fr_view_swing_arm_length.left = –  Y left + Z left    left
–1
fr_view_swing_arm_angle.left = – tan  Y  Z left 
left
The change in vertical and lateral position and the front view rotation of the right
wheel center due to a unit vertical force at the right wheel center is:
Y right = C  8, 9 
Z right = C  9, 9 
 right = C  10, 9 
234 Adams/Car
The right front view swing arm length and angle are:
2 2 12
fr_view_swing_arm_length.right =  Y right + Z right    right
–1
fr_view_swing_arm_angle.right = tan   Y right    Z right  
Figure 4 Instant Center Front View (Lateral, Vertical)
Kingpin Inclination Angle
Description The kingpin inclination angle is the angle in the front elevation between the steer
axis (the kingpin axis) and the vehicle's vertical axis. It is positive when the steer
axis is inclined upward and inward.
Units Degrees
Request Names • kingpin_incl_angle.left
• kingpin_incl_angle.right
Inputs Kingpin axis unit vectors - left and right

Method Adams uses the direction cosines in the y-direction and the z-direction of the kingpin
axis to calculate the kingpin inclination angle:
–1
kingpin_incl_angle.left = tan  DCOSY  DCOSZ 
–1
kingpin_incl_angle.right = tan  – DCOSY  DCOSZ 
Figure 5 Kingpin Angle (Ø is the Kingpin Angle)
Lateral Force - Deflection, Steer, and Camber Compliance
Description The deflections at the wheel center due to unit lateral forces applied simultaneously at
the tire contact patches. The forces are oriented as if in a right turn. Adams reports the
lateral translational deflection, steer deflection (rotational deflection about the vertical
axis), and the camber deflection (rotational deflection about the longitudinal axis).
Positive deflection indicates a deflection to the right. Positive steer is a steer to the left.
Positive camber compliance is when the wheels lean outward at the top.
Units Deflection - mm; Camber and steer - degrees
236 Adams/Car
Request • lat_force_defl_compliance.left
Names • lat_force_defl_compliance.right
• lat_force_steer_compliance.left
• lat_force_steer_compliance.right
• lat_force_camber_compliance.left
• lat_force_camber_compliance.right
• Tire radius - loaded
Method When the force is applied at the tire contact patch, Adams computes the deflection due
to both the lateral force at the wheel center and the moment created around the wheel
center. The total compliances are:
lat_force_defl_compliance.left = +[C(2,2) + Rl x C(2,4) + C(2,8) + Rl x C(2,10)]
lat_force_defl_compliance.right = +[C(8,2) + Rl x C(8,4) + C(8,8) + Rl x C(8,10)]
lat_force_steer_compliance.left = +[C(6,2) + Rl x C(6,4) + C(6,8) + Rl x C(6,10)]
lat_force_steer_compliance.right = +[C(12,2) + Rl x C(12,4) + C(12,8) + Rl x C(12,10)]
lat_force_camber_compliance.left = +[C(4,2) + Rl x C(4,4) + C(4,8) + Rl x C(4,10)]
lat_force_camber_compliance.right = -[C(10,2) + Rl x C(10,4) + C(10,8) + Rl x C(10,10)]
Figure 6 Lateral Force Loading for Deflection, Steer, and Camber

Compliances
Lift/Squat Acceleration
Description Lift is the amount of front suspension extension (rebound) per G of vehicle
acceleration. Squat is the amount of rear suspension compression (jounce) per
G of vehicle acceleration. Lift and squat arise when the suspension reacts to
longitudinal tractive forces, weight transfer forces, and, in dependent
suspensions, to the differential input and output torques.
Units mm
Request Names Front suspensions:
• lift.left
• lift.right
Rear suspensions:
• squat_acceleration.left
• squat_acceleration.right
Suspension parameters array:
• suspension_type (independent/dependent)
Vehicle parameters array:
• sprung_mass
• cg_height
• wheelbase
• loaded_tire_radius
• tire_stiffness
• axle_ratio (final drive ratio, pinion ring gear ratio)
• drive_ratio (fraction of total drive torque directed to the suspension)
Suspension geometry:
• Track
Acceleration due to gravity (Ag)
238 Adams/Car
Method The suspension lift or squat during acceleration arises due to the tractive forces,
weight transfer, and, in live axles, due to the differential input and output
torques, as well. The longitudinal tractive forces at the tire contact patches are:
Fleft = Fright = -drive_ratio / 2.0

The vertical forces at the tire contact patch due to weight transfer are:
VWleft = VWright = - cg_height / (2 * Wheelbase)

Live axles also react to the drive torques (input torque to the differential pinion
and the left and right output torque from the differential). Given the longitudinal
tractive forces, the input torque (TI) to the differential is:
TI = tire_loaded_radius * abs(Fleft + Fright) / axle_ratio

And the vertical force at the tire contact patches due to the drive torque is:
VTleft = -VTright = TI / Track

The left and right output torque from the differential is:
TOleft = - tire_loaded_radius * Fleft

TOright = - tire_loaded_radius * Fright
The vertical deflections of the suspension due to drive torque are:
ZDleft = VTleft * C(3,1) + TOleft * C(3,5) + VTright

* C(3,7) + TOright * C(3,11) + VTleft /
tire_stiffness
ZDright = VTleft * C(9,1) + TOleft * C(9,5) +
VTright * C(9,7) + TOright * C(9,11) + VTright /
tire_stiffness
Independent suspensions do not react to the drive torques. Therefore,
ZDleft = ZDright = 0.0

The vertical deflections of the suspension due to tractive forces are:
ZFleft = Fleft * C(3,1) + Fright * C(3,7)

ZFright = Fright * C(9,7) + Fleft * C(9,1)
The vertical deflections of the suspension due to weight transfer forces are:
ZWleft = VWleft C(3,3) + VWright C(3,9) + VWleft /

tire_stiffness
ZWright = VWleft C(9,3) + VWright C(9,9) + VWright /
tire_stiffness
Finally, the lift/squat per G of acceleration is:
lift.left / squat_acceleration.left = (ZDleft + ZFleft + ZWleft) * sprung_mass * Ag
lift.right / squat_acceleration.right = (ZDright

+ ZFright + ZWright) * sprung_mass * Ag
Percent Anti-Dive Braking/Percent Anti-Lift Braking
Description Percent anti-dive braking for a front suspension and percent anti-lift braking for a
rear suspension are the ratio of vertical suspension deflections caused by braking
forces and torques to the deflections caused by weight transfer. During braking,
the vertical deflections in a suspension from weight transfer can, in part, be
cancelled by the vertical deflections caused by braking forces and torques in the
suspension. Suspensions that exhibit this characteristic are said to have anti-dive
or anti-lift geometry.
For front suspensions, percent anti-dive braking is positive when deflections

caused by braking forces and torques act to extend or rebound the suspension. For
rear suspensions, percent anti-lift braking is positive when the deflections caused
by the braking forces and torques act to compress or jounce the suspension.
Units %
• anti_dive_braking.left
• anti_dive_braking.right
Rear suspensions:
• anti_lift.left
• anti_lift.right
240 Adams/Car
• sprung_mass
• cg_height
• wheelbase
• tire_stiffness
• brake_ratio (fraction of braking done by the suspension)
• acceleration due to gravity (Ag)
Method The brake forces at the tire contact patch per G of longitudinal deceleration are:
Fleft = Fright = sprung_mass * Ag * brake_ratio / 2

The brake torques reacted that the suspension reacts to are:
BTleft = loaded_tire_radius * Fleft

BTright = loaded_tire_radius * Fright
The weight transfer forces that the suspension reacts to are:
WTleft = sprung_mass * Ag * cg_height / wheelbase /

2
WTright = sprung_mass * Ag * cg_height / wheelbase
/ 2
The brake forces and torques that cause the suspension deflections are:
ZBleft = Fleft * C(3,1) + Fright * C(3,7) + BTleft *

C(3,5) + BTright * C(3,11) + Fleft / tire_stiffness
ZBright = Fleft * C(9,1) + Fright * C(9,7) + BTleft *
C(9,5) + BTright * C(9,11) + Fright / tire_stifness
The weight transfer forces that cause the suspension deflections are:
ZWleft = WTleft * C(3,3) + WTright * C(3,9) + WTleft

/ tire_stiffness
ZWright = WTleft * C(9,3) + WTright * C(9,9) +
WTright / tire_stiffness
Finally, the percent anti-dive and percent anti-lift are:
anti_dive_braking.left = anti_lift.left = 100 *

ZBleft / ZWleft
anti_dive_braking.right = anti_lift.right = 100 *
ZBright / ZWright
Percent Anti-Lift Acceleration/Percent Anti-Squat Acceleration
Description Percent anti-lift for a front suspension and percent anti-squat for a rear
suspension are the ratio of vertical suspension deflections caused by tractive
forces and drive torques to the deflections caused by weight transfer. During
acceleration, the vertical deflections in a suspension from weight transfer can,
in part, be cancelled by the vertical deflections caused by tractive forces and
drive torques in the suspension. Suspensions that exhibit this characteristic
are said to have anti-lift or anti-dive geometry. Note that a suspension that
does not transmit tractive forces and drive torques (drive_ratio = 0.0) has zero
anti-lift or anti-squat.
For front suspensions, percent anti-lift is positive when deflections caused by

tractive forces and drive torques act to compress or jounce the suspension. For
rear suspensions, percent anti-squat is positive when the deflections caused by
the tractive forces and drive torques act to extend or rebound the suspension.
Units %
• anti_lift.left
• anti_lift.right
Rear suspensions:
• anti_squat.left
• anti_squat.right
242 Adams/Car
Suspension parameters array:
• suspension_type (independent/dependent)
• sprung_mass
• cg_height
• wheelbase
• tire_stiffness
• axle_ratio (final drive ratio, pinion ring gear ratio)
• drive_ratio (fraction of total drive torque directed to the suspension)
Suspension geometry:
• Track
Acceleration due to gravity (Ag)
Method The longitudinal tractive forces at the tire contact patches are:
Fleft = Fright = -drive_ratio / 2.0

The vertical forces at the tire contact patch due to weight transfer are:
VWleft = VWright = - cg_height / (2 * Wheelbase)

Live axles also react with the drive torques (input torque to the differential
pinion and output torque from the differential). Given the longitudinal tractive
forces, the input torque (TI) to the differential is:
TI = tire_loaded_radius * abs(Fleft + Fright) /

axle_ratio
And the vertical force at the tire contact patches due to the drive torque is:
VTleft = -VTright = TI / Track

The left and right output torque from the differential is:
TOleft = - tire_loaded_radias * Fleft

TOright = - tire_loaded_radias * Fright
The vertical deflections of the suspension due to drive torque are:
ZDleft = VTleft * C(3,1) + TOleft * C(3,5) +

VTright * C(3,7) + TOright * C(3,11) + VTleft /
tire_stiffness
ZDright = VTleft * C(9,1) + TOleft * C(9,5) +
VTright * C(9,7) + TOright * C(9,11) + VTright /
tire_stiffness
Independent suspensions do not react to the drive torque. Therefore,
ZDleft = ZDright = 0.0

The vertical deflections of the suspension due to tractive forces are:
ZFleft = Fleft * C(3,1) + Fright * C(3,7)

ZFright = Fright * C(9,7) + Fleft * C(9,1)
The vertical deflections of the suspension due to weight transfer forces are:
ZWleft = VWleft C(3,3) + VWright C(3,9) + VWleft /

tire_stiffness
ZWright = VWleft C(9,3) + VWright C(9,9) + VWright
/ tire_stiffness
The left and right percent anti-lift for front suspensions and percent anti-squat for rear
suspensions are:
anti_lift.left / anti_squat.left = 100 *

(ZFleft + ZDleft) / ZWleft
anti_lift.right / anti_squat.right =100 *
(ZFright + ZDright) / ZWright
244 Adams/Car
Ride Rate
Description Ride rate is the spring rate of the suspension relative to the body, measured at the
tire contact patch.
Units Newtons/mm
Request Names • ride_rate.left
• ride_rate.right
• Tire stiffness
Method Adams computes ride rate as the equivalent rate of the wheel rate and tire rate in
series.
Ks = Wheel rate (see Wheel Rate)

Kt = Vertical tire rate
Ktotal = Ks x Kt / (Ks + Kt)
Ride Steer
Description Ride steer is the slope of the steer angle versus the vertical wheel travel curve. Ride
steer is the change in steer angle per unit of wheel center vertical deflection due to
equal vertical forces at the wheel centers. Positive ride steer implies that the
wheels steer to the right, as the wheel centers move upward.
Units Degrees/mm
Request Names • ride_steer.left
• ride_steer.right

Method Change in Wheel Orientation
Using the compliance matrix, Adams first calculates the change in wheel
orientation (W) due to unit forces applied at both wheel centers:
Wl/dF = C(4, 3) - C(4, 9) , C(5, 3) - C(5, 9) , C(6, 3)

- C(6, 9)
Wr/dF = C(10, 3) - C(10,9) , C(11, 3) - C(11, 9) ,
C(12, 3) - C(12,9)
Change in Wheel-Center (Spin) Vector Orientation

The change in the left wheel-center (spin) vector (d(wcvl)) and the right wheel
(spin) vector (d(wcvr) are vectors of partial derivatives given by the cross product
of the change in wheel orientation with the wheel-center vector:
d(wcvl)/dF = Wl x wcvl
d(wcvr)/dF = Wr x wcvr
Change in Steer Angle
The change in steer angle due to a change in wheel-center vector orientation is also
a vector of partial derivatives given by:
d(steer_anglel)/d(wcvl) = (-1.0 / ( syl**2 +

sxl**2 ) ) { syl, -sxl, 0 }
d(steer_angler)/d(wcvr) = (-1.0 / ( syr**2 +
sxr**2 ) ) { syr, -sxr, 0 }
where:
sxl = wcvl o x; The x component of the left wheel-

center (spin) vector
syl = wcvl o y; The y component of the left wheel-
center (spin)
vector\sxr = wcvr o x; The x component of the
right wheel-center (spin) vector
syr = wcvr o y; The y component of the right
wheel-center (spin) vector
The change in steer angle due to unit vertical forces at both wheel centers is
computed by the chain rule:
d(steer_anglel) /dF = ( -d(steer_anglel)/d(wcvl)

) o ( d(wcvl) / dF )
d(steer_angler)/dF = ( -d(steer_angler)/d(wcvr) )
o ( d(wcvr) / dF )
246 Adams/Car
Change in Wheel-Center Vertical Travel

The change in wheel-center vertical travel (dz) due to unit vertical forces applied
at both wheel centers is:
dzl /dF = { C(3,3) + C(3,9) }

dzr /dF = { C(9,3) + C(9,9) }
Using the chain rule one final time, the ride steer is:
ride_steer.left = d(steer_anglel)/dzl =
d(steer_anglel)/dF/(dF/dzl)
ride_steer.right = d(steer_angler)/dzr =
d(steer_angler)/dF/(dF/dzr)
Nomenclature • Bold, uppercase text, such as Wl, are vectors.
• Bold, lowercase text, such as wcvl, are unit vectors.
• X is the vector cross product operator.
• o is the vector dot product operator.
• * is the scalar multiplication operator.
Roll Camber Coefficient
Description Roll camber coefficient is the rate of change of wheel inclination angle with
respect to vehicle roll angle. Positive roll camber coefficient indicates an increase
in camber angle per degree of vehicle roll.
Units Unitless
Request Names • roll_camber_coefficient.left
• roll_camber_coefficient.right

• Tire stiffness
• Track width
Method Adams applies opposing unit forces acting vertically at the tire contact patches.
The height difference between the tire contact patches is the following, where Kt
is the vertical tire rate:
DZ = C(3,3) - C(3,9) - C(9,3) + C(9,9) + 2/Kt

The vehicle roll angle is the rotation of the line through the tire contact patches:
Av = DZ / track
Adams measures the wheel inclination with respect to the line through the tire
contact patches, which has two components. The first is from the vertical
movement of the tire contact patch and is the same as the vehicle roll angle. The
second is from the rotational compliance at the wheel center due to the vertical
force:
Ac = - C(4,3) + C(4,9) (left side)

= - C(10,3) + C(10,9) (right side)
The total wheel inclination is then:
Ai = Av - Ac
The roll camber is then:
roll_camber_coefficient = (Av - Ac) / Av = 1 - Ac / Av
Figure 7 Roll Camber

248 Adams/Car
Roll Caster Coefficient
Description Roll caster coefficient is the rate of change in side view steer axis angle
with respect to vehicle roll angle. A positive roll caster coefficient indicates
an increase in caster angle per degree of vehicle roll.
This calculation assumes that the steer axis (kingpin) is fixed in the
suspension upright as in a double-wishbone or MacPherson strut
suspension. The calculation, however, is not valid for suspensions where
the steer axis is not fixed in the suspension upright, for example, a five-link
front suspension used in Audi A4.
Units Unitless
Request Names • roll_caster_coefficient.left
• roll_caster_coefficient.right
• Tire stiffness
• Track width
Method Adams applies opposing unit forces acting vertically at the tire contact
patches. The height difference between the tire contact patches is the
following, where Kt is the vertical tire rate:
DZ = C(3,3) - C(3,9) - C(9,3) + C(9,9) + 2/Kt

The vehicle roll angle is the rotation of the line through the tire contact
patches:
Av = DZ / track
The rotational compliance at the wheel center due to the vertical force is:
Ac = C(5,3) - C(5,9) (left side)

= C(11,3) - C(11,9) (right side)
The roll caster is then:
roll_caster_coefficient = Ac / Av
Roll Center Location

Description Roll center location is the point on the body where the moment of the
lateral and vertical forces exerted by the suspension links on the body
vanishes.
Units
Request Names • roll_center_location.lateral_from_half_track
• roll_center_location.vertical
• roll_center_location.lateral_to_left_patch
• roll_center_location.lateral_to_right_patch
250 Adams/Car
Inputs • Compliance matrix at contact patches

• Contact patch location
Method Adams applies unit vertical forces (perpendicular to the road) at the tire
contact and measures the resulting contact patch displacements in the
vertical and lateral direction (front view). Adams projects lines
perpendicular to the contact patch displacements for both the left and right
patches. The roll center lies at the intersection of these lines.
Adams reports errors when the motions of the left and right patches are
parallel (just as it occurs with a fully trailing arm suspension). Therefore,
the projected lines have no intersection. Adams also reports an error when
the motion of the left and/or right patches is very small for a unit vertical
force (for example, the suspension is very stiff).
Finally, Adams limits the distance from the roll center to the left and right
patches to +/- 1000 meters.
Figure 8 Roll Center Location (Front View)
Roll Steer

Description Roll steer is the change in steer angle per unit change in roll angle, or the slope of
the steer-angle-verses-roll-angle curve. Roll steer is positive when for increasing
roll angle (left wheel moving up, right wheel moving down) the steer angle increases
(wheels steer toward the left).
Units Unitless
Request Names • roll_steer.left
• roll_steer.right
Inputs • Wheel center spin axis unit vector (wcv) left and right
• Track
• Tire stiffness (Kt)
• Compliance matrix
252 Adams/Car
Method Using the compliance matrix, Adams first calculates the change in roll angle and the
change in the wheel-center vector orientation due to a roll moment (the roll moment
is a unit vertical force upward at the left contact patch and a unit force downward at
the right contact patch). Then, Adams calculates the change in steer angle due to the
change in wheel-center vector orientation. Finally, Adams applies the chain rule to
calculate the roll steer.
Change in Roll Angle

The change in roll angle is:
d(roll_angle)/d(roll_moment) = ( C(3,3) - C(3,9) -

C(9,3) + C(9,9) + 2.0/Kt ) / Track
Change in Wheel-Center Spin Vector Orientation
The changes in orientation of the left wheel (Wl) and of the right wheel (Wr) due to
a unit upward force at the left contact patch and a unit downward force at the right
contact patch are:
Wl = { C(4, 3) - C(4, 9) , C(5, 3) - C(5, 9) , C(6,

3) - C(6, 9) }
Wr = { C(10, 3) - C(10,9) , C(11, 3) - C(11, 9) ,
C(12, 3) - C(12, 9) }
The change in the left wheel-center (spin) vector (d(wcvl)) and the right wheel (spin)
vector (d(wcvr) are vectors of partial derivatives:
d(wcvl)/d(roll_moment) = Wl x wcvl
d(wcvr)/d(roll_moment) = Wr x wcvr
Change in Steer Angle

The change in steer angle due to a change in wheel-center vector orientation is also
a vector of partial derivatives given by:
d(steer_anglel)/d(wcvl) = (-1.0 / ( syl**2 + sxl**2

) ) { syl, -sxl, 0 }
d(steer_angler)/d(wcvr) = (-1.0 / ( syr**2 + sxr**2
) ) { syr, -sxr, 0 }
where:
sxl = wcvl o x; The x component of the left wheel-

syl = wcvl o y; The y component of the left wheel-
sxr = wcvr o x; The x component of the right wheel-
syr = wcvr o y; The y component of the right wheel-
The change in steer angle for a change in roll moment is computed using the chain
rule:
d(steer_anglel)/d(roll_moment) = (
d(steer_anglel)/d(wcvl) ) o (
d(wcvl)/d(roll_moment) )
d(steer_angler)/d(roll_moment) = (
d(steer_angler)/d(wcvr) ) o (
d(wcvr)/d(roll_moment) )
Roll Steer
And applying the chain rule one last time, the roll steer is
roll_steer.left = ( d(steer_anglel)/d(roll_moment)
) / ( d(roll_angle)/d(roll_moment) )
roll_steer.right = ( d(steer_angler)/d(roll_moment)
) / ( d(roll_angle)/d(roll_moment) )
Request REQUST/id, FUNCTION=USER(900,17,characteristics_input_array_id)
Statements
Nomenclature • Bold, uppercase text, such as Wl, are vectors.
• Bold, lowercase text, such as wcvl, are unit vectors.
Side-View Angle
Description The side-view angle is the wheel carrier side-view rotation angle. It is
positive for a clockwise rotation, as seen from the left side of the vehicle.
Units Angle
Request Names • side_view_angle.left
• side_view_angle.right
Inputs Wheel bearing I marker and origo_y
Method side_view_angle = az, marker I, marker J
254 Adams/Car
Side-View Swing Arm Length and Angle
Description The swing arm is an imaginary arm extending from the wheel's side elevation
instant center of rotation to the wheel center. For front suspensions, the sign
convention is that when the instant center is behind the wheel center, the swing
arm has a positive length. For rear suspensions, the sign convention is the
opposite: when the instant center is ahead of the wheel center, the swing arm
has a positive length.
The angle of the swing arm is the angle it makes to the horizontal. A positive
angle for a positive length is when the arm slopes downward from the wheel
center. A positive angle for a negative length arm is when the arm slopes
upward from the wheel center.
The magnitude of the swing-arm length is limited to a maximum of 1000

meters.
Units Length - mm; angle - degrees
Request Names • side_view_swing_arm_angle.left
• side_view_swing_arm_angle.right
• side_view_swing_arm_length.left
• side_view_swing_arm_length.right

Method The change in vertical and longitudinal position and the side view rotation of
the left wheel center due to a unit vertical force at the left wheel center is:
DX left = C(1,3)
DZ left = C(3,3)
DØ left = C(5,3)
The left side view swing arm length and angle are:
side_view_swing_arm_length.left = (DX left 2 + DZ left 2)1/2 / DØ left
side_view_swing_arm_angle.left = tan-1 (DX left / DZ left)
The change in vertical and longitudinal position and the change in side view
rotation of the right wheel center due to a unit vertical force at the right wheel
center is:
DX right = C(7,9)
DZ right = C(9,9)
DØ right = C(11,9)
The right side view swing arm length and angle are:
side_view_swing_arm_length.right = (DXright 2 + DZright 2) 1/2 / DØ right
side_view_swing_arm_angle.right = tan-1 (DXright / DZ right)
Figure 9 Instant Center Side View (Fore and Aft, Vertical)
Suspension Roll Rate

256 Adams/Car
Description Suspension roll rate is the torque, applied as vertical forces at the tire contact
patches, per degree of roll, measured through the wheel centers.
Units Newton-mm/degree
Request Names • susp_roll_rate.left
• susp_roll_rate.right
• Track width
Method Adams uses opposing unit forces as the applied torque:
T = F x track = track
The resulting vertical distance between wheel centers is:
 Z = X  3, 3  – X  3 , 9  – X  9 , 3  + X  9 , 9 
The rotation of the line through the wheel centers is:
 = Z  track
The roll rate is:
2
susp_roll_rate = T / Ø = track  Z
Figure 10 Roll Rate - Suspension
Toe Angle

Description Toe angle is the angle between the longitudinal axis of the vehicle and the line
of intersection of the wheel plane and the vehicle's XY plane.
Adams reports toe angle in radians. It is positive if the wheel front is rotated
in towards the vehicle body.
Units Degrees
RequestNames • toe_angle.left
• toe_angle.right
Inputs Wheel center axis unit vectors - left and right
Method Adams uses the direction cosines in the x- and y-directions of the wheel
center axis relative to the road to calculate toe angle, such that:
toe_angle.left = tan-1 (DCOSX/DCOSY)

toe_angle.right = tan-1 (-DCOSX/DCOSY)
Figure 11 Toe Angle

258 Adams/Car
Total Roll Rate
Description Total roll rate is the torque, applied as vertical forces at the tire contact patches,
per degree of roll, measured at the tire contact patches.
Units Newton-mm/degreee
Request Names • total_roll_rate.left
• total_roll_rate.right
• Tire stiffness
• Track width
Method Adams uses opposing unit forces as the applied torque:
T = F x track = track
The resulting vertical distance between wheel centers is the following, where Kt
is the tire stiffnesses:
Z = C  3, 3  – C  3 , 9  – C  9 , 3  + C  9, 9  + 2  K t
The rotation of the line through the tire contact patches is:
 = Z  track
The roll rate is:

2
total_roll_rate = T/Ø = track  Z
Total Track

Description Total track is the distance measured along the line passing through the left and
right tire contact points with the left and right road parts (pads) and then
projected onto the right road plane.
The tire contact point lies at the intersection of two lines:
• The first line is formed by the intersection of the wheel plane with the
road plane.
• The second line is perpendicular to the first and passes through the
wheel center.
The wheel plane is perpendicular to the wheel spin axis and passes through
the wheel center.
The left and right road planes behave differently, depending on your
coordinates:
• In vehicle coordinates, the left and right road planes remain

perpendicular to the vehicle's vertical axis, but lie at different heights.
If you run an opposite wheel-travel using vehicle coordinates, the left
and right road planes remain un-rolled (flat) relative to the vehicle
body (ground in a suspension analysis).
• In ISO coordinates, the left and right road planes form one plane that
rotates about the vehicle's longitudinal axis to simulate rolling of the
suspension relative to the road. If you run an opposite wheel-travel
analysis using ISO coordinates, the right road plane and left road
plane are identical, as if the suspension was rolled relative to a flat
road. The total_track (distance between tire contact points) projected
onto the right road plane is foreshortened, and therefore, is less than
the total track output.
Also, the distance from the road plane to the wheel center depends on the tire
deflection, which depends on the tire stiffness and the force required to deflect
the suspension to a given position.
Units Length
Request Names • total_track
260 Adams/Car
Inputs • Contact patch positions

Method The following is the equation used to compute total track:
T = ABS (ROAD (COMP, CPPLEFT) - ROAD (COMP, CPPRIGHT))

where:
• ROAD is a data structure filled with a series of kinematic

characteristics of the suspension. ROAD (Y,CPPLEFT) returns, for
example, the Y component of the left contact patch position.
• CPP represents the instantaneous coodinates of contact points
obtained as described above.
Wheel Rate
Description Wheel rate is the vertical stiffness of the suspension relative to the body, measured
at the wheel center.
Units Newtons/mm
Request Names • wheel_rate.left
• wheel_rate.right
Method Adams computes suspension wheel rate as the inverse of the z-axis displacement
at the wheel center due to the vertical forces applied at both wheel centers
simultaneously.
wheel_rate.left = 1 / (C(3,3) + C(3,9))

wheel_rate.right = 1 / (C(9,3) + C(9,9))
Ackerman

Description Ackerman is the difference between the left and right wheel steer angles. A
positive Ackerman indicates that the right wheel is being steered more to the
right than to the left.
Units Degrees
Request Names • ackerman.left
• ackerman.right
Inputs Steer angle (see Steer Angle)
Method Adams/Car computes Ackerman by subtracting the right steer angle from the
left steer angle:
ackerman = Right steer angle – Left steer angle
Ackerman Angle
Description Ackerman angle is the angle whose tangent is the wheel base divided by the turn
radius. Ackerman angle is positive for right turns.
Units Degrees
Request Names • ackerman_angle.left
• ackerman_angle.right
262 Adams/Car
Inputs • Turn radius (see Turn Radius)

• Wheelbase
Method ackerman_angle = tan-1(Wheel Base/Turn Radius)
Figure 12 Ackerman Angle
Ackerman Error
Description Ackerman error is the difference between the steer angle and the ideal steer angle
for Ackerman geometry. Because Adams/Car uses the inside wheel to compute
the turn center, the Ackerman error for the inside wheel is zero.
For a left turn, the left wheel is the inside wheel and the right wheel is the outside
wheel. Conversely, for a right turn, the right wheel is the inside wheel and the left
wheel is the outside wheel. Positive Ackerman error indicates the actual steer
angle is greater than the ideal steer angle or the actual is steered more to the right.
Units Degrees
Request Names • ackerman_error.left

• ackerman_error.right
Inputs • Steer angle (see Steer Angle)
• Ideal steer angle (see Ideal Steer Angle)
Method ackerman_error.left = (left steer angle - left ideal steer angle)
ackerman_error.right = (right steer angle - right ideal steer angle)
Caster Moment Arm (Mechanical Trail)
Description Caster moment arm is the distance from the intersection of the kingpin (steer)
axis and the road plane to the tire contact patch measured along the intersection
of the wheel plane and road plane. Caster moment arm is positive when the
intersection of the kingpin axis and road plane is forward of the tire contact
patch.
Units mm
Request Names • caster_moment_arm.left
• caster_moment_arm.right
264 Adams/Car
Inputs • Kingpin axis position, a point on the kingpin axis (Rs) - left and right
• Kingpin (steer) axis unit vector (s) - left and right
• Tire contact patch position (Rp) - left and right
• Wheel center axis unit vector (w) - left and right
• The road normal unit vector (k)
Methods Adams/Car first finds the intersection of the kingpin axis and the road plane.
Note that by convention, the kingpin axis unit vector is directed upward, away
from the road, and the road plane has zero height. The intersection of the
kingpin axis and the road plane (Rkr) is:
Rsr = Rs - (Rs o k)/(s o k) s

Next, Adams/Car finds a unit vector (l) directed rearward along the line of
intersection between the wheel plane and the road plane:
l = k x w / | k x w | (left side)
l = k x -w / | k x -w | (right side)
The distance along l from the contact patch to the intersection of the kingpin
axis and the road plane is:
caster_moment_arm = (Rp - Rkr) o l
Figure 13 Caster Moment Arm and Scrub Radius

Ideal Steer Angle
Description Ideal steer angle is the steer angle in radians that gives Ackerman steer geometry
or 100% Ackerman. For Ackerman steer geometry, the wheel-center axes for all
four wheels pass through the turn center. Note that Adams/Car uses the steer
angle of the inside wheel to determine the turn center for Ackerman geometry.
Therefore, the ideal steer angle and the steer angle are equal for the inside wheel.
When making a left turn, the left wheel is the inside wheel. Conversely, when
making a right turn, the right wheel is the inside wheel. A positive steer angle
indicates a steer to the right.
Units Degrees
Request Names • ideal_steer_angle.left
• ideal_steer_angle.right
Inputs • Turn radius (see Steer Angle)
• Wheelbase
Method ideal_steer_angle.left = tan-1 [Wheel Base/Turn Radius - Rp(left) o y )]
ideal_steer_angle.right = tan-1 [Wheel Base/Turn Radius -Rp(right) o ŷ )]
Note • Right turns give positive angles and turn radii
• Rp(left) o ŷ < 0
• Rp(right) o ŷ > 0
• |Inside wheel's ideal steer angle| > |outside wheel's ideal steer angle|
Outside Turn Diameter

266 Adams/Car
Description Outside turn diameter is the diameter of the circle defined by a vehicle's outside
front tire when the vehicle turns at low speeds. Adams/Car determines the circle
by the tire's contact patch for a given steer angle. For a left turn, the right front
wheel is the outside wheel. For a right turn, the left front wheel is the outside
wheel.
Units mm
Request Names • outside_turn_diameter.left
• outside_turn_diameter.right
Inputs • Turn radius (see Turn Radius)
• Track width
• Wheelbase
Method outside_turn_radius = 2.0 [(| Turn Radius | +Track/2)2 + (Wheel Base) 2]1/2
Percent Ackerman
Description Percent Ackerman is the ratio of actual Ackerman to ideal Ackerman expressed
as a percentage. Percent Ackerman is limited to the range from -999% to 999%.
Percent Ackerman is positive when the inside wheel's steer angle is larger than the
outside wheel's steer angle.
Units %
Request Names • percent_ackerman.left
• percent_ackerman.right
• Ideal steer angle (see Ideal Steer Angle)
• Ackerman (see Ackerman)
Method ackerman = Right steer angle - Left steer angle
ideal_ackerman = Right ideal steer angle - Left ideal steer angle
percent_ackerman = 100 x Ackerman/Ideal Ackerman

Scrub Radius
Description Scrub radius is the distance from the intersection of the kingpin (steer) axis and
the road plane to the tire contact patch measured along the projection of the
wheel-center axis into the road plane. Scrub radius is positive when the
intersection of the kingpin axis and the road plane is inboard of the tire contact
patch.
Units mm
268 Adams/Car
Request Names • scrub_radius.left

• scrub_radius.right
Inputs • Kingpin axis position (Rs) - left and right

• Kingpin (steer) axis unit vector (s) - left and right
• Wheel-center axis unit vector (w) - left and right
• The road normal unit vector (k)
Method Adams/Car first finds the intersection of the kingpin axis and the road plane.
Note that by convention the kingpin axis unit vector is directed upward, away
from the road, and the road plane has zero height. The intersection of the kingpin
axis and the road plane (Rkr) is:
Rsr = Rs - (Rs o k)/(s o k) s

Next Adams/Car finds the projection (m) of the wheel-center axis (w) onto the
road plane
M = (k x w) x k
m = M / | M |
The distance from the contact patch to the intersection of the kingpin axis and
the road plane along m is:
scrub_radius = (Rp - Rkr) o m
Figure 14 Caster Moment Arm and Scrub Radius

270 Adams/Car
Steer Angle
Description Steer angle is the angle measured from the vehicle heading to the line formed
by the intersection of the wheel plane with the ground plane. Steer angle is
positive when a wheel is rotated to the right as if the vehicle were making a right
turn.
Units Degrees
Request Names • steer_angle.left
• steer_angle.right
Inputs Wheel-center axis unit vectors - left and right
Method Adams/Car uses the direction cosines of the x-direction and the y-direction of
the wheel-center axis constructed from the wheel-center orientation to calculate
steer angle:
steer_angle.left = tan-1 (-DCOSX/|DCOSY|)

steer_angle.right = tan-1 (DCOSX/|DCOSY|)
Steer Axis Offset

Description The steer axis offset is the shortest distance from the steer (kingpin) axis to
the wheel center. The steer axis offset is measured in the plane perpendicular
to the steer axis and passing through the wheel center. The steer axis offset is
always positive.
The steer axis offset-longitudinal is the component of the steer axis offset
along the intersection of the wheel plane with the plane perpendicular to the
steer axis and passing through the wheel center. The steer axis offset-
longitudinal is positive when the wheel center is forward of the steer axis.
The steer axis offset-lateral is the component of the steer axis offset along the
projection of the wheel-center axis into the plane perpendicular to the steer
axis and passing through the wheel center. The steer axis offset - lateral is
positive when the wheel center lies outboard of the steer axis.
Units mm
Request Names • steer_axis_offset.off_left
• steer_axis_offset.off_right
• steer_axis_offset.lon_left
• steer_axis_offset.lon_right
• steer_axis_offset.lat_left
• steer_axis_offset.lat_right
Inputs • Wheel-center position (WCP) left and right
• Wheel-center (spin) axis unit vector (wcv) left and right
• Kingpin (steer) axis position (KPP) left and right
• Kingpin (steer) axis unit vector (kpv) left and right
272 Adams/Car
Method First, define longitudinal and lateral directions in a plane perpendicular to the steer
(kingpin) axis using the kingpin axis vector and the wheel-center (spin) vector.
u_lon = ( wcv x kpv ) / | wcv x kpv |

and:
u_lat = ( kpv x u_lon ) / | kpv x u_lon |

Note that u_lat is the projection of the wheel-center vector (wcv) onto the plane
perpendicular to the kingpin axis.
The displacement vector (R) from a point on the kingpin (steer) axis to the wheel
center is:
R = WCP - KPP
The steer axis offset-longitudinal is:
steer_axis_offset.lon_left = -R o u_lon
steer_axis_offset.lon_right = R o u_lon
The steer axis offset-lateral is:
steer_axis_offset.lat_left = R o u_lat
steer_axis_offset.lat_right = R o u_lat
Finally, the steer axis offset is:
steer_axis_offset.off_left = sqrt( lon_left2 +

lat_left2 )
steer_axis_offset.off_right = sqrt( lon_right2 +
lat_right2 )
Figure 15 Steer Axis Offset (Top View)

Request Statements Offset:

REQUST/id, FUNCTION=USER(900,44,characteristics_input_array_id)\
Longitudinal offset:
Lateral offset:
Nomenclature • Bold text in uppercase letters, such as R, shows vectors.
• Bold text in lowercase letters, such as u_lon, shows unit vectors.
Turn Radius
Description The turn radius is the distance measured in the ground plane from the
vehicle center line to the turn center along the y-axis (see the figure for
Ackerman Angle). Turn radius is positive for right turns and negative for left
turns.
Units mm
Request Names • turn_radius.left
• turn_radius.right
274 Adams/Car

• Track width
• Wheelbase
• Wheel-center orientations - left and right
Method Adams/Car determines the inside wheel by checking the sign of the steer
angles. It computes turn radius using the inside tire orientation.
Left turn:
turn_radius.left = - [Wheel Base (DCOSY/DCOSX) +

Track/2]
Right turn:
turn_radius.right = [Wheel Base x (DCOSY/DCOSX) +

Track/2]
Working with the Suspension Test Rig

Adams/Car uses the suspension test rig, named .__MDI_SUSPENSION_TESTRIG, in all its suspension
analyses. When you create a suspension assembly, Adams/Car assembles the suspension test rig with the
selected suspension and steering subsystems.
The suspension test rig inputs excitation as motions and forces to the suspension and steering subsystems.
The excitations are made up of one or more of the following:
• Displacement for wheel bump and rebound vertical travel
• Roll and vertical force
• Steering travel at the steering wheel or rack
• Forces or torques at the steering wheel or rack
• Forces and torques at the contact patch and the hub
Learn about the suspension test rig:

• Benefits of Using the Suspension Test Rig
• Structure of Suspension Test Rig
Benefits of Using the Suspension Test Rig

You can use the suspension test rig to:
• Include a deflecting tire in your suspension simulations so that suspension characteristics output
by Adams/Car are more accurate.
• Swap a deflecting tire with a semi-rigid tire.
• Specify additional loads acting through the tire on the suspension, in particular:
• Lateral cornering force at the contact patch
• Lateral damage force and damage radius (point of application of force)
• Traction force acting at the wheel center (note that the traction torque is not reacted by the
suspension)
• Braking force at the contact patch (creates a brake torque on the suspension)
• Overturning moment at the contact patch
• Aligning torque at the contact patch
• Drive your suspension with a set of closed-loop controllers to vary:
• Wheel-center displacements
• Contact patch displacements
• Wheel vertical forces
• Perform roll angle sweeps at constant total vertical force (sum of vertical force on the left and
right wheels)
276 Adams/Car
Structure of Suspension Test Rig

You assemble your suspension and steering subsystems with the suspension test rig. Then, using the
resulting assembly, you simulate different suspension motions and loadcases to determine how your
suspension performs. To help you to assess the performance of your suspension, Adams/Car calculates
about forty characteristics, such as toe angle, camber angle, caster trail, roll center height, and aligning
torque camber compliance.
When you assemble your suspension subsystem to the suspension test rig, the suspension arms, struts,
links, and subframe that normally mount to the body, mount to ground. The test rig includes wheels and
tires that mount to the suspension hubs. The test rig drives the suspension motion by tables that contact
the tires, pushing the suspension up through the tires. Finally, if you include a steering subsystem, the test
rig couples to the rack and the steering wheel to drive steering motion.
When you submit a suspension analysis you can request the test rig to control the wheel center or the tire
contact patch positions. In some cases the test rig may not be able to achieve a desired position because
the suspension travel is limited, for example, by a bumper. In such a case, the vertical actuators saturate,
meaning they reach the maximum force they can apply. The forces and displacements the test rig can
apply to the suspension through the vertical actuators are limited to reasonable values for passenger cars.
For other vehicles, you may need to update the limits. To learn how to update the limits, see Vertical
Actuators.
To properly assemble with the test rig, your suspension template must include the following output
communicators (see Communicator Entity Class):
• suspension_mount (communicator entity class: mount) - Points to the parts (typically the hub,
also known as the spindle) in your suspension template to which the test rig wheel tires mount.
• wheel_center_location (communicator entity class: location) - Contains the wheel-center
location that Adams/Car uses to locate the test rig relative to the suspension.
• toe_angle and camber_angle (communicator entity class: parameter real) - Contain the static toe
and camber angles that Adams/Car uses to orient the test-rig wheels.
• suspension_upright (communicator entity class: mount) - Points to the suspension upright in
your suspension template. The suspension test rig creates a perpendicular joint primitive
between the suspension mount (that is, the hub) and the suspension upright to lock wheel
rotation during suspension analyses.
The following make up the suspension test rig:
• Vertical Actuators
• Suspension Test Rig Tire
• Static Loads
• Loadcase Files
Vertical Actuators
The left and right vertical actuators apply forces to drive the test-rig tables, and in turn, the suspension,
up and down. An integral controller computes the actuator force necessary to achieve the desired wheel
center or contact patch positions. However, the forces in the actuators are limited by default to -22,000
N in rebound and 40,000 N in jounce.
The vertical actuators are standard joint force actuators (pairs of action-only translational forces). You
can modify the force limits using the Adams/Car Template Builder through the menus Build -> Actuator
-> Joint Force -> Modify.
Suspension Test Rig Tire

The suspension test rig includes left and right wheel and tire UDE instances that are compatible with
Adams/Tire. The test rig tables contact these tires to drive the suspension's vertical travel. These tires also
apply the contact patch loads (read from the loadcase spline) to the suspension. The suspension test rig
sets the simulation type string to ”SUSPENSION” to inform Adams/Tire you are performing a
suspension analysis.
About RIGID_WHEEL and LIVE_TIRE

When working with these tires you can modify them to select either of the following:
• RIGID_WHEEL - The tire transmits both compression and tension force allowing the test rig to
pull the suspension into rebound.
• LIVE_TIRE - The tire only transmits compression force. Thus when the vertical force between
the tire and table goes to zero, the tire separates from the table. Therefore, when using a
LIVE_TIRE, the test rig cannot pull the suspension into rebound. However, the force of gravity
and the suspension spring will typically drive the suspension into rebound until the suspension
hits the rebound bumper.
For the equations for RIGID_WHEEL and LIVE_TIRE,
• radius is the distance, measured in the plane of the wheel, from the wheel center to the contact
patch
• r is the unit vector directed from the contact patch to the wheel center
• n is the unit vector normal to the table
RIGID_WHEEL
When you select RIGID_WHEEL, you enter the tire stiffness and unloaded radius. Adams/Car sets the
tire property file string to ”RIGID_WHEEL” and passes the stiffness and radius you entered to
Adams/Tire through an ARRAY statement. Adams/Tire calculates the tire vertical force using the
following equation:
force = tire_stiffness*(unloaded_radius - radius) (r o n)
LIVE_TIRE
When you select LIVE_TIRE, you must enter a tire property file. Adams/Tire opens the property file and
reads the unloaded radius and vertical stiffness. These values are automatically converted to the proper
278 Adams/Car
units for your suspension assembly. Other parameters in the tire property file are ignored. Adams/Tire
calculates the tire vertical force using the following equation:
force = max(0.0, tire_stiffness*(unloaded_radius - radius) (r o n))
Static Loads
You can specify forces, torques, and displacements as inputs to your suspension analyses. These inputs
are stored in the loadcase spline. The loadcase spline contains a linear interpolation at discrete time
intervals, between the upper and lower values.
The following table shows how forces and torques are expressed in the reference frames :
Forces/Torques in Reference Frames
Reference frame:
TYDEX H ISO-W contact TYDEX-C axis system wheel
Force/torque: patch center
Lateral force (cornering) x
Longitudinal force (braking) x
Longitudinal force (traction) x
Overturning moment x
Rolling resistance torque x
Aligning torque x
Loadcase Files
Adams/Car supports old suspension loadcase files (version 5) as follows:
• Vertical Mode = Length - Corresponds to wheel_center_height
• Vertical Mode = Force - Corresponds to an open-loop vertical force
Tire Test Rig
Tire Test Rig

In Adams/Car the response of a single tire under various conditions and excitations can be evaluated in
the so-called Tire Testrig. The test rig can be activated by, after building an assembly, clicking on
Simulate - Full-Vehicle Analysis - Tire Testrig.
The tire testrig model exists of one tire (wheel) mounted on a spindle that can be suspended to ground by
a spring, or preloaded by an SFORCE, or fixed at a certain axle height.
The road can be fixed or moving (moving in x, y, z-direction, or rolling around x-axis), while the road it-
self can be flat with or without a cleat (pothole), or user-defined (road property file).
The wheel movements can enhance steering (slip angle variations), wheel rotations (longitudinal slip
variations), inclination with the road (camber), vertical and longitudinal wheel (center) displacements.
The initial wheel rotational speed can be calculated using the free tire radius in the tire property file and
the initial wheel longitudinal velocity
280 Adams/Car
Tire Test Rig
Example testrig files, defining the testrig simulations, can be found in the loadcases folder of the
Adams/Car database. The user may define own testrig simulations or modify one of these examples.
Tire Test Rig
Each analysis represents one simulation. By clicking on the analysis name, the simulation details can be
defined:
Once all analysis details have been defined, clicking on 'Run It' starts the process of generating the model
files, run these with the solver and plotting a number of default characteristics in the postprocessor view.
Note: There are three points of attention when evaluating tire characteristics:
• For analyzing steady state tire characteristics, please remember that the usemode
in the tire property file should be set to steady state (not transient)
• Some tire models have a 'start-up' smoothing option. This causes the tire response
to start from zero up to the full tire force response during the first 0.1 seconds. For
analyzing tire characteristics it is often useful to disable this option.
• The plots created for the Adams Postprocessor will be in MMKS units (mm,
Newton, seconds, Kilogram).
282 Adams/Car
Running Full-Vehicle Analyses

You can take previously created suspension subsystems and integrate them with other subsystems to
create a full-vehicle assembly. You can then perform various analyses on the vehicle to test the design of
the different subsystems and see how they influence the total vehicle dynamics. All of the analyses,
except for the data-driven analyses, use the .__MDI_SDI_TESTRIG, and are therefore based on the
Driving Machine. You can also examine the influence of component modifications, including changes in
spring rates, damper rates, bushing rates, and anti-rollbar rates, on the total vehicle dynamics.
Each type of analysis you perform requires a minimum set of subsystems: front and rear suspension
subsystems, front and rear wheel subsystems, one steering subsystem, and one body subsystem. Before
you can create an assembly and perform an analysis in Adams/Car, you must open or create the minimum
set of subsystems required.
Using Adams/Car, you can:
• Easily modify the geometry and the properties of the components of your subsystems.
• Select from a standard set of vehicle maneuvers to evaluate handling characteristics of your
virtual prototype.
• View the vehicle states and other characteristics through plots.
You can specify inputs to the analysis by typing them into an analysis dialog box or by selecting a driver
control file that contains the desired inputs.
After specifying the prototype assembly and its analysis, Adams/Car, like your company's testing
department, applies the inputs that you specified and records the results. To understand how your
prototype behaved during the analysis, you can plot the results. After viewing the results, you might
modify the prototype and analyze it again to see if your modifications improve its behavior.
The following figure shows an overview of the full-vehicle analysis process.
Setting up Full-Vehicle Analyses

Before you set up a full-vehicle analysis, you must assemble and check the vehicle, as explained next:
• Assembling a Vehicle
• Checking a Vehicle
• Setting up the Analysis
Assembling a Vehicle
Adams/Car creates a full-vehicle assembly from a set of subsystems that you select. An assembly lets
you quickly put together full vehicles from previously tested and verified subsystems and switch between
subsystems depending on the analysis that you want to perform.
The associated component property files, such as springs and bushings, must also exist in your database.
If a suspension subsystem uses mount parts, such as the spring top mounting to a subframe, you must
read the subframe subsystem into the assembly. If you do not read in the required mount subsystems,
Adams/Car connects any mount parts to the global ground part instead of the absent mount subsystem.
Therefore, the mount point cannot move with the full vehicle, which causes the Adams/Car analysis to
fail.
Checking a Vehicle
Before submitting your model for analysis, visually check its assembly. The Adams/Car default view is
front isometric view. From the front view, you should be able to see obvious assembly problems. You
should also check your vehicle from the side because it provides a more useful view for positioning the
subsystems.
As you view your assembly from different angles, check for obvious problems, such as:
• Is the front suspension in the correct place?
• Is the body graphic positioned correctly?
• Are the wheels somewhere near the same height?
All the analyses currently available are based on the Driving Machine. Therefore, to perform open-loop,
closed-loop, and quasi-static analyses, you must select the .__MDI_SDI_TESTRIG in your assemblies.
Always check whether you selected the correct test rig for the analysis you want to perform. If you
selected an incorrect test rig, create another assembly using the correct test rig.
To check the test rig:

1. From the File menu, point to Info, and then select Assembly.
2. In the Assembly Name text box, enter the name of your assembly.
3. Select OK.
Adams/Car displays the Information window, with the test rig name listed at the top of the
window.
284 Adams/Car
Setting up the Analysis
To set up full-vehicle analyses:

1. From the Simulate menu, point to Full-Vehicle Analysis, and then select the analysis you want
to set up.
2. Enter the parameters needed to control the analysis.
3. Typically, each transient analysis can be preceded by a quasi-static prephase analysis before
running the transient analysis on your full-vehicle assemblies. A quasi-static prephase analysis
consists of a straight analysis or a skidpad analysis, depending on the type of analysis you
selected. If you do not select the quasi-static option, Adams/Car performs a SETTLE analysis.
For more information about the different quasi-static setup method keywords (such as SETTLE
and STRAIGHT), see Structure of Event Files.
4. For dialog box help, select F1.
5. Select OK.
Controlling Full-Vehicle Analyses

If you are an experienced Adams/Car user and you want to perform some non-standard full-vehicle
analyses, such as studying the linear behavior of your vehicle between two mini-maneuvers, you can use
an Adams/Solver control subroutine (Eventxxx) to do so.
When you run a full-vehicle analysis, Adams/Car writes a number of files to the current working
directory (as defined by File -> Select Directory). These files contain important information about the
details of the maneuver. In particular, two files are important in defining the scope of the maneuver. These
are the Adams/Solver control file (.acf) and the event file (.xml). See Working with Event Files (.xml).
The following shows the typical contents of an .acf:
file/model=test_step
preferences/solver=F77
output/nosep
control/ routine=abgVDM::EventInit,
function=user(3,1,10,0,2,5,7,17)
control/ routine=abgVDM::EventRunAll, function=user(0)
!
stop
In the .acf, note the following line:
function=user(3,1,10,0,2,5,7,17)
This line calls an Adams/Car-specific control subroutine (a consub). The consub sets up and initializes
the full-vehicle analysis. It does the following:
• Reads the event file (or converts the TeimOrbit .dcf file into XML)
• Performs a number of static analyses based on the content of the DcfStatic class in the event file
• Performs a dynamic analysis by running each of the mini-maneuvers listed in the DcfMini
classes in the event file
You can view and modify the event file (.xml) using the Event Builder. The Event Builder allows you to
modify existing parameters for the entire maneuver, such as step size and hmax, to modify specific mini-
maneuver information, and add mini-maneuvers.
The following line calls the control subroutine EventInit:
control/ routine=abgVDM::EventInit, function=user(3,1,10,0,2,5,7,17)
The call to this subroutine passes 8 parameters, as described next. Note that each number in the array
(3,1,10,0,2,5,5,17) is listed after the description of that parameter.
par(1) 3: ID of STRING statement containing .XML event filename = 3
par(2) ID of ORIGO marker = 1
par(3) ID of ARRAY statement containing initial condition SDI parameters = 10
par(4) ID of ARRAY statement containing ids of parts for which initial
velocity are not set = 0
par(5) ID of ARRAY holding Vehicle Parameters. = 2
par(6) ID of main Driving Machine ARRAY. = 5
par(7) ID ISO EAS Marker = 7
par(8) ID of ARRAY containing the ids of extensible end condition sensor
elements = 17
If you look at the corresponding Adams/Solver dataset (.adm), you will see that STRING/3 contains the
name of the event file:
! adams_view_name='testrig_dcf_filename'
STRING/3
, STRING =example_crc.xml
All standard Adams/Car events generate an event file in XML format, similar to the one referenced in
the example above, but .dcf files in TeimOrbit format are still supported, both in the Event Builder and
at the solver level. This means that you can replace the above string and reference a .dcf file in TeimOrbit
format. The file will be automatically converted to XML format.
By modifying the .acf file, you can now execute all mini-maneuvers defined in the event file, or just run
the initialization and then execute one mini-maneuver at a time. Full-vehicle analysis .acf files by default
call the Driving Machine initialization routine, then call the RunAll method. You can, however, modify
the .acf file and use the following commands for more control over your analysis:
• control/ routine=abgVDM::EventRunAll, function=user(0) - Runs all the active mini-maneuvers
in the list of events
• control/ routine=abgVDM::EventRunNext, function=user(0) - Runs the following mini-
maneuver in the list of the events
• control/ routine=abgVDM::EventRunFor, function=user(double time) - Runs the current mini-
maneuver for duration of time [s]
• control/ routine=abgVDM::EventRunUntil, function=user(double time) - Runs the current mini-
maneuver until the desired absolute time [s]
286 Adams/Car
Using this flexibility within the event control subroutine enables you to use the power of the acf language
to make changes and re-submit your solution to Adams/Solver. The language parameters for the .acf file
are documented in the Adams/Solver online help.
Running with External Adams/Solver

How you run Adams/Solver depends on the platform you are on:
• On Windows - The location of your .acf, .adm, and event files is important. Open a DOS shell
(from the Start menu, point to Programs, point to Accessories, and then select Command
Prompt) and change directory to the location where your files are stored (cd temp\run).
• On UNIX - Open a shell and change directory to the location of your files (cd
/usr/home/user/temp/run).
To run external Adams/Solver:

• Issue the command:
adamsxx acar ru-solver filename.acf
where:
• xx corresponds to the version of Adams that you are using

• filename.acf is the name of your acf file
Reading Results
After you run the analysis, you can use Adams/PostProcessor to animate and view the results.
Note: • To control the execution of the various mini-maneuvers defined in the XML event
file you need to issue the EventInit control subroutine command first. This
instructs Adams/Car to build a list of quasi-static and transient events as they are
defined in the event file.
• To execute each mini-maneuver in the event file, you should issue a control/
routine=abgVDM::EventRunNext as described above.
3D Road Analysis
A 3D road analysis simulates your vehicle assembly traversing a three-dimensional road representation
and the obstacles or characteristics contained in that 3D road. The road file (.rdf/.xml) is used by both the
tire subsystems to compute contact patch forces/moments, and by the lateral controller. The Driving
Machine uses path information contained in the 3D road file to drive the vehicle along the specified
course centerline. Example 3D road files are distributed in the shared Adams/Car database (3d_road_*).
For more information about the 3D road, see Using the Road Builder.
To set up a 3D road analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, point to Course Events, and then select
3D Road.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: 3D
Road.
3. Select OK.
Cornering Analyses
You use cornering analyses to evaluate your vehicle's handling and dynamic responses during various
cornering-type maneuvers. Cornering analyses use both open- and closed-loop controllers of the steering,
throttle, brake, gear, and clutch signals to investigate various vehicle behaviors. You can investigate both
steady-state and limit cornering to characterize responses such as understeer/oversteer gradients, weight
transfer, and so on.
Note: Adams/Car creates an event file (.xml) that defines the analysis. The Driving Machine uses
the event file to control the vehicle. Adams/Car stores the event file in the working
directory so you can refer to it as needed and examine it using the Event Builder.
The cornering analyses include:

• Braking-In-Turn
• Constant-Radius Cornering
• Cornering with Steer Release
• Lift-off Turn-in
• Power-off Cornering
Braking-In-Turn Analysis
The braking-in-turn analysis is one of the most critical analyses encountered in everyday driving. This
analysis examines path and directional deviations caused by sudden braking during cornering. Typical
results collected from the braking-in-turn analysis include lateral acceleration, variations in turn radius,
and yaw angle as a function of longitudinal deceleration.
In a braking-in-turn analysis, you can set the Driving Machine to drive your full vehicle, as follows:
• Drive down a straight road, turn onto a skidpad, and then accelerate to achieve a desired lateral
acceleration
• Run a quasi-static skidpad setup, which places the vehicle on a skidpad with predefined lateral
acceleration
288 Adams/Car
The Driving Machine holds the longitudinal speed and radius constant for a time to let any transients
settle. It then applies a brake signal to the vehicle to control the vehicle deceleration at a constant rate
(units in g).
Depending on the controller type, the Driving Machine does either of the following:
• Open-loop - Locks the steering wheel
• Closed-loop - Maintains the skidpad radius
The Driving Machine maintains the braking for the given duration of the maneuver or until the vehicle
speed drops below 2.5 meters/second.
You can use the plot configuration file, mdi_fva_bit.plt, in the shared Adams/Car database to generate
the plots that are typically of interest for this type of analysis.
To set up a braking-in-turn analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, point to Cornering Events, and then
select Braking-In-Turn.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis:
Braking-In-Turn.
3. Select OK.
Constant-Radius Cornering Analysis

For constant-radius cornering analysis, the Driving Machine drives your full vehicle down a straight
road, turns onto a skidpad, and then gradually increases velocity to build up lateral acceleration. One
common use for a constant radius cornering analysis is to determine the understeer characteristics of the
full vehicle.
To set up a constant-radius cornering analysis:

select Constant Radius Cornering.
Constant-Radius Cornering.
3. Select OK.
Cornering with Steer Release Analysis

The vehicle performs a dynamic constant-radius cornering to achieve the prescribed conditions (radius
and longitudinal velocity or longitudinal velocity and lateral acceleration). After the steady state
prephase, the steering wheel closed-loop signal is released, simulating a release of the steering wheel.
The analysis focuses primary on the path deviation, yaw characteristics, steering-wheel measurements,
roll angle, roll rate, and side-slip angle.
To set up an analysis of cornering with steer release:

select Cornering w/Steer Release.
Cornering Steer Release.
3. Select OK.
Lift-off Turn-in Analysis

This analysis examines path and directional deviations caused by suddenly lifting the throttle pedal
during cornering and applying an additional ramp steering input. Typical results collected from the lift-
off turn-in analyses include lateral acceleration, variations in turn radius, and yaw angle as a function of
longitudinal deceleration. Adams/Car drives the vehicle through two distinct phases:
• Cornering pre-phase: Adams/Car uses quasi-static calculations to set the vehicle at the correct
initial conditions for the desired lateral acceleration at the given radius.
• Lift-off turn-in: The steer is ramped from the last value of the previous mini-maneuver at the
desired rate. The throttle signal is set to zero; the clutch can be engaged or disengaged.
To set up a lift-off turn-in analysis:

select Lift-Off Turn-In.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: Lift-
Off Turn-In.
3. Select OK.
Power-off Cornering Analysis

The purpose of this maneuver is to determine the power-off effect on course holding and directional
behavior of a vehicle, whose steady-state circular path is disturbed only by power-off. The Driving
Machine drives the vehicle through two distinct phases:
• An initial quasi-static setup that achieves the initial conditions.

• A power-off event where the throttle signal is stepped down from the value of the previous mini-
maneuver to zero.
The lateral acceleration and skidpad radius define the initial conditions. Note that the significance of the
results decreases with the skidpad radius. After reaching the initial steady-state driving conditions, the
steering signal is kept constant and the accelerator pedal is released with a step signal profile. The release
of the accelerator pedal is considered as the moment of power-off initiation, which you can define.
Typical results collected from power-off cornering analyses include variations in the heading direction
and longitudinal deceleration, as well as side-slip angle, yaw angle, and gradient.
290 Adams/Car
To set up a power-off cornering analysis:

select Power-off Cornering.
Power-Off Cornering.
3. Select OK.
Course Analyses
Course analyses are based on the Driving Machine and are of a course-following type, such as ISO lane
change.
In an ISO lane change analysis, the Driving Machine drives your full vehicle through a lane change
course as specified in ISO-3888: Double Lane Change. You specify the gear position and speed at which
to perform the lane change. The analysis stops after the vehicle travels 250 meters; therefore, the time to
complete the lane change depends on the speed you specify.
The course analyses include:
• ISO Lane Change
• 3D Road
ISO Lane Change

During an ISO lane change analysis, a longitudinal controller maintains the chassis velocity to the desired
value, and a lateral controller module acts on the steering system to maintain the vehicle on the desired
ISO lane-change path.
Adams/Car uses an external file to define the path for the maneuver: iso_lane_change.dcd defines the
trace of the desired path on the x-y plane.
Note: Adams/Car creates an event file (.xml) that defines the analysis and the different
parameters. It uses the .xml file for the analysis and then leaves it in the working directory
so you can refer to it as needed. The file that defines the path is stored in the
shared_car_database, in the driver_data table, and is called iso_lane_change.dcd.
To set up an ISO lane change analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, point to Course Events, and then
select ISO Lane Change.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: ISO
Lane Change.
3. Select OK.
3D Road
A 3D road analysis simulates your vehicle assembly using a three-dimensional road representation. The
road file (.rdf) is used by both the tire subsystems to compute contact patch forces/moments, and by the
lateral controller. The standard driver interface (SDI) uses path information contained in the 3D road file
to drive the vehicle along the specified course. The shared car database includes several example 3D road
files.
To set up a 3D road analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, point to Course Events, and then
select 3D Road.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: 3D
Road.
3. Select OK.
Open-Loop Steering Analyses

Adams/Car provides a wide range of open-loop steering analyses. In open-loop steering analyses, the
steering input to your full vehicle is a function of time.
The open-loop steering analyses include:
• Drift
• Fish-Hook
• Impulse Steer
• Ramp Steer
• Single Lane-Change
• Step Steer
• Swept-Sine Steer
Drift Analysis
In a drift analysis, the vehicle reaches a steady-state condition in the first ten seconds. A steady-state
condition is one in which the vehicle has the desired steer angle and initial velocity values. In seconds 1
through 5 of the analysis, Adams/Car ramps the steering angle/length from the initial value to the desired
value using a STEP function. In seconds 5 through the desired end time, it linearly ramps the throttle at
the desired ramp rate.
Note: Adams/Car creates an event file (.xml) that defines the analysis and the different parameters.
It uses the .xml file for the analysis and then leaves it in the working directory so you can
refer to it as needed.
292 Adams/Car
To set up a drift analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, point to Open-Loop Steering Events,
and then select Drift.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: Drift.
3. Select OK.
Fish-Hook Analysis
You use a fish-hook analysis is to evaluate dynamic roll-over vehicle stability.
A fish-hook analysis consists of two mini-maneuvers (see Creating Mini-Maneuvers):
• A quasi-static phase sets up the vehicle at the desired initial conditions.
• The second mini-maneuver runs the actual fish-hook analysis in which Adams/Car computes the
steering signal as a combination of step functions, and disengages the clutch. The maneuver
provides a basis for evaluating a vehicle's transitional response and dynamic roll-over stability.
The most important factors for this evaluation are: steering-wheel angle, lateral acceleration,
yaw rate, and roll angle.
Adams/Car conducts the analysis by driving at a constant speed, putting the vehicle in neutral,
and turning one direction in a preselected steering-wheel angle and then turning the opposite
direction in another preselected steering-wheel angle.
To set up a fish-hook analysis:

and then select Fish Hook.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: Fish
Hook.
3. Select OK.
Impulse-Steer Analysis
In an impulse-steer analysis, the steering demand is a force/torque, single-cycle, sine input. The steering
input ramps up from an initial steer value to the maximum steer value. You can run with or without cruise
control. The purpose of the test is to characterize the transient response behavior in the frequency domain.
Typical metrics are: lateral acceleration, and vehicle roll and yaw rate, both in time and frequency
domain.
To set up a impulse-steer analysis:

and then select Impulse Steer.
Impulse Steer.
3. Select OK.
Ramp-Steer Analysis
In a ramp-steer analysis, you obtain time-domain transient response metrics. The most important
quantities to be measured are: steering-wheel angle, yaw angle speed, vehicle speed and lateral
acceleration. During a ramp-steer analysis, Adams/Car ramps up the steering input from an initial value
at a specified rate.
To set up a ramp-steer analysis:

and then select Ramp Steer.
Ramp Steer.
3. Select OK.
Single Lane-Change Analysis

During a single lane-change analysis, the steering input goes through a complete sinusoidal cycle over
the specified length of time. The steering input can be:
• Length, which is a motion applied to the rack of the steering subsystem.
• Angle, which is angular displacements applied to the steering wheel.
• Force applied to the rack.
• Torque applied to the steering wheel.
To set up a single lane-change analysis:

and then select Single Lane Change.
Single Lane Change.
3. Select OK.
Step Steer Analysis

A step steer analysis yields time-domain transient-response metrics. The most important quantities to be
measured are:
• Steering-wheel angle
• Yaw rate
• Vehicle speed
• Lateral acceleration
During a step steer analysis, Adams/Car increases the steering input from an initial value to a final value
over a specified time.
294 Adams/Car
To set up a step steer analysis:

and then select Step Steer.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: Step
Steer.
3. Select OK.
Swept-Sine Steer Analysis

Sinusoidal steering inputs at the steering wheel let you measure frequency-response vehicle
characteristics. This provides a basis for evaluating a vehicle transitional response, the intensity and
phase of which varies according to the steering frequency. The most important factors for this evaluation
are:
• Steering-wheel angle
• Lateral acceleration
• Yaw rate
• Roll angle
During a swept-sine steer analysis, Adams/Car steers the vehicle from an initial value to the specified
maximum steer value, with a given frequency. It ramps up the frequency of the steering input from the
initial value to the specified maximum frequency with the given frequency rate.
To set up a swept-sine steer analysis:

and then select Swept-Sine Steer.
Swept-Sine Steer.
3. Select OK.
Quasi-Static Analyses
Quasi-static analyses find dynamic equilibrium solutions for your full vehicle at increasing, successive
values of lateral acceleration. Quasi-static analyses, in contrast to open-loop and closed-loop analyses,
do not include transient effects and solve very quickly. For example, in a quasi-static analysis, a change
in lateral acceleration from 0.1g to 0.5g does not show the lateral acceleration or yaw rate overshoot that
a similar open-loop and closed-loop analysis might show.
The following topics contain information on setting up quasi-static analyses, as well as a description of
the types of quasi-static analyses:
• Quasi-Static Constant-Radius Cornering
• Quasi-Static Constant-Velocity Cornering
• Quasi-Static Force Moment Method
• Quasi-Static Straight-Line Acceleration
Quasi-Static Constant-Radius Cornering Analysis

You perform a constant radius cornering analysis to evaluate your full vehicle's understeer and oversteer
characteristics. The constant radius cornering analysis holds the turn radius constant and varies the
vehicle velocity to produce increasing amounts of lateral acceleration.
This analysis:
• Uses a force-moment method to balance the static forces to 0 at each time step.
• Provides a faster solution than the corresponding dynamic analysis, but doesn't account for
transient effects, such as gear shifting.
• Can be useful when exploring the limit handling characteristics of the vehicle due to a
combination of both the longitudinal and lateral acceleration.
• Differs from the constant-velocity cornering analysis in that the turn radius is fixed and the
longitudinal velocity varies.
A CONSUB controls this analysis. For more information on CONSUB, see Welcome to Adams/Solver
Subroutines.
You can, for example, use the plot configuration file, mdi_fva_ssc.plt, in the shared Adams/Car database
to generate the plots that are typically of interest for this analysis. Otherwise, in Adams/PostProcessor,
you can create your own plots by selecting the desired requests and components.
To set up a constant-radius cornering analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, point to Quasi-Static Maneuvers, and
then select Constant-Radius Cornering.
2. Enter the necessary parameters as explained in the dialog box help for Quasi-Static Constant
Radius Cornering.
3. Select OK.
Quasi-Static Constant-Velocity Cornering Analysis

You perform a constant velocity cornering analysis to evaluate your full vehicle's understeer and
oversteer characteristics. The constant velocity cornering analysis holds the vehicle velocity constant and
varies the turn radius to produce increasing amounts of lateral acceleration. The input parameters for this
analysis are the same as the steady-state cornering analysis except that you specify the vehicle
longitudinal velocity instead of the turn radius.
This analysis:
• Uses a force-moment method to balance the static forces to 0 at each time step.
• Provides a faster solution than the corresponding dynamic analysis, but doesn't account for
transient effects, such as gear shifting.
296 Adams/Car
• Can be useful when exploring the limit handling characteristics of the vehicle due to a
combination of decreasing turn radius and longitudinal acceleration.
• Differs from the constant-radius cornering analysis in that the turn radius is not fixed.
A CONSUB controls this analysis. For more information on CONSUB, see Welcome to Adams/Solver
Subroutines.
You can use the plot configuration file, mdi_fva_ssc.plt, in the shared car database to generate the plots
that are typically of interest for this analysis.
To set up a constant-velocity cornering analysis:

then select Constant-Velocity Cornering.
2. Enter the necessary parameters as explained in the dialog box help for Quasi-Static Constant
Velocity Cornering.
3. Select OK.
Quasi-Static Force-Moment Analysis

You perform a force-moment analysis to evaluate the stability and handling characteristics of your
vehicle model. During the analysis, Adams/Car drives the vehicle at constant longitudinal speed and
performs a series of analyses at different side-slip angles and steer angles. The analysis:
• Represents a typical test in which the vehicle is constrained on a model flat-belt tire tester.
• Is based on the assumption that most of the stability and control characteristics can be obtained
from a study of the steady-state force and moments acting on the vehicle.
You can present the results of a quasi-static force-moment analysis in tabular form or as diagrams and
plots representing the computed forces and moments from the simulated test. The diagram created from
the forces and moments acting on the vehicle is a portrait of the vehicle-maneuvering potential for
specific operating conditions.
A CONSUB controls this analysis. For more information on CONSUB, see Adams/Solver Subroutines.
To set up a force-moment analysis:

then select Force-Moment Method.
2. Enter the necessary parameters as explained in the dialog box help for Quasi-Static Force-Moment
Method.
3. Select OK.
Quasi-Static Straight-Line Acceleration Analysis

A quasi-static straight-line acceleration analysis uses the static solver to perform multiple static analyses
with each increasing time step representing an increase in straight line acceleration/deceleration. This
technique uses a force-moment method to balance the static forces to 0 at each time step. This method
provides a quicker solution than the dynamic analysis but doesn't have transient effects, because of such
events as gear shifting.
To set up a straight-line acceleration analysis:

then select Straight-Line Acceleration.
2. Enter the necessary parameters as explained in the dialog box help for Quasi-Static Straight-Line
Acceleration.
3. Select OK.
Straight-Line Behavior Analyses

The analyses based on the Driving Machine focus on the longitudinal dynamics of the vehicle.
Adams/Car uses open- and closed-loop longitudinal controllers to drive your vehicle model.
Note: Adams/Car creates an event file (.xml) that defines the analysis and the different parameters.
It uses the .xml file for the analysis and then leaves it in the working directory so you can
refer to it as needed.
The straight-line-behavior analyses include:

• Acceleration
• Braking
• Power-off Straight Line
Acceleration Analysis
During an acceleration analysis, the Driving Machine ramps the throttle demand from zero at your input
rate (open loop) or you can specify a desired longitudinal acceleration (closed loop). You can specify
either free, locked, or straight-line steering. An acceleration analysis helps you study the anti-lift and anti-
squat properties of a vehicle.
To set up an acceleration analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, point to Straight-Line Behavior, and
then select Acceleration.
Acceleration.
3. Select OK.
298 Adams/Car
Braking Analysis
During a braking analysis, the Driving Machine ramps the brake input from zero at your input rate or lets
you specify a longitudinal deceleration (closed loop). You can also specify either free or locked steering.
The braking test analysis helps you study the brake-pull anti-lift and anti-dive properties of a vehicle.
To set up a braking analysis:

then select Braking.
Braking.
3. Select OK.
Power-off Straight Line Analysis

This analysis allows you to examine operating behavior and directional deviations caused by suddenly
lifting off the throttle pedal during a straight-line analysis. Typical results collected from the power-off
straight-line analysis include variations in heading direction and longitudinal deceleration. Optionally,
you can depress the clutch during the throttle lift-off. In this case, you specify the duration that it takes
to depress the clutch.
The Driving Machine drives the vehicle through two distinct phases:
• Quasi-static setup - The vehicle is set up in a straight line, to reflect the initial longitudinal
velocity condition.
• Power-off event - The throttle signal is stepped down, from the value of the initial set mini-
maneuver, to zero.
To set up a power-off straight line analysis:

then select Power-off Straight Line.
Power-Off Straight Line.
3. Select OK.
File-Driven Analysis
The file-driven analysis lets you run an analysis described in an existing event file (.xml).
Having direct access to event files lets you perform non-standard analyses on your full-vehicle assembly
because all you have to do is generate a new event file describing the analysis.
Learn about the Driving Machine.
Learn about Event Files.

To set up a file-driven analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, and then select File Driven Events.
2. Enter an Output Prefix.
3. If necessary, select a new Road Data File.
Press F1 for more detailed information on any of the selections in this dialog box.
4. Right-click in the Driver Control Files text box and select an XML Event file from the file
selection dialog box.
5. Select OK.
Working with Event Files (.xml)

You use event files (.xml) to describe the maneuvers you want the Driving Machine to perform.
Event files (.xml) describe how you want the Driving Machine to drive your vehicle during a maneuver.
The event file instructs the Driving Machine how fast to drive the vehicle, where to drive the vehicle (for
example, on a 80 m radius skidpad), and when to stop the maneuver (for example, when lateral
acceleration = 8 m/s2). Event files specify the kinds of controllers the Driving Machine should use for
each of the available control signals (steering, throttle, brake, gear, and clutch). An event file can
reference other files, primarily driver control data files (.dcd), to obtain necessary input data, such as
speed versus time. Learn about referencing .dcd files.
Event files organize complex maneuvers into a set of smaller, simpler steps called mini-maneuvers. An
event file defines the static-setup and a list of mini-maneuvers. For each mini-maneuver, the event file
specifies how the Driving Machine is to control the steering, throttle, brake, gear, and clutch.
Learn about event files:
• Creating Event Files
• Structure of Event Files
• Creating Mini-Maneuvers
• Referencing .dcd Files
• Example Event Files
Creating Event Files

Before you can run a Driving Machine full-vehicle analysis, you must create (or use) an event file that
contains one or more mini-maneuvers.
To set up Driving Machine mini-maneuvers:

1. From the Simulate menu, point to Full-Vehicle Analysis, and then select Event Builder.
The Event Builder dialog box has four major sections.
• File name, initial speed and gear, and units used in a selected field (shown at the bottom of the
dialog box).
300 Adams/Car
• Static Set-up and Gear Shifting Parameters.

• Mini-maneuver parameters on tabs for each of the five control signals with open-loop Control
Value, plus an additional tab for Conditions to end a mini-maneuver.
• Closed-loop parameters (used when a control signal has its Control Method set to machine.
2. From the File menu, select New.
3. Enter the file name in the text box and click OK. The name appears in the Event File text box
with a .xml extension. Initial default values appear in other text boxes.
4. If required, you can modify the initial Speed and Gear.
5. If required, you can modify values specified in the Static Set-up tab (for more information, see
dialog box help for Event Builder).
6. Select the Gear Shifting Parameters tab. If required, you can modify values specified on this tab
(for more information, see dialog box help for Event Builder).
7. If required, you can modify Machine Control control actions in the Trajectory Planning
Parameter tab and Machine Control longitudinal and lateral PID Controller gains in the PID's
Speed & Path and PID's Steering Output Parameters tabs (for more information, see dialog
box help for Event Builder).
8. For MINI_1 (the default initial mini-maneuver), make selections for each of the control signal
tabs (Steering, Throttle, Braking, Gear, and Clutch). Enter the necessary parameters as explained
in the dialog box help for Event Builder to create the mini-maneuver.
9. Click the Conditions tab and enter the parameters required to end the mini-maneuver (for more
information, see Specifying Conditions).
10. To create additional mini-maneuvers, click the button to the left of the mini-maneuver
Name. This displays the Table Editor for mini-maneuvers.
11. In Table Editor mode, enter the name of your new mini-maneuver in the Name text box at the
bottom of Event Builder.
12. Click Add. This adds a row to the Table Editor. You can edit any of the values in the row by
clicking in the appropriate cell (for more information, see dialog box help for Event Builder).
13. Continue adding mini-maneuvers as necessary.
14. To return to Property Editor mode, either double-click a name (in the Name column), or select
the name, right-click, and then select Modify with Property Editor.
15. When you've finished creating your event file, select Save.
After you create the file, you use it to run a file-driven analysis.
Learn about Structure of Event Files.
Using Event Files

After you use the Event Builder to create or modify an event file, you use that event file to run a file-driven
analysis.
Creating Mini-Maneuvers
A mini-maneuver is a set of smaller, simpler analysis steps, such as a straight-line mini-maneuver. Mini-
maneuvers are contained in event files (.xml).
To create a mini-maneuver, you must specify controls signals (steering, throttle, braking, gear, and
clutch) and its conditions. For each control signal, you specify the following:
• Actuator type (steering only)
• Control method
• Control type
• Control mode
Learn more:
• Specifying an Actuator Type
• Specifying a Control Method
• Specifying a Control Type
• Specifying a Control Mode
• Specifying Conditions
Specifying an Actuator Type

When defining the steering control for a mini-maneuver, you must specify an actuator type. You use the
actuator type to specify whether the Driving Machine steers the vehicle at the steering wheel or steering
rack and whether the Driving Machine uses a force or motion. For example, when you set Actuator Type
to rotation, the Driving Machine steers using a motion on the steering wheel.
The actuator type you select for steering determines how the Driving Machine interprets the units of other
parameters associated with the steering signal. For example, if you set Actuator Type to torque, the
Driving Machine interprets the amplitude argument for an open-loop sinusoidal input as torque (with
units of length*force). If you set Actuator Type to rotation, however, the Driving Machine interprets the
amplitude as an angle.
Arguments
force Driving Machine steers the vehicle by applying a force to the steering rack.
rotation Driving Machine steers the vehicle using a MOTION statement on the steering-wheel
revolute joint.
torque Driving Machine steers the vehicle by applying torque to the steering wheel.
trans Driving Machine steers the vehicle using a motion on the steering rack translational
joint.
302 Adams/Car
Specifying a Control Method

When defining any mini-maneuver, you must specify a control method for each control signal.
Arguments
• Open
• Machine
• SmartDriver
Open Control Method

The Driving Machine output for the control signal is a function of time, and you must specify the function
using the Control Type argument.
You cannot switch from an open-loop control mini maneuver to a human control mini maneuver. You
can, however, switch from human control in a preceding mini maneuver to open-loop control in a
subsequent mini maneuver.
Machine Control Method
Setting Control Method to machine specifies the vehicle path, speed profile, and other parameters used
by machine control.
If you set machine control for gear and clutch, you must also supply the maximum and minimum engine
speed. Machine control up-shifts to keep engine speed less than maximum and down-shifts to keep
engine speed greater than minimum.
If you set Control Method to machine for steering, then you should specify the target path, using the Steer
Control argument.
If you set Control Method to machine for throttle or brake, then you should specify the target speed
profile, using the Speed Control argument.
Note: • If you set Speed Control to lat_accel, then you must set Steer Control to skidpad.
• Machine control for throttle requires the use of machine control for braking.
Likewise, machine control for clutch requires machine control for gear.
Arguments
304 Adams/Car
Steer Control You can select one of the following:
• ay_s_map/ay_t_map - To define these closed-loop steering conditions, you can use a

Table/Plot editor that you access by selecting the Table Editor button.
• file -
• File Name - Enter the name of a file that contains the path data.
• path_map - To define this closed-loop steering condition, you can use a Table/Plot editor
that you access by selecting the Table Editor button. To define this closed-loop steering
condition, you can use a Table/Plot editor that you access by selecting the Table Editor
button.
• skidpad -
• Entry Distance - Specifies the length of the straight path preceding the turn. Note that
all paths are relative to the position of the vehicle at the end of the preceding mini-
maneuver. If the preceding mini-maneuver was a skidpad and you want the vehicle to
continue on the same circle in the current mini-maneuver, then specify zero (0) for Entry
Distance.
• Radius - Specifies the radius of the skidpad.
• Turn Direction - Specifies which way the vehicle turns when traveling forward.
• straight - The vehicle travels forward from its current position along the tangent of the path
from the preceding mini-maneuver. If the vehicle was under open-loop steering control in
the preceding mini-maneuver, then the vehicle travels forward in the direction of its current
velocity. You don't need to specify additional arguments.
Speed Contro You can select one of the following:
• ax_s_map
• ax_t_map
• file
• File Name - Enter the name of a file that contains the closed-loop data.
• lat_accel - Be sure to set Steer Control to skidpad.
• Lat. Acc. - Enter a value for the lateral acceleration.
• lon_accel
• Start Time
• Long. Acc - Enter a value for the longitudinal acceleration.
• maintain - The Driving Machine maintains the ending speed of the vehicle from the
previous mini-maneuver. If this mini-maneuver is the first in the experiment, then the
Driving Machine maintains the initial speed set in the EXPERIMENT block.
• Velocity
• speed_s_map
• speed_t_map
• vel_polynomial
• Velocity - Specifies the vehicle speed as polynomial of time. The Driving Machine
computes the speed using the following relation:
IF (Time < START_TIME):
SPEED = VELOCITY
IF ( TIME START_TIME ):
SPEED = VELOCITY +
ACCELERATION*(TIME - START_TIME)+
1/2*JERK*(TIME-START_TIME)**2
where START_TIME is the starting time relative to the beginning of the mini-maneuver.
Specify the following arguments:
VELOCITY = value <length/time>
ACCELERATION = value <length/time2>
JERK = value <length/time3>
START_TIME = value <time>
Note that JERK is the time rate of change of acceleration. JERK = d(acceleration)/dt.
• Acceleration
• Jerk
• Start Time
You can use a Table/Plot editor to define the various maps of speed and acceleration expressed as a
function of time or distance traveled.
306 Adams/Car
SmartDriver Control Method

When you set Control Method to SmartDriver, you must also specify the Control Mode, the task, course
file, as well as the maximum driving, braking, and turning accelerations.
Arguments
Task Select one of the following:
• user_defined - Set your own vehicle limits.

• vehicle_limits - Use the maximum vehicle limits.
Course File Displays the name of a .xml or .drd file that describes the path over which the
Driving Machine or Adams/SmartDriver drive the vehicle.
Select to choose a course file.
Max Driving Acc Enter the maximum driving acceleration index. Valid values are 0 to 100.
Max LH Turn Acc Enter the maximum left turn acceleration index. Valid values are 0 to 100.
Max Braking Acc Enter the maximum braking acceleration index. Valid values are 0 to 100.
Max Braking Acc Enter the maximum braking acceleration index. Valid values are 0 to 100.
Max RH Turn Acc Enter the maximum right turn acceleration index. Valid values are 0 to 100.
Specifying a Control Type

For any of the control signals (steering, throttle, braking, and so on), when you set Control Method to
open, Adams/Car enables the Control Type option.
Arguments
constant The Driving Machine inputs a constant signal to your vehicle model.
• Control Value - Enter a real number.

data_drive Specifies that the control signal comes from a driver control data file (.dcd), which you
n specify. The Driving Machine opens the .dcd file and reads the appropriate data.
• Dcd Filename - Enter the name of a .dcd file.

data_map Lets you specifies a series of discrete values as a function of time. Click the Open Loop
Demand Map button that appears to enter values and view a plot of the values you enter.
function Specifies that you should use any valid Adams/Solver function expression based on time.
• Function - Enter a time-based function. For example:

C20.0*SIN(2*PI*TIME)
where TIME is the simulation time.
impulse The Driving Machine outputs an impulse to your vehicle constructed from a pair of cubic
step functions. To define the impulse, you must specify the following arguments:
• Start Time - The starting time of the impulse relative to the beginning of the
mini-maneuver. For example, if the mini maneuver starts at 1.2 seconds
simulation time and Start Time = 0.3 seconds, then the impulse begins at 1.5
seconds simulation time.
• Duration - The length in time of the impulse.
• Maximum Value - The height of the impulse. The impulse reaches its
maximum value relative to the start time at half the duration.
Adams/Car computes the IMPULSE function as follows:
Let T1 = ( TIME - START_TIME ) / DURATION/2.0

Let T2 = ( TIME - (START_TIME + DURATION/2.0) ) /
DURATION/2.0
IF ( T1 < 0.0 ):
OUTPUT = 0.0
IF ( 0 < T1 < 1.0 ):
OUTPUT = MAXIMUM_VALUE * ( 3.0 - 2.0*T1)*T1*T1
IF ( T1 > 1.0 and T2 < 1.0 )
OUTPUT = MAXIMUM_VALUE( 1.0 - (3.0 -2.0*T2)*T2*T2 )
IF ( T2 > 1.0 );
OUTPUT = 0.0
The following plot illustrates the IMPULSE function:

308 Adams/Car
ramp The Driving Machine supplies a ramp input. To define the ramp, you must supply the
following arguments:
• Start Time
• Ramp Value
Adams/Car computes the RAMP function as follows:
If ( time < START_TIME ) input = INITIAL_VALUE

if ( time > START_TIME ) then
input = INITIAL_VALUE + ( time - START_VALUE) * RAMP_VALUE
Note: When using the RAMP function, the output value grows for the duration of the
mini-maneuver.
sine The Driving Machine outputs a single-cycle sinusoid to your vehicle smoothed at the
beginning and end by cubic-step functions. The duration of each cubic-step function is
1/100*CYCLE_LENGTH.
• Start Time - The starting time of the sinusoid relative to the beginning of the
mini-maneuver. For example, if the mini-maneuver starts at 2.1 seconds
simulation time and Start Time = 0.3 seconds, then the sinusoid begins at 2.4
seconds simulation time.
• Amplitude - The amplitude of the sinusoid.
• Cycle Length - The length of time to complete one cycle of the sinusoid.
Adams/Car computes the SINE function as follows:
Let T1 = (TIME - START_TIME) / CYCLE_LENGTH / 100.0

Let T2 = (TIME - (START_TIME + 0.99*CYCLE_LENGTH)) /
CYCLE_LENGTH / 100.0
IF ( T1 < 0.0 ):
OUTPUT = INITIAL_VALUE
IF ( 0 < T1 < 1.0 ):
OUTPUT = INITIAL_VALUE + AMPLITUDE *
SIN( 2.0*PI*(TIME - START_TIME)/ CYCLE_LENGTH) * (3.0 -
2.0*T1)*T1*T1
IF ( T1 > 1.0 and T2 < 0.0 )
SIN( 2.0*PI*(TIME - START_TIME)/ CYCLE_LENGTH)
IF ( T1 > 1.0 and 0.0 < T2 < 1.0 )
SIN( 2.0*PI*(TIME - START_TIME)/ CYCLE_LENGTH) (1.0 - (3.0
-2.0*T2)*T2*T2)
IF ( T2 > 1.0:
OUTPUT = INITIAL_VALUE
The following plot illustrates the SINE function:

310 Adams/Car
step The Driving Machine inputs a STEP5 function to your vehicle model based on the
following input parameters, which you must supply:
• Start Time
• Duration
• Final Value
Adams/Car computes the STEP function as follows:
If ( time < START_TIME ) then input = INITIAL_VALUE

if ( START_TIME < time < START_TIME + DURATION ) then
Let T = (TIME - START_TIME)/DURATION
input = INITIAL_VALUE + ( FINAL_VALUE - INITIAL_VALUE)*( 3 - 2*T)*T**2
if ( time > START_TIME + DURATION ) then input = FINAL_VALUE
Note that START_TIME is relative to the beginning of the mini-maneuver.

swept_sine Sweeps the frequency of the output from the initial frequency to a maximum frequency
at a given rate. Once the maximum frequency is achieved, the frequency remains
constant. The amplitude of the swept sine function is fixed. To define swept sine, you
must supply the following parameters:
• Start Time - The starting time of the function, measured from the beginning of
the mini-maneuver.
• Amplitude - The amplitude of the swept-sine function.
• Initial Frequency - The starting frequency of the swept-sine function in
<cycles/time>.
• Frequency Rate - The rate the frequency is swept from the initial frequency to
the maximum frequency <cycles/time/time>.
• Max Frequency - The maximum frequency of the swept sine function in
<cycles/time>.
The following plot illustrates the SWEPT_SINE open-loop function:
Specifying a Control Mode

If you set Control Method to open, you must also define the Control Mode as either absolute or relative.
If Control Method is not open, Control Mode is always absolute. With all open-loop maneuvers, the value
of the preceding mini maneuver is used as the starting point for the next mini-maneuver. This is
irrespective of whether you set Control Mode to relative or absolute. For example, your vehicle is driving
on a skid pad at 30 mph, with 20o of steering wheel, when the first mini-maneuver is finished. The
steering-wheel angle for the next mini maneuver will be 20o.
You can set Control Mode for the following open-loop control types:
• constant
• data_driven
• data_map
• step
312 Adams/Car
For these control types, Control Mode changes the meaning of the FINAL_VALUE input in the .xml.
Control Mode has no effect on the rest of the Control Types, nor on machine, human, and SmartDriver
control methods.
The relative and absolute methods allow you to define the steering-wheel angle for the end of the next
mini maneuver.
Arguments
Absolute Indicates that the final value is absolute. For example, for a step input to the steering
where the initial steering is 10 degrees and the final value is 50 degrees, the steer at the
end of the step equals 50 degrees.
Relative Indicates that the final value is relative to the initial value. For example, for a step input
to the steering where the initial steering is 10 degrees and the final value is 50 degrees,
the steer at the end of the step equals 60 degrees.
Here is another example. If at the beginning of the mini-maneuver the steering is 20o, the steering Control
Method is set to open, the Control Type is set to step, and the FINAL_VALUE = 90.0, then
FINAL_VALUE is relative to INITIAL_VALUE, and the steering angle at the end of the step input is
110o. If, however, Control Mode is set to Absolute, then the steering angle at the end of the step input
equals the FINAL_VALUE of 90o
Specifying Conditions
Conditions specify when one mini-maneuver ends so the next one can begin. For example, you might end
a mini-maneuver when the vehicle speed reaches 100 kph. You can also group end conditions together.
For example, you might end a mini-maneuver when the vehicle speed reaches 100 kph and the lateral
acceleration exceeds 5 m/s2.
The event file supports conditions based on time, distance, velocity, acceleration, and many other vehicle
control variables. Conditions reference a measure or solver variable by name to measure a given quantity
in the model.
The Conditions tab of the Event Builder shows one possible condition at a time in Property Editor mode.
To add conditions or view other defined conditions, click the button to the left of the condition name to
enter Table Editor mode. In Table Editor mode, you can see all defined conditions, add new conditions,
modify conditions, or delete conditions. The Table Editor mode also lets you see the full set of arguments
available for each condition.
Arguments
Then, the end condition is satisfied if:

5 - 0.1 < Lateral acceleration < 5 + 0.1
Name Filter Filters the listed conditions based on the substring you specify.
Name Shows the condition name (not editable).
314 Adams/Car
Type Quantity that is measured. Can be:
• curvature - Curvature of the vehicle trajectory

• distance - Total distance traveled by the vehicle during a mini-maneuver
• engine_speed - Angular velocity of the engine crankshaft in number of
revolutions per minute (rpm)
• lat_accel - Vehicle lateral acceleration
• lat_dis - Vehicle lateral displacement with respect to the global reference
system
• lat_velocity - Vehicle lateral velocity
• loc_accel - Vehicle longitudinal acceleration
• lon_dis- Vehicle longitudinal displacement with respect to the global
reference system.
• pitch_angle - Angular displacement about the vehicle's lateral axis
• pitch_rate - Time derivative of pitch angle
• rack_tra_vel - Time derivative of rack displacement
• rack_travel - Displacement in the steering rack joint
• radius - Radius of vehicle trajectory
• roll_angle - Angular displacement about the vehicle's longitudinal axis
• roll_rate - Time derivative of vehicle roll angle
• side_slip_ang - Angle between the ground-plane projections of the vehicle's
longitudinal axis and its velocity vector
• stee_ang_vel - Time derivative of steering angle
• steering ang - Angular displacement in the steering-wheel joint
• time - Simulation time
• user_defined - Not implemented
• velocity - Vehicle longitudinal velocity
• vert_accel - Vertical acceleration of driver reference frame with respect to
origo marker
• vert_dis - Vehicle vertical displacement with respect to the global reference
system
• vert_velocity - Vehicle vertical velocity with respect to the global reference
system
• yaw_accel - Angular acceleration about the vehicle's vertical axis
• yaw_angle - Angular displacement about the vehicle's vertical axis
• yaw_rate - Angular velocity about the vehicle's vertical axis
Test • == - Equal to trigger value

• >> - Greater than the trigger value
• << - Less than the trigger value
• |==| - Absolute type value is equal to the trigger value
• |<<| - Absolute type value is less than the trigger value
• |>>| - Absolute type value is greater than the trigger value
Trigger Value The value against which the measure is tested to determine if the end condition is
satisfied. Except for ENGINE_SPEED, which uses RPMs, you must specify the
value in modeling units as defined in the event file.
Error The allowed difference between measure and value that still satisfies the test. Error
must be positive and be specified in modeling units as defined in the event file
(except engine_speed, which is in RPMs). For example, if the cells of the table are:
Filter Time The test must be satisfied continuously over the filter time to satisfy the end
condition. filter time must be positive.
Delay Time Once the end condition is satisfied, delay the end of the mini-maneuver by delay
time.
Group Name You specify a name to group conditions together. All conditions having the same
group name must be satisfied simultaneously to end a mini-maneuver. For example,
you might specify two end conditions:
• Longitudinal velocity equal to 20 m/s

• Lateral acceleration greater than 5 m/s/s Then you place the specified end
conditions in the group mygroup. To end the mini-maneuver, the
longitudinal velocity must be 20 m/s and the lateral acceleration must be
greater than 5 m/s/s.
Condition Type Select a condition type:
• abort - When met, it causes the simulation to stop.

• end - When met, it causes the simulation to proceed to the next mini-
maneuver, if one is defined.
• info - Not yet implemented
• warning - Not yet implemented
Referencing .dcd Files

You can reference driver control data (.dcd) files through XML event files to specify data for the method
of control of the vehicle. When referencing .dcd files, event files can obtain two types of data:
• Open-loop data - Includes steering-wheel angle, throttle position, brake pressure, gear, and
clutch position tabulated against time or distance traveled.
316 Adams/Car
• Closed-loop data - Uses data from the dcd file to fix the vehicle path and speed for a mini-
maneuver. Examples of closed-loop data are the vehicle position {x, y} versus time (t) or path
{x, y} versus distance traveled (s). Closed-loop data can also include vehicle speed and lateral
acceleration which the Machine Control integrates to determine the desired vehicle path and
speed.
You reference .dcd files in your event files by selecting Machine for Steering/Throttle and Braking and
browsing your databases for dcd files in the File Name text box. That is, using the file option for Machine
Control means that you want to obtain control data from a .dcd file.
Example Event Files

In Adams/Car, XML became the default file format for Driving Machine analyses. Although Adams/Car
still supports driver control files (.dcf), it now automatically converts them to .xml. The .xml files are
referred to as event files. Although the contents of the two files types look different, they contain the same
event information. You work with .xml files through the Event Builder.
In the shared Adams/Car database, we provide files in both .dcf and .xml format. These files are stored
in the driver_controls.tbl directory/table.
Adams/SmartDriver Analysis
The Adams/SmartDriver analysis lets you run an analysis described in an existing event file (.xml). You
can drive the vehicle at the acceleration limits or some percentage of those limits.
To set up an Adams/SmartDriver analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, and then select Adams/SmartDriver.
2. Press F1 and then follow the instructions in the dialog box help for Full-Vehicle Analysis:
SmartDriver.
3. Select OK.
Tilt Table Analysis

The Truck plugin includes a new testrig, .__TILT_TABLE_TESTRIG. This testrig allows static and
dynamic tilt tests similar to those performed at many proving grounds. Typically these tests are used to
estimate a vehicle's aggregate CG height and rollover point.
Setting up the Analysis

To perform a tilt test simulation, you first must build a full-vehicle assembly referencing the new
.__TILT_TABLE_TESTRIG. The testrig includes joint primitives at each of the downhill wheels to
prevent the vehicle from sliding off the table. These joints attach to the wheels automatically by use of
communicators. The testrig is set up to attach to wheels from subsystems with the following minor roles:
front, rear, rear_2, tag_axle, trailer_1, trailer_2. In this way the same testrig may be used with vehicle
assemblies containing from two to six axles.
To set up a tilt table analysis:

1. From the Simulate menu, point to Full-Vehicle Analysis, and then select Tilt Table Analysis.
2. Enter the necessary parameters as explained in the dialog box help for Full-Vehicle Analysis: Tilt
Table.
3. Select OK.
318 Adams/Car
Using the Driving Machine

You use the Driving Machine to perform full-vehicle analyses. The Driving Machine drives your virtual
vehicle according to your instructions much like a test driver would drive an actual vehicle. The Driving
Machine steers the vehicle, applies the throttle and brake, and shifts gears (using the clutch). You can
instruct the Driving Machine to switch between open- and closed-loop (Machine Control and
SmartDriver) control during a simulation.
Using open-loop control, the Driving Machine can, for example, input a swept-sinusoid to the steering
or play back recorded steering, throttle, brake, gear, and clutch signals as input to your virtual vehicle.
This lets you use data acquired in real tests as input to your virtual vehicle.
Using Machine Control, which replaced DriverLite, the Driving Machine can, for example, steer a vehicle
around a skid-pad, while gradually increasing speed. You use Machine Control to have the vehicle follow
a path and maintain a specified longitudinal speed or acceleration. Inputs to Machine Control are the
target path the vehicle should follow and/or a target speed or longitudinal acceleration vs time or distance.
Using Adams/SmartDriver, you can determine the maximum performance of a vehicle as it follows a
specified path. Adams/SmartDriver is an extra-cost, add-on product that lets you specify a desired
performance criterion (for example, 100%, 80%, 50% of vehicle limits) for the vehicle as it follows the
defined path. Adams/SmartDriver then creates a target longitudinal speed along the path that meets the
desired performance criterion.
Adams/Car stores your instructions to the Driving Machine in an XML event file. You can use the Event
Builder (or any text editor) to create or modify an event file.
Note: We changed the Driving Machine architecture to support XML files as the default, while
maintaining support for legacy dcf files. If you specify a dcf file, Driving Machine
automatically converts it to an XML file in the working directory so you can use the Event
Builder to review and modify the event.
Driving Machine reads recorded open-loop signals and vehicle path and velocity data from text files
named driver control data files (.dcd).
To help you calculate the control signals, Adams/Solver passes vehicle information such as position,
velocity, and acceleration, to the Driving Machine. The Driving Machine provides a means for defining
and passing sets of command signals, feedback signals, and parameters for each of the five control signals
(steering, throttle, brake, gear, and clutch).
The following figure shows how the Driving Machine works in a virtual prototyping model.
Learn more about the Driving Machine:

• What You Can Do with the Driving Machine
• How You Benefit from Using the Driving Machine
• Steps in Using the Driving Machine
• Creating Paths for Driving Machine
• Data Flow in Driving Machine
• Template Updates
• Limitations to the Driving Machine
320 Adams/Car
What You Can Do with the Driving Machine

Using the Driving Machine, you can:
• Input the vehicle path {x, y} and speed, and use closed-loop, Machine Control, to steer a vehicle
along a path or follow a desired velocity or both (the table, Closed-Loop Data in .dcd Files, lists
all potential inputs).
• Input a variety of open-loop functions, such as swept-sine and impulse, to the steering, throttle,
or brake.
• Input recorded steering, throttle, brake, gear, and clutch signal to your model.
• Stop a simulation, switch controllers, and change output-step size based on reaching a target
lateral acceleration, longitudinal velocity, or distance traveled.
• With the optional Adams/SmartDriver closed-loop control, you can specify a desired vehicle
performance level, such as 100% or 50%, and input a path and speed as you would for Machine
Control.
How You Benefit from Using the Driving Machine

When working with the Driving Machine, you have the following benefits:
• You save the time you previously needed to set proper gains for closed-loop controllers. The
Driving Machine incorporates proprietary control algorithms from MSC.Software.
• You shorten simulation times by ending simulations based on targets for lateral acceleration,
longitudinal velocity, and distance traveled.
• You gain flexibility in how you input vehicle paths and desired velocity profiles, choosing from
recorded data stored in external files or parametrically generated paths and profiles based on a
few simple inputs.
Steps in Using the Driving Machine

Follow these steps to use the Driving Machine:
1. Assemble a full-vehicle model with the .__MDI_SDI_TESTRIG test rig or open an existing full-
vehicle assembly.
2. Do either of the following:
• Use a predefined analysis (from the Simulate menu, point to Full-Vehicle Analysis, and then
point and select the predefined analysis you want).
• Create your own event file to perform your specific set of simulations (from the Simulate
menu, point to Full-Vehicle Analysis, and then select Event Builder).
Tips on Creating Paths for Driving Machine

Applies to Machine Control and SmartDriver
The following are tips for creating paths for the Driving Machine.
Remove Excess Noise

The path referenced in the event file is the TARGET path used by the steering controller with no
smoothing or other manipulation to alter the path shape. Therefore, any irregularities included in the path
description, such as the noise coming from telemetry data, are seen by the steering controller and can
produce a quickly changing steering input. Further, because the Driving Machine computes the steering
input at discrete time steps (equal to the selected output step), and the steering input is typically applied
through a MOTION on the steering wheel, a quickly changing steering input will produce a noisy
steering torque signal. Therefore, to minimize noise in the steering torque you may want to preprocess
the path data to remove noise and/or add corner cutting, and then store the resulting path in a .dcd file.
Path Point Spacing Important

In addition, path points spaced too far apart can also produce a noisy steering torque. To obtain the best
results from the controller with the lowest level of noise, we recommend that the largest distance between
points in the path be less than the minimum distance traveled by the vehicle in one output step. That is,
the distance travelled between two consecutive output steps should be greater than the distance between
any two path points. For example, if the maneuver minimum velocity is 10 m/s and the recommended
time step size is used (0.01 seconds), the suggested path point spacing is 0.1 meter. We recommend that
you create your paths for the lowest speed you expect to run, because small path point spacing is suitable
for both low- and high-speed events.
Also, note that if the distance between path points is greater than 0.5 meters, the controller re-samples
the path to a path point spacing of 0.5 meters. (This is the current default. You can use an API to modify
this setting.)
The following plots show the effect on steering input and steering torque using path point spacings of 0.5
m and 0.05 m at low and high speed:
• Figure 1 - Path following at low speed (around 5 m/s, output step size 0.01 seconds)
• Figure 2 - Path following at standard speed (from 20 to 40 m/s, output step size 0.01 seconds)
322 Adams/Car
Low Speed Test
Standard-speed Test
When speed increases, the difference in path point spacing has no effect.
Data Flow in Driving Machine

When you submit a simulation using the Driving Machine, Adams/Car generates an Adams/Solver
command file (.acf), an Adams/Solver dataset file (.adm), and an XML event file. The .acf file instructs
Adams/Car Solver to read the dataset file and event file (using abgVDM::EventInit CONSUB). It also
instructs Adams/Car Solver to perform maneuvers described in the event file (using
abgVDM::EventRunAll CONSUB). Adams/Car Solver then provides the standard output files: .msg,
.res, .gra, and .out.
The event file (.xml) describes the maneuver you want to perform as a list of mini-maneuvers. The event
file can reference one or more driver control data (.dcd) files. Driver control data files contain either
closed-loop or open-loop data. An example of closed-loop data is vehicle path and speed (the table,
Closed-Loop Data in .dcd Files, lists all potential inputs). Open-loop data are steering, throttle, brake,
gear, and/or clutch signals versus time.
The following figure summarizes the data flow specific to the Driving Machine.
Template Updates
The 2005 Driving Machine employs vehicle controllers developed by MSC.Software, commonly known
as Machine Control, which replaces DriverLite functionality, and Adams/SmartDriver. To better control
324 Adams/Car
speed and path, the 2005 Driving Machine needs additional information about the vehicle. In particular,
the speed controller uses a feed-forward function to ensure quick and accurate response. However, this
requires information about the available engine brake torque, engine drive torque, brake torque, and
aerodynamic drag. You supply this information by creating new output communicators in your templates.
In addition, you must also enter vehicle parameter data, such as overall steering ratio that is stored in the
assembly file.
For more information, see Working with Templates->Template Updates.
Limitations of the Driving Machine

The Driving Machine has the following limitations:
• It can only accurately steer a vehicle when positive steer inputs steer the vehicle to the left.
• It can only drive the vehicle within the vehicle's limits of lateral and longitudinal acceleration,
and longitudinal velocity.
Working with Driver Control Data Files (.dcd)

You use driver control data (.dcd) files to specify:
• The closed-loop data, such as path and speed you want a vehicle to follow.
• The open-loop data, which is the steering, throttle, brake, gear, and clutch signals versus time
you want to input to a vehicle.
To use a .dcd file, you must reference it from an event file (.xml).
Driver control data files contain data for use by the Driving Machine. To instruct the Driving Machine to
use the data from a .dcd file, you must reference the file in an event file (.xml). An excerpt from a .xml
showing a reference to a .dcd file looks like the following:
(STEERING)
METHOD = 'OPEN'
CONTROL_TYPE = 'DATA_DRIVEN'
FILE_NAME = 'my_data.dcd'
Driver control data files hold two types of data:
• Open-loop data - Data that is played back as input to the vehicle without concern for how fast or
where the vehicle goes. Such data includes: steering-wheel angle, throttle, brake, gear, and clutch
signals. Examples of open-loop data include steering-wheel angle versus time, and throttle
position versus time.
• Closed-loop data - Data that specifies exactly where and how fast the vehicle should go. An
example of closed-loop data is vehicle x and y position versus time. You can specify closed-loop
data in several forms. For example, curvature and velocity versus distance traveled, or lateral
acceleration and longitudinal acceleration versus time. You specify the type of data using the
SPEED_CONTROL and STEERING_CONTROL arguments in the .dcd file.
Learn about .dcd files:

• Structure of .dcd Files
• Specifying Closed-Loop Data
• Creating .dcd Files
• Example .dcd File
Structure of Event Files

Event files contain the following type of information:
• Name of Event File
• Speed
• Gear Number
• Static Setup
• Gear Shifting Parameters
• Mini-Maneuvers for the Experiment
Name of Event File

When you assign a name to the event file, Adams/Car automatically generates a file with extension .xml
in the working directory and updates the Event File text box with the file name you entered.
Speed
Represents the initial vehicle speed for the maneuver.
Gear Number
Represents the initial gear position for the maneuver.
Static Setup
You can specify static-setup analyses that remove start-up transients that can eliminate mini-maneuvers
that you might normally use to set up a vehicle for cornering maneuvers. For example, in the past, to
perform a brake-in-turn analysis you might have run a transient mini-maneuver to have the vehicle turn-
in and reach static-setup on given turn, at a given speed/lateral acceleration, before starting to brake the
vehicle. This approach is equivalent to a test driver on a proving ground, driving at a steady speed and in
a steady-state condition (vehicle has no transients) before starting a dynamic maneuver (braking,
acceleration, steering, and so on). Now you can perform a much faster (less CPU time) static-setup
analysis.
You can set static setup to any of the arguments described next.
326 Adams/Car
Arguments
none Adams/Car does not perform a static equilibrium analysis. Rather, it locks the wheel
rotations and then performs an acceleration initial-conditions analysis, which
initializes Adams/Tire. Adams/Car then deactivates the wheel lock joint primitives
before executing the first mini-maneuver.
normal Locks the wheel rotations using joint primitives, but leaves the body free to move in
the fore-aft, lateral, and yaw directions. Soft springs (1 N/m and 10 N m/radian),
introduced by Adams/Tire just for static equilibrium, acting in all directions
between each wheel center and ground limit, but do not prevent, body yaw, fore-aft,
and lateral displacements. Then, before executing the first mini-maneuver,
Adams/Car deactivates the joint primitives to unlock the wheel rotations, and
Adams/Tire removes the soft springs.
The transitional and torsional stiffnesses supplied by the tire act in all directions
(x,y,z). Without these stiffnesses, the vehicle would have a neutral equilibrium
position in the x-y plane of the road.
Note that Adams/Chassis does not support normal.

settle Locks the body's fore-aft, lateral, and yaw displacement using joint primitives and
performs a static equilibrium to settle the vehicle on the road. Then, before
executing the first mini-maneuver, Adams/Car deactivates the joint primitives.
For example selecting settle and specifying an initial velocity of 27777.78 mm/s is
equivalent to driving a stake vertically through the vehicle body and constraining the
body to move vertically about the stake. It allows the vehicle to roll (cornering) and
pitch (braking), but does not allow rotation about the axis of the stake (Yaw). When
the vehicle is released from this condition, it should be relatively well balanced to
remove initial transient effects. An imbalance in the tire forces could, however,
cause a slight steering effect. If you want to remove this effect, we recommend that
you use straight.
skidpad Locks the body's fore-aft and lateral position using a joint primitive. Adams/Car
adjusts the steering and throttle so the vehicle's yaw rate, lateral acceleration, and
speed match those prescribed by the initial radius, initial turn direction, and the
initial lateral acceleration or initial speed. You must specify the initial radius and
turn direction. Also, you must supply either the initial lateral acceleration or the
initial speed.
For example, selecting skidpad and specifying an initial radius, turn direction, and
initial speed effectively performs a settle static setup followed by a straight static
setup. Then, Adams/Car adjusts the steering and throttle so that the vehicle's yaw
rate, lateral acceleration, and speed match those prescribed in the event file. By
carefully observing the .msg file Adams/Solver produces, you can see the model
manipulation occur.
straight Locks the body's fore-aft and lateral position using a joint primitive. Adams/Car
adjusts the steering (so that the vehicle's yaw rate and lateral acceleration are zero)
and the throttle and/or brake (to balance any aerodynamic drag and scrub that the
tires produce and to match the specified initial longitudinal acceleration). Then,
before executing the first mini-maneuver, Adams/Car deactivates the joint
primitives.
The maneuver has two separate static analyses: the first uses the settle method, the
second uses a force balance on the vehicle body to ensure that the net lateral force
is negative (the vehicle is traveling in a straight line) and that longitudinal forces are
zero. The values for steering-wheel angle, throttle position, and so on, are used as
initial conditions for the subsequent dynamic analysis.
Gear-Shifting Parameters
Define the gear-shifting properties and the shape of the upshift and downshift curves for throttle and
clutch signals.
Arguments
Throttle Fall Time Delta time of the step function for the descending curve of the throttle
signal (> 0.0)
Clutch Fall Time Delta time of the step function for the descending curve of the clutch signal
(> 0.0)
Throttle Raise Time Delta time of the step function for the ascending curve of the throttle signal
(> 0.0)
Clutch Raise Time Delta time of the step function for the ascending curve of the clutch signal
(> 0.0)
328 Adams/Car
Shift Time Duration of the gear shifting event (> 0.0)

RPM Control Enables an algorithm for RPM limiting during gear shifting
Mini-Maneuvers
The Driving Machine runs each mini-maneuver in the order listed, until the list is ended or a mini-
maneuver is terminated.
For each mini maneuver, you must specify a name for the mini-maneuver, the control signals (steering,
throttle, braking, gear, and clutch), as well as the condition for ending the mini maneuver. Learn more
about Creating Mini-Maneuvers.
Structure of .dcd Files

Driver control data (.dcd) files use a TeimOrbit File Format similar to other Adams/Car property files.
Driver control data files must contain these data blocks:
• MDI_HEADER block - Identifies the file as a .dcd file and provides version information.
• UNITS block - Identifies the units of the data contained in the .dcd file.
The driver control data file must also contain at least one of two data blocks:
• OPEN_LOOP block - Specifies the steering, throttle, brake, gear, and clutch inputs to the
vehicle.
• CLOSED_LOOP block - Specifies the path or the speed of the vehicle, or both.
Note: Driver control data files can contain both open-loop and closed-loop blocks.
The following is an example .dcd file:

[MDI_HEADER]
FILE_NAME = iso_lane_change.dcd
FILE_TYPE = 'dcd'
FILE_VERSION = 1.0
FILE_FORMAT = 'ASCII'
(COMMENTS)
{comment_string}
'Example .dcd file containing steering path for iso lane change'
[UNITS]
LENGTH = 'meters'
FORCE = 'newton'
MASS = 'kg'
TIME = 'sec'
ANGLE = 'radians'[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.586
-102.0 3.586
-115.0 3.586
-140.0 0.172
-147.0 0.172
-155.0 0.172
-162.0 0.172
-170.0 0.172
-200.0 0.172
-300.0 0.172
[OPEN_LOOP]
ORDINAL = 'time'
(DATA)
{ time steering throttle brake gear clutch }
0.0000E-01 0.1465E-02 0.3016E-02 0.0000E+00 0.3000E+01 0.0000E+00
0.1000E-01 0.1465E-02 0.3016E-02 0.0000E+00 0.3000E+01 0.0000E+00
0.2000E-01 0.1541E-02 0.3193E-02 0.0000E+00 0.3000E+01 0.0000E+00
0.3000E-01 0.1633E-02 0.3748E-02 0.0000E+00 0.3000E+01 0.0000E+00
0.4000E-01 0.1730E-02 0.5697E-02 0.0000E+00 0.3000E+01 0.0000E+00
0.5000E-01 0.1865E-02 0.1197E-01 0.0000E+00 0.3000E+01 0.0000E+00
0.6000E-01 0.1959E-02 0.2062E-01 0.0000E+00 0.3000E+01 0.0000E+00
0.7000E-01 0.2108E-02 0.4782E-01 0.0000E+00 0.3000E+01 0.0000E+00
0.8000E-01 0.2190E-02 0.8150E-01 0.0000E+00 0.3000E+01 0.0000E+00
0.9000E-01 0.2180E-02 0.1329E+00 0.0000E+00 0.3000E+01 0.0000E+00
0.1000E+00 0.2011E-02 0.2006E+00 0.0000E+00 0.3000E+01 0.0000E+00
Specifying Closed-Loop Data

When reading the following specification you should observe the following rules:
• [ ] = Data block
• ( ) = Sub-block
• { } = Data header
• || = Options, and means OR
• && = And
The nomenclature is:

• lon_vel = Vehicle longitudinal velocity
• lon_acc = Vehicle longitudinal acceleration
• lat_acc = Vehicle lateral acceleration
330 Adams/Car
• distance = Arc-length or distance traveled along the path

• curvature, k=1/radius
• x = X position of vehicle relative to ISO-Earth Axis System
• y = Y position of vehicle relative to ISO-Earth Axis System
• { } = Set of inputs
The following table summarizes the closed-loop data that a .dcd file can contain:
• The columns represent speed-control options from the driver parameters array.
• The rows represent the steering control options from the driver parameters array.
• The intersections give the data contained in the .dcd file and, therefore, the data input to the
funnel to produce {x, y, lon_vel} as needed by Driving Machine.
• p1 refers to the first parameter in the steering and throttle (speed) driver parameters arrays
(initial conditions arrays) in the dataset Adams/Car outputs.
Closed-Loop Data in .dcd Files
SPEED_CONTROL path
STEERING_CONTROL none lon_vel (p1=0) lon_acc (p1=1) lat_acc (p1=2) (p1=3)
none NOT {(distance or time), {(distance or time), NOT VALID NOT
VALID lon_vel} lon_acc} VALID
curvature (p1 = 0) {distance, {(distance or time), {(distance or time), {(distance or time), NOT
curvature} curvature, lon_vel} curvature, lon_acc} curvature, lat_acc} VALID
path (p1 = 1) {x, y} {x, y, lon_vel} {x, y, lon_acc} {x, y, lat_acc} {x, y,
time}
lat_acc (p1 = 2) NOT {distance or time, {distance or time, NOT VALID NOT
VALID lat_acc, lon_vel} lat_acc, lon_acc} VALID
Creating .dcd Files

You can use the sample .dcd files that we provide or you can create your own .dcd files.
To create .dcd files:

1. You can use one of three methods to create .dcd files:
• Run a physical or virtual test and record the data that you obtain from the five actuator
application areas.
• In a text editor, modify the sample .dcd files that we provide for you.
• Create a .dcd file using a text editor and following the specifications and format shown in
Specifying Closed-Loop Data and Example .dcd File Architecture.
2. Save the file and reference it when running File-Driven Analyses.
Example .dcd File

The following shows the architecture of a .dcd file and all the options you can set for a .dcd file. It
contains options, logic, and general rules that you must follow when creating a .dcd file.
[MDI_HEADER]
FILE_NAME = filename.dcd
FILE_TYPE = 'dcd'
FILE_VERSION = 1.0 FILE_FORMAT = 'ASCII'
(COMMENTS)
{comment_string}
'Any comment'
[UNITS]
LENGTH = 'meter' || 'millimeter' || 'centimeter' || 'kilometer' || etc.
FORCE = 'newton' || 'kilogram_force' || etc.
ANGLE = 'deg' MASS = 'kg'
TIME = 'sec'
[CLOSED_LOOP]
comment = string
steering_control = 'none' || 'curvature' || 'path' || 'lat_acc'
speed_control = 'none' || 'lon_vel' || 'lon_acc' || 'lat_acc' || 'path'
ordinal = 'distance' || 'time'
lon_vel_max = float
lon_vel_min = float
lon_acc_max = float
lon_acc_min = float
lat_acc_max = float
lat_acc_min = float
(DATA)
$ steering, speed
$ 1 Case{none, none} -- null case, no data required!!
$ 2 Case{none, lon_vel}
$ 3 Case{none, lon_acc}
$ 4 Case{none, lat_acc} -- NOT VALID
$ 5 Case{none, path} -- NOT VALID
{ ( distance || time ) && ( lon_vel || lon_acc ) }
$ 6 Case{curvature, none} -- Must have distance with curvature
{ distance && curvature }
$ 7 Case{curvature, lon_vel}
$ 8 Case{curvature, lon_acc}
$ 9 Case{curvature, lat_acc}
$10 Case{curvature, path} -- NOT VALID
{ ( distance || time ) && curvature && ( lon_vel || lon_acc || lat_acc )}
$11 Case{path, none}
$12 Case{path, lon_vel}
$13 Case{path, lon_acc}
$14 Case{path, lat_acc}
{ x && y && ( lon_vel || lon_acc || lat_acc ) }
$15 Case{path, path}
{ x && y && time }
$16 Case{lat_acc, none} -- NOT VALID
$17 Case{lat_acc, lon_vel}
$18 Case{lat_acc, lon_acc}
$19 Case{lat_acc, lat_acc} -- NOT VALID
$20 Case{lat_acc, path} -- NOT VALID
{ ( distance || time ) && lat_acc && ( lon_vel || lat_acc ) }
[OPEN_LOOP]
ordinal = 'time' || 'distance'
{distance || time steering throttle brake gear clutch}*
0.0 0.0 0.0 0.0 2 0.0
332 Adams/Car
0.1 0.0 0.0 0.0 2 0.0

*You can select distance or time and any combination of steering, throttle, brake, gear, and clutch.
Example corresponding to $ 2 Case{none,lon_vel}:

.....
[CLOSED_LOOP]
STEERING_CONTROL = 'NONE'
SPEED_CONTROL = 'LON_VEL'
ORDINAL = 'TIME'
(DATA)
{ TIME, LON_VEL }
0.0 27.777
0.1 27.777
0.2 27.776
0.3 27.775
0.4 27.774
0.5 27.773
.....
Example corresponding to $ 7 Case{curvature,lon_vel}:

.....
[CLOSED_LOOP]
STEERING_CONTROL = 'CURVATURE'
SPEED_CONTROL = 'LON_VEL'
ORDINAL = 'DISTANCE'
(DATA)
{ DISTANCE, CURVATURE, LON_VEL }
0.0 0.000 27.777
1.0 0.002 27.777
2.0 0.004 27.777
3.0 0.006 27.776
4.0 0.008 27.775
5.0 0.010 27.774
6.0 0.010 27.773
7.0 0.010 27.774
8.0 0.010 27.774
9.0 0.010 27.774
10.0 0.010 27.774
11.0 0.010 27.774
12.0 0.010 27.774
13.0 0.010 27.774
Machine Control Basics

Machine Control is a vehicle controller that you can use to simulate the control actions of a driver. You
simulate the actions of a driver by operating the steering, pedals, and gears of a simulated vehicle.
Machine Control determines control actions such that a simulated vehicle can follow a specified path
along a 2D or 3D road, while simultaneously following a specified longitudinal velocity or acceleration.
Machine Control's control action combines a reference trajectory planner and a model-predictive
controller (MPC), sometimes known as a feed-forward plus feedback controller.
At the trajectory planning stage, your targets for the vehicle and driver behavior and some basic
parameters describing the characteristics of the simulated vehicle are taken into account, and a realistic
trajectory that most closely satisfies your targets is identified (for example, path, speed, and acceleration).
Machine Control uses simple mathematical models of vehicle dynamics, such as a bicycle model, a
particle model, and a kinematic drivetrain model, to estimate the necessary control actions, such as the
steering angle and throttle position. Machine Control applies these estimated controls as inputs to the
simulated vehicle in a feed-forward manner, such that approximately correct control actions are applied
without delay.
Differences between the behavior of the simulated vehicle and the expected behavior (that is, the
behavior of the idealized models employed by the controller) are corrected continuously using feedback
controllers, which adjust the control actions to minimize the error between the reference trajectory and
the actual vehicle behavior.
Learn more about Machine Control:
• Feed-Forward Control
• Trajectory Planning
• Feedback Control
• Computation of Controls
Feed-Forward Control
Feed-Forward Lateral Control

Global axes, x-y, local axes, X-Y,
334 Adams/Car
vehicle path and global yaw angle, 
The projection of the vehicle path onto the ground plane is related to the velocities and global heading
as:
x· = V X cos  – V Y sin 
y· = V X sin  – V Y cos 
where:
( ) Global position of the vehicle

(VX, VY) Velocities of the vehicle relative to vehicle-fixed axes
 Global heading of the vehicle
The feed-forward component of the lateral control action is computed by assuming that your simulated
vehicle responds as a bicycle model. The simplicity of the bicycle model allows the analytical
identification of the relationship between the geometry of the path and the necessary control action
(steering angle), and vice-versa.
In a bicycle model, the lateral forces from both tires on an axle are assumed to act in the same direction,
and the left and right steer angles are assumed to be the same. In other words, Ackerman steering
geometry is not considered. With these assumptions, the tires may be lumped together into a single tire
representation, and the model is guided by a single steer angle.
This simplified model is used to identify the necessary steer angle required for the vehicle to follow the
connecting contour.
Simplification of a vehicle to the bicycle model
The form of the bicycle model employed by Machine Control assumes pure rolling of the front and rear
tires with no kinematic or compliance-steer effects, and therefore, no lateral velocity at the rear axle. Note
that this does not imply zero sideslip at the center of mass.
336 Adams/Car
If the origin of the vehicle-fixed local axis system shown above is selected to be the center of the rear
axle (not the center of mass), then the lateral velocity VY is now always assumed to be zero, and the
assumed path of the vehicle simplifies to:
where:
Rate of change of the direction of the path at the rear axle (note that this is
not equal to the yaw rate of the vehicle).
In this case, the center of the turn always lies on a line through the rear axle. The steer angle required to
yield a certain path curvature is then always equal to the Ackerman angle, and is independent of the
vehicle speed VX:
where:
E Wheelbase of the vehicle

R Radius of the turn at the rear axle
 Curvature of the path of the rear axle
and, therefore, this single steer angle input to the bicycle model controls the radius of turn and the
curvature of the path. A simple inversion of this equation enables an estimate of the necessary steer angle
to be calculated and applied to the simulated vehicle in a feed-forward sense.
Feed-Forward Longitudinal Control

To control either the velocity or acceleration of the simulated vehicle such that they match the reference,
a particle model, a simple aerodynamic drag model, and a kinematic drivetrain model are used to predict
the relationship between the wheel torque and the acceleration response of the vehicle.
The force or torque required to accelerate or decelerate the vehicle is expressed as a wheel torque, that
the engine and brakes must apply to one or more wheels. The magnitude of the required torque is
computed from the vehicle drag, inertia and tire rolling resistance:
Tw = Tinertial + Taero-drag+ Trolling-resistance

where:
V ref
T inertial = m e  -------------  R eq = m e  a ref  R eq
t
1 2
T aero – drag = ---  A C D AVref R eq
2
where:
Tw Total net wheel torque required to follow the reference

Tinertial Component that is required to accelerate the vehicle inertia
Taero-drag Required to overcome aerodynamic resistance
me Mass of the vehicle
aref Target (reference) vehicle acceleration
Vref Target (reference) vehicle speed
Req Average rolling radius of the wheels
A Density of air
CD Nominal drag coefficient of the vehicle
A Frontal area of the vehicle
Gear Shifting
Gear shifts are triggered on the basis of engine speed thresholds, and the gear is incremented according
to the following strategy:
338 Adams/Car
where:
g Current gear selection

g' Revised gear selection
w min Minimum engine speed allowed before a downshift is triggered
w max Maximum engine speed allowed before an up-shift is triggered
g min Highest available gear, or the number of available gears
Note: Driving Machine will not shift into neutral.
Trajectory Planning
Connecting Contour
For the lateral control of the vehicle, a simple model of the vehicle (a bicycle model) is used to compute
the control action that should cause the vehicle to follow the intended path. The simulated vehicle,
however, may not exactly follow the target path because of differences between the simplified model and
the simulated vehicle, or external factors (road roughness and aerodynamic disturbances).
Therefore, the potential for offset between the instantaneous vehicle location and heading, and the
location and heading of the path must be considered. In considering the location and heading of the path,
Machine Control builds a connecting contour between the current vehicle position (wherever it may be)
and some point on the target path, along which the vehicle will be steered to later bring it back to the
target path:
Figure 16 Connecting contour

The function that describes the connecting contour is parameterized such that one end of the connecting
contour matches the position and direction of the vehicle (at the vehicle rear axle) and the other end of
the connecting contour matches the path (at the preview distance, where the contour connects with the
target path), as shown in the above figure.
The connecting contour then becomes the reference trajectory (path) for the lateral control of the vehicle,
and the vehicle is steered by both feed-forward and feedback controllers, such that it should follow this
connecting contour. The connecting contour is updated each time the Machine Control controller is
called.
Longitudinal Trajectory Planning

The longitudinal trajectory planning essentially consists of constructing either a target velocity against
distance traveled along the track centerline, or a target acceleration against distance traveled, according
to your description of the target (for example, acceleration against distance traveled, velocity against
time).
Feedback Control
Yaw Rate Feedback

The yaw rate feedback component of the controller corrects for the difference between the yaw rate
response of the simulated vehicle and that of the bicycle model. Errors between the yaw rate reference
and the yaw rate of the simulated vehicle are quickly corrected, such that the simulated vehicle follows
the intended trajectory as closely as possible, even if the feed-forward control identified from the bicycle
model is significantly in error.
The yaw rate error is determined by considering the curvature that would result if the current yaw rate
were a steady-state value, and is corrected using a feedback controller, whose output is also fed into the
steering angle.
Lateral Displacement Feedback

The connecting contour approach does not include any term to correct for steady-state lateral
displacement error. This is preferred in most situations, because the resulting control actions tend to be
more realistic and robustly stable. Once the vehicle is close to the target path, an additional controller
acting on the distance Lo (the offset of the projected vehicle centerline from the path) adjusts the lateral
displacement of the vehicle:
where is a flag indicating whether the lateral displacement controller is activated, that is whether
the lateral displacement error Lo is small:
340 Adams/Car
Note that in the above, positive Lo indicates a vehicle to the left of the target path, requiring a positive
steering correction.
Longitudinal Velocity Feedback

Errors in longitudinal velocity are compensated using a PID controller:
where the velocity error is:

Ve = Vref(s) - Vactual
where:
s Distance along the reference path

Vref(s) Reference velocity
Vactual = Vx Longitudinal component of the vehicle velocity
Anti-windup
To improve the stability of the control in conditions of actuator (usually engine torque) saturation, the
input to the integral term of the controller is set to zero. This prevents wind-up of the integral term when
the vehicle is unable to provide any more torque, such that the feedback component of the torque demand
becomes:
where aw = 0 when saturation of the available torque is detected, aw = 1 otherwise.

Computation of Controls
Summation of Feed-Forward and Feedback Terms

Simple summation of the feed-forward and feedback terms gives the total demand from the lateral and
longitudinal controllers (steer angle and net wheel torque):
Mapping Net Wheel Torque Demand to Control Actions

Once the required total net wheel torque, Tw has been estimated, basic knowledge of the brake system
and driveline are used to identify the necessary control actions (throttle and brake) that must be applied,
such that the vehicle delivers the required net wheel torque.
The range of available net wheel torque is related to the available engine torque and the gearing of the
vehicle. Neglecting driveline inertia, the ratio of the gearbox and the differential defines the relationship
between the net wheel torque (Tw), and the engine torque (Te), at any instant:
such that the upper and lower limits Tm and TM on the net wheel torque, Tw (we) can be identified from
the upper and lower limits on Te (we):
where:
we Current engine speed (supplied as an input to Machine Control)

Minimum engine output torque (from the user engine map)
Maximum engine output torque (from the user engine map)
Rd Mean differential (final drive) ratio (from the basic vehicle knowledge)
Rg Gearbox ratio (from the basic vehicle knowledge)
The maximum brake torque, TB, is assumed to be constant.

342 Adams/Car
Net wheel torque limits as a function of engine speed, and maximum brake torque
The above figure shows the user-supplied engine model, scaled according to the gearing of the vehicle,
to yield:
• The maximum available net wheel torque, TM (normally positive for all we)
• The minimum available net wheel torque Tm (usually negative, especially at high engine speed
we, since it includes frictional and pumping losses due to throttling).
To define these limits, you can do either of the following:

• Supply a detailed nonlinear engine map, relating throttle to engine torque,
(therefore, adding a third dimension to the figure above)

• Supply only the maximum and minimum engine torques,
and choose Machine Control to employ a linear model of throttle response:

or
If a throttle map is provided, then this is mathematically inverted, so that the necessary throttle position
can be identified from the required net wheel torque Tw, provided it is feasible for the engine to deliver
this torque at the current engine speed :
344 Adams/Car
If the linear model is selected, then the feed-forward throttle and brake signals can be determined directly
from the required torque:
Control Modulation During Gearshift and Wheel-lift Events
Throttle and clutch modulation during gear-shifting

During a gear-change, the control actuation is open-loop, except for the optional closed-loop rpm control
as the clutch is re-engaged. In the following plots, which show the form of the control actions, the origin
of the time base is set to be the instant of triggering the gearshift event (see Gear Shifting).
The action of the clutch is determined, and the throttle signal, computed by the feedback and feed-
forward controllers, is modulated according to the following parameters:
• Gear change time (not the time of the whole event, but the time for which the clutch is not fully
engaged)
• Clutch raise and fall time
• Throttle raise and fall time
• DT1 (the delay between clutch disengagement and throttle release)
• DT2 (the delay between that start of clutch re-engagement and start of throttle reapplication)
The following plot shows the influence of the parameters DT1 and DT2:
346 Adams/Car
The following plot shows the influence of the throttle raise and fall time parameters:
The following plots show the effect of changing a single parameter from this baseline:
348 Adams/Car
• Changing clutch raise time:

• Changing clutch fall time:

350 Adams/Car
• Changing throttle raise time:

• Changing throttle fall time:

352 Adams/Car
• Changing DT1:
• Changing DT2:
RPM control during clutch re-engagement

During a gear change, between the time when the new gear is selected and the clutch is fully engaged,
the engine RPM we can optionally be controlled in a feedback sense, by another classical PID controller
with anti-windup. The error on which this controller acts is:
werror = we - wt
where wt is the transmission RPM with which the engine must be synchronized to avoid jerk when the
clutch is re-engaged.
This controller acts on the throttle input only.
Wheel-lift compensation
Controller-induced wheel-spin-up or wheel-lock is prevented by detecting when the loads on the driven
wheels go to zero (that is, the driven wheels are not in contact with the road). In this case, the throttle and
354 Adams/Car
brake are released (set to zero) and the clutch is depressed. The clutch action ensures that when the
vehicle lands, the wheels spin up to the correct velocity as quickly as possible.
Controlling Analysis Output Files
Controlling Analysis Output Files

Your template-based product lets you control the type and content of files an analysis outputs. You can
specify whether an analysis outputs a graphics file or results file. Graphics files contain time-dependent
data describing the position and orientation of each part in the model. Results files contain a basic set of
state variable information that Adams/Solver calculates during a simulation.
Your template-based product automatically reads the files that an analysis outputs.
If any subsystems within the assembly being analyzed contain flexible bodies, your template-based
product automatically outputs a results file, regardless of the specifications you made.
To specify analysis output files:

1. From the Settings menu, point to Solver, and then select Output Files.
The Output Files dialog box appears.
2. Select the types of files you want to output.
3. Select OK.
356 Adams/Car
Controlling Analyses Using CONSUBs

Adams/Car makes extensive use of the CONTROL command and associated CONSUB user subroutines
to perform specific analysis tasks in Adams/Solver. These include moving suspension models from the
design position to full jounce while suppressing output and running quasi-static steady-state analyses like
constant radius cornering. If you customize Adams/Car or if you want to better understand the contents
of the Adams Command Files (.acf) that Adams/Car writes, then the table below describing the purpose
of these CONSUBS along with the links to further documentation of the input parameters, will be of use
to you.
ID Description
900 Runs one or more static solutions to, for example, to adjust tie rod length to set desired
toe angle. Adams/Car adds a call to this consub when the assembly contains adjustable
forces. See Align or Adjust Suspension.
910 Set part velocity and wheel rotational velocity. See Part Velocity Setting.
917 Set part velocity and wheel rotational velocity. See Set Part Velocity.
950 For a suspension assembly, run a quasi-static simulation from time zero (0) to time one
(1) to position the suspension at the first point in the loadcase file. Output from
Adams/Solver to the request, graphics, and results files is suppressed so that plots
generated for suspension characteristics verses wheel travel do not have duplicate points
See Move Suspension to Initial Position.

1010 Fixed Body Equilibrium. This is also know as a "settle" analysis.
1020 Static Steady-State Straight Line Equilibrium and Static Steady State
Acceleration/Braking. Note in Adams/Car the auxiliary column joint is not used.
1021 Quasi-Static Steady-State Straight Line Acceleration/Braking Equilibrium. This sweeps the
longitudinal acceleration between 0 and an ending value.
1030 Static Steady-State Cornering Equilibrium
1031 Quasi-Static Steady-State Cornering Equilibrium
1032 Quasi-Static Steady-State Swept Steer Equilibrium
1060 Quasi-Static Milliken Moment Method Analysis
Controlling Full-Vehicle Analyses

If you are an experienced Adams/Car user and you want to perform some non-standard full-vehicle
analyses, such as studying the linear behavior of your vehicle between two mini-maneuvers, you can use
an Adams/Solver control subroutine (Eventxxx) to do so.
When you run a full-vehicle analysis, Adams/Car writes a number of files to the current working
directory (as defined by File -> Select Directory). These files contain important information about the
details of the maneuver. In particular, two files are important in defining the scope of the maneuver. These
are the Adams/Solver control file (.acf) and the event file (.xml).
The following shows the typical contents of an .acf:
file/model=test_step
preferences/solver=F77
output/nosep
function=user(3,1,10,0,2,5,7,9,4,8, 17)
control/ routine=abgVDM::EventRunAll, function=user(0)
!
stop
In the .acf, note the following line:
function=user(3,1,10,0,2,5,7,9,4,8, 17)
This line calls an Adams/Car-specific control subroutine (a consub). The consub sets up and initializes
the full-vehicle analysis. It does the following:
• Reads the event file (or converts the TeimOrbit .dcf file into XML)
• Performs a number of static analyses based on the content of the DcfStatic class in the event file
• Performs a dynamic analysis by running each of the mini-maneuvers listed in the DcfMini
classes in the event file
You can view and modify the event file (.xml) using the Event Builder. The Event Builder allows you to
modify existing parameters for the entire maneuver, such as step size and hmax, to modify specific mini-
maneuver information, and add mini-maneuvers.
The following line calls the control subroutine EventInit:
function=user(3,1,10,0,2,5,7,9,4,8, 17)
The call to this subroutine passes 11 parameters, as described next. Note that each number in the array
(3,1,10,0,2,5,5,9,4,8, 17) is listed after the description of that parameter.
par(1) 3: ID of STRING statement containing .XML event filename = 3
par(2) ID of ORIGO marker = 1
par(3) ID of ARRAY statement containing initial condition SDI
parameters = 10
par(4) ID of ARRAY statement containing ids of parts for which initial
velocity are not set = 0
par(5) ID of ARRAY holding Vehicle Parameters. = 2
par(6) ID of main Driving Machine ARRAY. = 5
par(7) ID ISO EAS Marker = 7
par(8) ID of Driver_Parameters_ARRAY_Steering_Human = 9
par(9) ID of STRING statement containing Driver Road Filename = 4
par(10) ID of ARRAY containing Human Driver Parameters = 8
par(11) ID of ARRAY containing the ids of extensible end condition
sensor elements = 17
358 Adams/Car
If you look at the corresponding Adams/Solver dataset (.adm), you will see that STRING/3 contains the
name of the event file:
! adams_view_name='testrig_dcf_filename'
STRING/3
, STRING =example_crc.xml
All standard Adams/Car events generate an event file in XML format, similar to the one referenced in
the example above, but .dcf files in TeimOrbit format are still supported, both in the Event Builder and
at the solver level. This means that you can replace the above string and reference a .dcf file in TeimOrbit
format. The file will be automatically converted to XML format.
By modifying the .acf file, you can now execute all mini-maneuvers defined in the event file, or just run
the initialization and then execute one mini-maneuver at a time. Full-vehicle analysis .acf files by default
call the Driving Machine initialization routine, then call the RunAll method. You can, however, modify
the .acf file and use the following commands for more control over your analysis:
• control/ routine=abgVDM::EventRunAll, function=user(0) - Runs all the active mini-maneuvers
in the list of events
• control/ routine=abgVDM::EventRunNext, function=user(0) - Runs the following mini-
maneuver in the list of the events
• control/ routine=abgVDM::EventRunFor, function=user(time) - Runs the current mini-maneuver
for duration of time [s]
• control/ routine=abgVDM::EventRunUntil, function=user(time) - Runs the current mini-
maneuver until the desired absolute time [s]
Using this flexibility within the event control subroutine enables you to use the power of the acf language
to make changes and re-submit your solution to Adams/Solver. The language parameters for the .acf file
are documented in the Adams/Solver online help.

Adams Car Analysis

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Adams Car Analysis

Enviado por

Direitos autorais:

Formatos disponíveis

Running Analyses

Running Suspension Analyses

For a suspension analysis, you can specify inputs to:

Setting up Suspension Analyses

To set up suspension analyses:

To set up a loadcase analysis:

A wheel-envelope analysis requires suspension and steering subsystems.

To set up a wheel-envelope analysis:

Roll & Vertical Force Analysis

To set up a roll & vertical force analysis:

Static Load Analysis

To set up a static load analysis:

To set up a steering analysis:

Opposite Wheel-Travel Analysis

To set up an opposite wheel-travel analysis:

Parallel Wheel-Travel Analysis

To set up a parallel wheel-travel analysis:

Single Wheel-Travel Analysis

To set up a single wheel-travel analysis:

Computation of Suspension and Steering Characteristics

Definition of Compliance Matrix

Steer Axis Computation

Instant Axes Method

To set up a dynamic analysis:

Example Suspension Loadcase File

Example Wheel-Envelope Input File

$ (c10) driving force (y) right

Example Wheel-Envelope Output File

The following is an example of a wheel-envelope output file:

Output of Suspension Analyses

• Steer Axis Offset

Aligning Torque - Steer and Camber Compliance

Note: This help file is shared by several Adams products.

Figure 1 Aligning Torque Loading for Steer and Camber

Note: This help file is shared by several Adams products.

Note that the inclination angle, a measurement available in full-vehicle analyses,

Figure 2 Camber Angle

Note: This help file is shared by several Adams products.

Figure 3 Caster Angle

Dive Braking/Lift Braking

Note: This help file is shared by several Adams products.

Inputs • Compliance matrix

Fleft = Fright = Brake Ratio / 2.0

Wleft = Wright = Whole vehicle CG height/ (2 x

Vertical deflections due to the vertical force are:

Zwleft = Wleft x C(3,3) + Wright x C(3,9)

ZFleft = Fleft [C(3,1) - Rl x C(3,5)] +

dive.left = (ZFleft + ZWleft + Wleft / Kt) Vehicle

Fore-Aft Wheel Center Stiffness

Note: This help file is shared by several Adams products.

Front-View Swing Arm Length and Angle

Note: This help file is shared by several Adams products.

The magnitude of the swing-arm length is limited to a maximum of 1000 meters.

Figure 4 Instant Center Front View (Lateral, Vertical)

Kingpin Inclination Angle

Note: This help file is shared by several Adams products.

Inputs Kingpin axis unit vectors - left and right

Figure 5 Kingpin Angle (Ø is the Kingpin Angle)

Lateral Force - Deflection, Steer, and Camber Compliance

Note: This help file is shared by several Adams products.

lat_force_defl_compliance.left = +[C(2,2) + Rl x C(2,4) + C(2,8) + Rl x C(2,10)]

lat_force_defl_compliance.right = +[C(8,2) + Rl x C(8,4) + C(8,8) + Rl x C(8,10)]

lat_force_steer_compliance.left = +[C(6,2) + Rl x C(6,4) + C(6,8) + Rl x C(6,10)]