Analysis

Mechanical Dynamics
Running Analyses in ADAMS/Car
About This Guide 3 Section I - Running Suspension Analyses 11 Section II - Running Full-Vehicle Analyses 83 Section III - Plotting Analysis Results 143 Section IV - Appendixes 151
Running Analyses in ADAMS/Car Copyright
U.S. Government Restricted Rights: If the Software and Documentation are provided in connection with a government contract, then they are provided with RESTRICTED RIGHTS. Use, duplication or disclosure is subject to restrictions stated in paragraph (c)(1)(ii) of the Rights in Technical Data and Computer Software clause at 252.227-7013. Mechanical Dynamics, Incorporated, 2301 Commonwealth Blvd., Ann Arbor, Michigan 48105. The information in this document is furnished for informational use only, may be revised from time to time, and should not be construed as a commitment by Mechanical Dynamics, Incorporated. Mechanical Dynamics, Incorporated, assumes no responsibility or liability for any errors or inaccuracies that may appear in this document. This document contains proprietary and copyrighted information. Mechanical Dynamics, Incorporated permits licensees of ADAMS software products to print out or copy this document or portions thereof solely for internal use in connection with the licensed software. No part of this document may be copied for any other purpose or distributed or translated into any other language without the prior written permission of Mechanical Dynamics, Incorporated. 2000 by Mechanical Dynamics, Incorporated. All rights reserved. Printed in the United States of America. ADAMS is a registered United States trademark of Mechanical Dynamics, Incorporated. All other product names are trademarks of their respective companies.
Part number: 101CARANA-01
Running Analyses in ADAMS/Car About This Guide
About This Guide

Welcome to ADAMS/Car
Welcome to ADAMS/Car, Mechanical Dynamics virtual prototyping software. ADAMS/Car creates, catalogues, and analyzes full vehicles and vehicle suspensions. This guide describes how you can use ADAMS/Car to analyze vehicle suspensions and full vehicles and explains the results of the analyses. It also introduces you to the Driving Machine. The Driving Machine drives your virtual vehicle according to your instructions much like a test driver would drive an actual vehicle.
What This Guide Assumes

This guide assumes that:
s
You know the basics of using ADAMS/Car. For an introduction to ADAMS/Car, see the guide, Getting Started Using ADAMS/Car.
ADAMS/Car is installed on your computer or network. It also assumes that your path variable contains the location where ADAMS/Car is installed and that you have permission to execute ADAMS/Car. If you do not know if ADAMS/Car is installed or where it is located, see your local ADAMS/Car expert or system administrator. You have a good understanding of:
s s s
Control theory. Vehicle dynamics. ADAMS/Car. For general information about ADAMS/Car, see the online ADAMS/Car Reference Guides.
Running Analyses in ADAMS/Car About This Guide
Introducing Analyses in ADAMS/Car
Overview
ADAMS/Car allows you to quickly and easily analyze suspensions and full vehicles under various conditions. The following sections introduce you to running analyses.
s s s s
About ADAMS/Car Analyses, 6 Types of Analyses, 7 Controlling Analysis Output Files, 8 About Test Rigs, 9
Running Analyses in ADAMS/Car Introducing Analyses in ADAMS/Car
About ADAMS/Car Analyses

Using ADAMS/Car to analyze a virtual prototype is much like ordering a test of a physical prototype. When ordering a test in ADAMS/Car, you specify the following:
s
The virtual prototype to be tested - 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
ADAMS/Car contains suspension and full-vehicle test rigs. For more on the test rigs, see About Test Rigs on page 9.
s
The kind of analysis youd like performed - You specify the test or analysis by selecting one from the ADAMS/Car Simulate menu. There are two major types of analyses: suspension and full-vehicle. For more on the analyses, see Types of Analyses on page 7. The analysis inputs to be used - 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 from an ADAMS/Car database.
After specifying the prototype assembly and its analysis, ADAMS/Car, like your companys 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. Each kind of analysis that you perform requires a minimum set of subsystems. For example, a suspension analysis requires one suspension subsystem. A full-vehicle analysis requires 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.
Types of Analyses
There are two types of analyses that you can run in ADAMS/Car: suspension analyses and full-vehicle analyses. To run full-vehicle analyses, you must have purchased the ADAMS/Car Vehicle Dynamics package. The next sections explain each type of analyses:
s s
About Suspension Analyses, 7 About Full-Vehicle Analyses, 8
About Suspension Analyses

ADAMS/Car lets you analyze and view virtual prototypes of suspensions and steering subsystems. Using ADAMS/Car, you can:
s
Easily modify the topology and the properties of the components of your suspension. Run a standard set of suspension and steering maneuvers. Visualize suspension characteristics through plots.
s s
For a suspension analysis, you can specify inputs to:

s
Move the wheels through bump-rebound travel and measure the toe, camber, wheel rate, roll rate, side-view swing-arm length, and other characteristics. For a complete list of the characteristics, see Understanding Suspension Characteristic Calculations on page 21. 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.
Based on ADAMS/Car results, you can alter the suspension geometry or spring rates and analyze the suspension again to evaluate the effects of the alterations. For more on suspension analyses, see Performing Suspension Analyses on page 13.
About Full-Vehicle Analyses

ADAMS/Car lets you analyze virtual prototypes of full vehicles. Using ADAMS/Car, you can:
s
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.
For more on full-vehicle analyses, see Performing Full-Vehicle Analyses on page 85.
Controlling Analysis Output Files

ADAMS/Car 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. ADAMS/Car automatically reads the files an analysis outputs. If any subsystems within the assembly being analyzed contain flexible bodies, ADAMS/Car continues to automatically output 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 3
Select the types of files you want ADAMS/Car to output. Select OK.
About Test Rigs

Three test rigs are available in ADAMS/Car:
s s s
About the Suspension Test Rig, 9 About the Driver Test Rig, 10 About the Driving Machine Test Rig, 10
About the Suspension Test Rig

ADAMS/Car uses the suspension test rig, called ._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 contact patch/hub of the suspension and steering subsystems. The excitations are made up of one or more of the following:
s s s s
Displacement (wheel bump and rebound vertical travel) Steering travel Forces or torques at the steering wheel joint or rack Forces and torques at the contact patch and at the hub
10
About the Driver Test Rig

ADAMS/Car uses the driver test rig, ._MDI_DRIVER_TESTRIG, to perform fullvehicle analyses. You assemble this test rig with any full-vehicle model that you are analyzing. The driver test rig supplies a series of driving signals to the vehicle subsystems or to actuators to perform a desired maneuver. These signals include:
s s s s s
Steering Throttle Brake Clutch Transmission
ADAMS/Car defines every full-vehicle standard maneuver as a particular function of each of the driving signals. For example, the step-steer maneuver is defined as a step signal on the steering wheel.
About the Driving Machine Test Rig

ADAMS/Car uses the Driving Machine test rig, ._MDI_SDI_TESTRIG, to perform full-vehicle analyses scripted by driver control files (.dcf) using IPG-Driver and IPG-Driver-Lite for closed-loop vehicle control.
Section I - Running Suspension Analyses
Includes:
s s
Performing Suspension Analyses, 13 Understanding Suspension Characteristic Calculations, 21
12
Running Analyses in ADAMS/Car Section I - Running Suspension Analyses
Performing Suspension Analyses
Overview
You can test suspensions to determine their kinematic and compliance characteristics by applying vertical, roll, and steering motions or forces. This chapter explains how to run suspension analyses and describes each type of suspension analysis you can run.
s s s s
Suspension Analysis Process, 14 Suspension Assembly Roles, 15 Setting Suspension Parameters, 15 Submitting Suspension Analyses, 16
14
Running Analyses in ADAMS/Car Performing Suspension Analyses
Suspension Analysis Process

You perform a suspension analysis 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 components, or subsystems, and the test rig. You then specify ranges of vertical wheel travel, steering travel, and static tire contact patch loads and the number of solution steps. 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 angle, camber angle, track change, wheel base change, wheel rate (vertical stiffness), fore-aft wheel center stiffness, and so on. You can plot these characteristics and use them to determine how well the suspension controls the motions of the wheels. For more information on the suspension characteristics, see Understanding Suspension Characteristic Calculations on page 21.
Figure 1 shows an overview of the process.
Figure 1. Suspension Analysis Process
Step 1: Open Assembly Step 2: Set Parameters Step 3: Submit Analysis Step 4: Animate and Plot
6 5 4 3 2 1 2 3 4 5
1, 3.00, 65%, 35%
A suspension analysis in ADAMS/Car is a quasi-static equilibrium analysis.
15
Suspension Assembly Roles

To create a suspension assembly, you can select any subsystem that has one of the major roles listed below. A major role defines the primary function of the subsystem.
s s
Suspension Steering
Setting Suspension Parameters

Before you submit a suspension analysis, you need to set the suspension parameters that ADAMS/Car uses when calculating suspension characteristics. These parameters describe the vehicle in which you wish to use the suspension. ADAMS/Car uses, for example, the parameters wheelbase, cg_height, and sprung mass to calculate the fore-aft weight transfer during braking and acceleration. Once you set the vehicle parameters in an ADAMS/Car session, ADAMS/Car uses those settings for all suspension analyses until you reset the parameters.
To set parameters:
1 2
From the Simulate menu, point to Suspension Analysis, and then select Set Suspension Parameters. Enter the desired parameter values, and then select OK.
Tip: For more information on entering parameter values, see the online dialog box help. To display the online dialog box help, press F1 when
the cursor is in the main window, and then click anywhere in the dialog box.
16
Submitting Suspension Analyses

You submit an analysis by selecting a specific analysis from the Simulate menu and then entering the vertical wheel travel and other parameters needed to control the analysis. You can also select one or more loadcase files (.lcf) from an ADAMS/Car database. Loadcase files 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. Actually, as you perform an analysis for which you did not create a loadcase file, ADAMS/Car creates one for you temporarily and deletes it after the analysis. The following sections explain more about submitting analyses and the types of suspension analyses available:
s s
Specifying Number of Steps, 16 Types of Suspension Analyses, 17
Specifying Number of Steps

As you submit a suspension analysis, you specify the number of steps in the analysis. The number of steps is the number of solution steps from a lower bound to an upper bound. For example, for an opposite wheel travel analysis, if you specify five steps and -100 mm rebound and 100 mm jounce, ADAMS/Car temporarily creates a loadcase file that contains left vertical wheel displacement inputs of -100, -60, -20, 20, 60, and 100 mm and right vertical wheel displacement inputs of 100, 60, 20, -20, -60, and -100 mm as shown below:
Figure 2. Number of Inputs to Steps
Inputs: Steps: -100 1 -60 2 -20 3 20 4 60 5 100
Note that all suspension analyses in ADAMS/Car are quasi-static equilibrium analyses.
17
Types of Suspension Analyses

The types of analyses that you can run on a suspension are:
s s s s
Wheel Travel Analyses, 17 Steering Analysis, 18 Steering Analysis, 18 External-File Analyses, 18
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 explained in the next sections. As a minimum, all wheel travel analyses require a suspension system. The analyses can also include a steering system.
s s s
Parallel Wheel Travel Analysis, 17 Opposite Wheel Travel Analysis, 17 Single Wheel Travel Analysis, 18
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. For more information on specifying a parallel wheel travel analysis, see the online dialog box help.
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, 180 degrees 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. For more information on specifying an opposite wheel travel analysis, see the online dialog box help.
18
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. For more information on specifying a single wheel travel analysis, see the online dialog box help.
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. A steering analysis requires a suspension subsystem and a steering subsystem. For more information on specifying a steering analysis, see the online dialog box help.
Static Load Analysis
A static load analysis applies static loads to the tire contact patches between the specified upper and lower load limits. A static load analysis requires a suspension subsystem. For more information on specifying a static load analysis, see the online dialog box help.
External-File Analyses
There are two types of external-file analyses:

s s
Loadcase Analysis, 18 Wheel-Envelope Analysis, 19
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. For an example of a loadcase file, see Example Suspension Loadcase File on page 153. A loadcase analysis requires a suspension subsystem.
19
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. For examples of wheel-envelope input and output files, see Example Wheel-Envelope Files on page 157. When you submit a wheel-envelope analysis, you specify one or more wheel-envelope input files defining:
s s
Vertical wheel and steering inputs. Static contact patch forces for articulating and/or loading the suspension subsystem.
For more information on specifying an external-file analysis, see the online dialog box help.
20
Understanding Suspension Characteristic Calculations
Overview
ADAMS/Car calculates 38 different characteristics during suspension analyses. This chapter describes each of the characteristics. Many of the descriptions refer to an accompanying diagram that illustrates the definition of the characteristics.
s s s s s
Computing Suspension and Steering Characteristics, 22 Calculating Steer Axes, 22 Definition of Compliance Matrix, 24 General Suspension Characteristics, 26 Steering System Characteristics, 67
22
Running Analyses in ADAMS/Car Understanding Suspension Characteristic Calculations
Computing Suspension and Steering 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. For more information on the compliance matrix, see Definition of Compliance Matrix on page 24.
Calculating Steer Axes

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 and instant axis. Using the geometric method, ADAMS/Car calculates the steer axis by passing a line through two markers on the steer axis. Using the instant axis method, ADAMS/Car calculates the steer axis as the instant axis of rotation of the wheel carrier parts. Both methods give accurate results, but the instant axis method is the more general, since 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.
23
The following sections describe the two methods for calculating suspension steer axes:
s s
Geometric Method, 23 Instant Axes Method, 23
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 suspensions compliance matrix. While the calculation is performed numerically, it is best described in physical terms. To calculate the steer axis at a given suspension position, ADAMS/Car first locks the spring travel and applies an incremental steering torque or force. Then, from the resulting translation and rotation of the wheel carrier parts, ADAMS/Car calculates the instant axis of rotation for each wheel carrier. The instant axes of rotation are the steer axes. 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.
24
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.
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.
25
ADAMS/Car uses a 12 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:
Figure 3. Compliance Matrix
X left wheel Y Z AX AY AZ X right wheel Y Z AX AY AZ
C ( 1, 1 ) , C ( 1, 2 ) C ( 1, 12 )
C ( 2, 1 ) , C ( 2, 2 ) C ( 2, 12 ) C ( 3, 1 ) , C ( 3, 2 ) C ( 3, 12 ) C ( 7, 1 ) C ( 1, 8 ) C ( 9, 1 ) , C ( 9, 2 ) C ( 12, 1 ) , C ( 12, 2 ) C ( 12, 12 )
FX left wheel FY FZ TX TY TZ FX right wheel FY FZ TX TY TZ
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.
26
General Suspension Characteristics

This section defines general suspension characteristics that ADAMS/Car analysis computes for all suspensions. Additional characteristics are computed for steered suspensions. For more information, see Steering System Characteristics on page 67.
s s s s s s s s s s s s s s s s s s s s s s
Aligning Torque - Steer and Camber Compliance, 27 Camber Angle, 29 Caster Angle, 30 Dive Braking/Lift Braking, 32 Fore-Aft Wheel Center Stiffness, 34 Front-View Swing Arm Length and Angle, 35 Kingpin Inclination Angle, 37 Lateral Force - Deflection, Steer, and Camber Compliance, 38 Lift/Squat Acceleration, 40 Percent Anti-Dive Braking /Percent Anti-Lift Braking, 43 Percent Anti-Lift Acceleration / Percent Anti-Squat Acceleration, 46 Ride Steer, 49 Roll Camber Coefficient, 50 Roll Caster Coefficient, 52 Roll Center Location, 53 Roll Steer, 55 Side-View Swing Arm Length and Angle, 58 Ride Rate, 60 Suspension Roll Rate, 61 Toe Angle, 63 Total Roll Rate, 65 Wheel Rate, 66
27
Aligning Torque - Steer and Camber Compliance

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 Request Names Method
degrees/(force*length) alt_steer_compliance/[left,right] alt_camber_compliance/[left,right] alt_steer_compliance: left = (180/) * (C(6,6) + C(6,12)) right = (180/) * (C(12,6) + C(12,12)) alt_camber_compliance: left = (180/) [c(4,6) + c(4,12)] right = -(180/) [c(10,6) + c(10,12)]
28
Figure 4. Aligning Torque Loading for Steer and Camber Compliances
29
Camber Angle
Description
Camber angle is the angle the wheel plane makes with the vertical (road normal). It is positive when the top of the wheel leans outward from the vehicle body.
s s
Request Names Inputs Method
camber_angle.left camber_angle.right
Wheel center axis (spin axis) unit vectors, left and right
camber = -(180/) * arcsin(spinaxis z )
Figure 5. Camber Angle
Y = Camber Angle
30
Caster Angle
Description
Caster angle is the angle in the side elevation between the steering (kingpin) axis and the vertical. ADAMS/Car reports caster angle in degrees. It is positive when the steer axis is inclined upward and rearward. ADAMS/Car computes the steer axis using the geometric or instant axis method.
s s s s s
Request Names Inputs
caster_angle.left caster_angle.right
Steer (kingpin) axis unit vectors - left and right Road vertical unit vector (z) Road longitudinal unit vector (x)
Method
ADAMS/Car 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 = rtod * arctan(sx / sz)
31
Figure 6. Caster Angle
Kingpin/Steering Axis
X = Caster Angle
32
Dive Braking/Lift Braking

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.
s s s s s s s s s
dive.left dive.right
Compliance matrix Front or rear braking ratio Loaded tire radius Tire stiffness Total CG height Total vehicle weight Wheelbase
Method
ADAMS/Car first computes the longitudinal force due to braking:

Fleft = Fright = Brake Ratio / 2.0
and then the vertical force due to weight transfer:

Wleft = Wright = Total CG Height/ (2 Wheelbase)
Note: For rear anti-lift, the weight transfer is a negative value.
These are forces at each wheel per unit total braking force.
33
Vertical deflections due to the vertical force are:

Zwleft = Wleft C(3,3) + Wright C(3,9) Zwright = Wleft C(9,3) + Wright 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 C(3,5)] + Fright[C(3,7) - Rl C(3,11)] ZFright = Fleft [C(9,1) - Rl C(9,5)] + Fright[C(9,7) - Rl C(9,11)]
The front dive or rear lift is:

Left = (ZFleft + ZWleft + Wleft / Kt) Vehicle Weight Right = (ZFright + ZWright + Wright / Kt) Vehicle Weight
34
Fore-Aft Wheel Center Stiffness

Description
The stiffness of the suspension in the fore-aft direction is relative to the body, measured at the wheel center.
s s
fore_aft_wheel_center_stiffness.left fore_aft_wheel_center_stiffness.right
Compliance matrix ADAMS/Car applies equal unit forces acting longitudinally at the wheel centers. It calculates the fore-aft wheel center stiffness as follows:
Left = 1 / C(1,1) Right = 1 / C(7,7)
35
Front-View Swing Arm Length and Angle

Description
The swing arm is the imaginary arm extending from the wheels 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 inward and upward.
s s s s
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
Inputs Method
Compliance matrix 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(5,3)
The left front view swing arm length and angle are:
Front View Swing Arm Lengthleft = - (Yleft 2 + Zleft 2) 1/2 / left Front View Swing Arm Angleleft = - (180 /) tan-1 (Yleft / Zleft)
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(2,3) Z right = C(3,3) right = C(5,3)
36
The right front view swing arm length and angle are:
Front View Swing Arm Lengthright= (Yright 2 + Zright 2) 1/2 / right Front View Swing Arm Angleright = (180 /) tan-1 (Yright / Z right)
Figure 7. Instant Center Front View (Lateral, Vertical)
Line of Wheel Center Travel
Z
ANG
Vertical
Y R
Lateral
37
Kingpin Inclination Angle

Description
The kingpin inclination angle is the angle in the front elevation between the steer axis (the kingpin axis) and the vertical. ADAMS/Car reports the kingpin angle in degrees. It is positive if the steer axis is inclined upward and inward.
s s
kingpin_incl_angle/left kingpin_incl_angle/right
Kingpin axis unit vectors - left and right ADAMS/Car uses the direction cosines in the y-direction and the z-direction of the kingpin axis to calculate the kingpin inclination angle:
Left Kingpin = (180/) tan-1 (DCOSY/DCOSZ) Right Kingpin = (180/) tan-1 (-DCOSY/DCOSZ)
Figure 8. Kingpin Angle ( is the Kingpin Angle)
Steer axis
38
Lateral Force - Deflection, Steer, and Camber Compliance

Description
The deflections at the wheel center due to unit lateral forces applied simultaneously at the tire patches. The forces are oriented as if in a right turn. ADAMS/Car 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.
s s s s s
Request Names
lat_force_defl_compliance/left lat_force_defl_compliance/right lat_force_steer_compliance/left lat_force_steer_compliance/right lat_force_camber_compliance/left
Inputs
s s
Compliance matrix Tire radius - loaded
39
Method
When the force is applied at the tire contact patch, ADAMS/Car 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:
Left Deflection = +[C(2,2) + Rl C(2,4) + C(2,8) + Rl C(2,10)] Right Deflection = +[C(8,2) + Rl C(8,4) + C(8,8) + Rl C(8,10)] Left Steer = +(180/) [C(6,2) + Rl C(6,4) + C(6,8) + Rl C(6,10)] = +(180/) [C(12,2) + Rl C(12,4) + C(12,8) + Rl C(12,10)] = +(180/) [C(4,2) + Rl C(4,4) + C(4,8) + Rl C(4,10)] C(4,8) + Rl C(4,10)] = -(180/) [C(10,2) + Rl C(10,4) + C(10,8) + Rl C(10,10)]
Right Steer
Left Camber
Right Camber
Figure 9. Lateral Force Loading for Deflection, Steer, and Camber Compliances
Z
Right Left
40
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. Front suspensions:
s s
Request Names
lift_acceleration/left lift_acceleration/right
Rear suspensions:
s s
squat_acceleration/left squat_acceleration/right
Inputs
Compliance matrix Suspension parameters array:

s
suspension_type (independent/dependent)
Vehicle parameters array:

s s s s s s s
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:
s
Track
Acceleration of gravity (Ag)
41
Method
The suspension lift or squat during acceleration arises due to the tractive forces, weight transfer, and, in dependent suspensions, 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)
Dependent suspensions 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_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 torques. Therefore, ZDleft = ZDright = 0.0.
42
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/Squat left = (ZDleft + ZFleft + ZWleft) * sprung_mass * Ag Lift/Squatright = (ZDright + ZFright + ZWright) * sprung_mass * Ag
43
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.
Request Names
Front suspensions:
s s
anti_dive_braking/left anti_dive_braking/right
Rear suspensions:
s s
anti_lift_braking/left anti_lift_braking/right
44
Inputs
Compliance matrix Vehicle parameters array:

s s s s s s s
sprung_mass cg_height wheelbase loaded_tire_radius tire_stiffness brake_ratio (fraction of braking done by the suspension)
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
45
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_diveleft = anti_liftleft = 100 * ZBleft / ZWleft anti_diveright = anti_liftright = 100 * ZBright / ZWright
46
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.
Request Names
Front suspensions:
s s
anti_lift_acceleration/left anti_lift_acceleration/right
Rear suspensions:
s s
anti_squat_acceleration/left anti_squat_acceleration/right
47
Inputs
Compliance matrix Suspension parameters array:

s
suspension_type (independent/dependent)
Vehicle parameters array:

s s s s s s s
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:

s
Track

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)
Dependent suspensions also react to 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
48
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 = ZDright = VTleft * C(3,1) + TOleft * C(3,5) + VTright * C(3,7) + TOright * C(3,11) + VTleft / tire_stiffness 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:
percent_anti_liftleft = 100 * (ZFleft + ZDleft) / ZWleft
percent_anti_liftright = 100 * (ZFright + ZDright) / ZWright
49
Ride Steer
Description
Ride steer is the steer of the wheels per unit vertical deflection of the wheel center due to equal vertical forces at the tire contact patches. Positive ride steer implies that the wheels steer to the left when the forces are applied.
s s
ride_steer/left ride_steer/right
Compliance matrix ADAMS/Car applies equal unit forces acting vertically at the tire patches. It calculates ride steer as follows:
Left = (180/) [(C(6,3) + C(6,9)) / (C(3,3) + C(3,9))] Right = (180/) [(C(12,3) + C(12,9)) / (C(9,3) + C(9,9))]
50
Roll Camber Coefficient

Description
Roll camber coefficient is the rate of change in wheel inclination angle with respect to vehicle roll angle. Positive roll camber coefficient indicates an increase in camber angle per degree of vehicle roll.
s s s s s
roll_camber_coefficient/left roll_camber_coefficient/right
Compliance matrix Tire stiffness Track width
Method
ADAMS/Car applies opposing unit forces acting vertically at the tire patches. The height difference between the tire patches is the following, where Kt is the vertical tire rate:
Z = 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 patches:
Av = Z / track
ADAMS/Car measures the wheel inclination with respect to the line through the tire patches, which has two components. The first is from the vertical movement of the tire 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) = - C(10,3) + C(10,9) (left side) (right side)
The total wheel inclination is then:

Ai = Av - Ac
51
The roll camber is then:

RC = (Av - Ac) / Av = 1 - Ac / Av
Figure 10. Roll Camber
Ac Ai
Av Y F F
52
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.
s s s s s
roll_caster_coefficient/left roll_caster_coefficient/right
Method
ADAMS/Car applies opposing unit forces acting vertically at the tire patches. The height difference between the tire patches is the following, where Kt is the vertical tire rate:
Z = 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 patches:
Av = Z / track
The rotational compliance at the wheel center due to the vertical force is:
Ac = C(5,3) - C(5,9) = C(11,3) - C(11,9) (left side) (right side)
The roll caster is then:

RC = Ac / Av
53
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.
s s s s
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
Inputs
s s
Compliance matrix at contact patches Contact patch location
Method
ADAMS/Car 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/Car 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/Car 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/Car 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).
54
Figure 11. Roll Center Location (Front View)
Lateral to Right Patch
Lateral to Left Patch
F = Incremental Force
Y, Z= Incremental Motions of Contact Patch
Roll Center
Z F Height
Y Z
Y
Z Y
55
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).
s s s s s s
roll_steer/left roll_steer/right
Wheel center (spin) axis unit vector (wcv) left and right Track Tire stiffness (Kt) Compliance matrix
Method
Using the compliance matrix, ADAMS/Car 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/Car calculates the change in steer angle due to the change in wheel center vector orientation. Finally, ADAMS/Car 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
56
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 derivaties 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 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) )
57
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 Statements Nomenclature
REQUST/id, FUNCTION=USER(900,17,characteristics_input_array_id)\
s s s s s
Bolded text in uppercase letters, such as Wl, are vectors. Bolded text in lowercase letters, 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.
58
Side-View Swing Arm Length and Angle

Description
The swing arm is an imaginary arm extending from the wheels side elevation instant center of rotation to the wheel center. When the instant center is behind the wheel center, the swing arm has a positive length for front suspension. When the instant center is ahead of the wheel center, the swing arm has a positive length for rear suspensions. 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.
Request Names
s s s s
side_view_swing_arm_angle/left side_view_swing_arm_angle/right side_view_swing_arm_length/left side_view_swing_arm_length/right
Inputs Method
Compliance matrix 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 Lengthleft = (DX left 2 + DZ left 2)1/2 / D left Side View Swing Arm Angleleft = (180 /p) tan-1 (DX left / DZ left)
59
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 Lengthright = (DXright 2 + DZright 2) 1/2 / D right Side View Swing Arm Angleright = (180 /p) tan-1 (DXright / DZ right)
Figure 12. Instant Center Side View (Fore and Aft, Vertical)
X
Line of Wheel Center travel
Z Z X R ANG
Vertical
Fore and Aft
60
Ride Rate
Description
Ride rate is the spring rate of the suspension relative to the body, measured at the tire patch.
s s s s
ride_rate/left ride_rate/right
Compliance matrix Tire stiffness
Method
ADAMS/Car computes ride rate as the equivalent rate of the wheel rate and tire rate in series.
Ks = Wheel rate (see Wheel Rate on page 66) Kt = Vertical tire rate Ktotal = Ks Kt / (Ks + Kt)
61
Suspension Roll Rate

Description
Suspension roll rate is the torque, applied as vertical forces at the tire patches, per degree of roll, measured through the wheel centers.
s s s s
susp_roll_rate/left susp_roll_rate/right
Compliance matrix Track width
Method
ADAMS/Car uses opposing unit forces as the applied torque:

T = F track = track
The resulting vertical distance between wheel centers is:

Z = C(3,3) - C(3,9) - C(9,3) + C(9,9)
The rotation of the line through the wheel centers is:

= Z / track
The roll rate is:

Rate = T / = (/180) track2 /Z
62
Figure 13. Roll Rate - Suspension
Z F Y F
63
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 road surface. ADAMS/Car reports toe angle in degrees. It is positive if the wheel front is rotated in towards the vehicle body.
s s
toe_angle/left toe_angle/right
Wheel center axis unit vectors - left and right ADAMS/Car 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:
Left toe = (180/) tan-1 (DCOSX/DCOSY) Right toe = (180/) tan-1 (-DCOSX/DCOSY)
64
Figure 14. Toe Angle
= Toe Angle
65
Total Roll Rate

Description
Total roll rate is the torque, applied as vertical forces at the tire patches, per degree of roll, measured at the tire patches.
s s s s s
total_roll_rate/left total_roll_rate/right
Method
ADAMS/Car uses opposing unit forces as the applied torque:

T = F 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/Kt
The rotation of the line through the tire patches is:

= Z / track
The roll rate is:

Rate = T/ = ( /180) track2/Z
66
Wheel Rate
Description
Wheel rate is the vertical spring rate of the suspension relative to the body, measured at the wheel center.
s s
wheel_rate/left wheel_rate/right
Compliance matrix ADAMS/Car 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.
Left = 1 / [C(3,3) + C(3,9)] Right = 1 / [C(9,3) + C(9,9)]
67
Steering System Characteristics

This section defines suspension characteristics for steered suspensions. For the general characteristics of all suspensions, see General Suspension Characteristics on page 26.
s s s s s s s s s s
Ackerman, 68 Ackerman Angle, 69 Ackerman Error, 70 Ackerman Percent, 71 Caster Moment Arm, 72 Ideal Steer Angle, 74 Outside Turn Diameter, 75 Scrub Radius, 76 Steer Angle, 78 Turn Radius, 82
68
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.
s s
ackerman/left ackerman/right
Steer angle (see Steer Angle on page 78). ADAMS/Car computes Ackerman by subtracting the right steer angle from the left steer angle:
Ackerman = Right steer angle Left steer angle
69
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.
s s s s
ackerman_angle/left ackerman_angle/right
Turn radius (see Turn Radius on page 82) Wheelbase
Method
Ackerman angle = (180/) tan-1(Wheel Base/Turn Radius)

Figure 15. Ackerman Angle
Inside Tire
L = Left Steer Angle R = Right Steer Angle A = Ackerman Angle
Wheel Base
Turn Radius
Y
70
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.
s s s s
ackerman_error/left ackerman_error/right
Steer angle (see Steer Angle on page 78) Ideal steer angle (see Ideal Steer Angle on page 74)
Method
Ackerman error left = (left steer angle - left ideal steer angle) Ackerman error right = (right steer angle - right ideal steer angle)
71
Ackerman Percent
Description
Ackerman percent is the ratio of actual Ackerman to ideal Ackerman expressed as a percentage. Ackerman percent is limited to the range from -999% to 999%. Ackerman percent is positive when the inside wheels steer angle is larger than the outside wheels steer angle.
s s s s s
ackerman_percent/left ackerman_percent/right
Steer Angle (see Steer Angle on page 78) Ideal Steer Angle (see Ideal Steer Angle on page 74) Ackerman (see Ackerman on page 68)
Method
Ackerman = Right steer angle - Left steer angle Ideal Ackerman = Right ideal steer angle - Left ideal steer angle Ackerman percent = 100 Ackerman/Ideal Ackerman
72
Caster Moment Arm

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.
s s s
caster_moment_arm/left caster_moment_arm/right
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)
s s s s
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 upwards 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 k)/(s 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 w / | k w | (left side) l = k -w / | k -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) l
73
Figure 16. Caster Moment Arm and Scrub Radius

Y
Wheel plane intersection line
X
Scrub radius Caster moment arm Kingpin axis/road plane intersection point Tire contact patch
74
Ideal Steer Angle

Description
Ideal steer angle is the steer angle in degrees 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.
s s s s s
ideal_steer_angle/left ideal_steer_angle/right
Turn radius (see Steer Angle on page 78) Track width Wheelbase
Method
Left Ideal Steer Angle = (180/) tan-1 [Wheel Base/(Turn Radius+ Track/2)] Right Ideal Steer Angle = (180/) tan-1 [Wheel Base/(Turn Radius+ Track/2)]
75
Outside Turn Diameter

Description
Outside turn diameter is the diameter of the circle defined by a vehicles outside front tire when the vehicle turns at low speeds. ADAMS/Car determines the circle by the tires 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.
s s
Request Names
outside_turn_radius/left outside_turn_radius/right
Inputs
s s s
Turn radius (see Turn Radius on page 82) Track width Wheelbase
Method
Outside Turn Diameter = 2.0 [(| Turn Radius | +Track/2)2 + (Wheel Base) 2]1/2
76
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.
s s
Request Names
scrub_radius/left scrub_radius/right
Inputs
s s s s s
Kingpin axis position (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)
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 upwards away from the road and that the road plane has zero height. The intersection of the kingpin axis and the road plane (Rkr) is:
Rsr = Rs (Rs k)/(s k) s
Next ADAMS/Car finds the projection (m) of the wheel center axis (w) onto the road plane
M = (k w) 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) m
77
Figure 17. Caster Moment Arm and Scrub Radius

Y
Wheel plane intersection line
X
Scrub radius Caster moment arm Kingpin axis/road plane intersection point Tire contact patch
78
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.
s s
Request Names
steer_angle/left steer_angle/right
Inputs Method
Wheel center axis unit vectors - left and right 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:
Left Steer Angle = (180/) tan-1 (DCOSX/|DCOSY|) Right Steer Angle= (180/) tan-1 (-DCOSX/|DCOSY|)
79
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.
Request Names
s s s s s s
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
s s s s
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
80
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:

lon_left lon_right = -R o u_lon = R o u_lon
The steer axis offset-lateral is:

lat_left lat_right = R o u_lat = R o u_lat
Finally, the steer axis offset is:

off_left = sqrt( lon_left**2 + lat_left**2 ) off_right = sqrt( lon_right**2 + lat_right**2 )
81
Figure 18. Steer Axis Offset (Top View)
Kingpin (steer) axis
OF
FS ET
Wheel center axis unit vector (wcv)
N -LO OFF
OFF
- LA T
Wheel center (WCP)
Wheel plane
Request Statements
Offset:
REQUST/id, FUNCTION= USER(900,44,characteristics_input_array_id)\
Longitudinal offset:
Lateral offset:
Nomenclature
s s
Bold text in uppercase letters, such as R, shows vectors. Bold text in lowercase letters, such as u_lon, shows unit vectors.
X is the vector cross product operator. o is the vector dot product operator. * is the scalar multiplication operator.
s s s
82
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 Figure 15 on page 69). Turn radius is positive for right turns and negative for left turns.
s s
Request Names
turn_radius/left turn_radius/right
Inputs
s s s s
Steer angle (see Steer Angle on page 78) 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-hand turn:
Turn Radius = - [Wheel Base (DCOSY/DCOSX) + Track/2]
Right-hand turn:
Turn Radius = [Wheel Base (DCOSY/DCOSX) + Track/2]
Section II - Running Full-Vehicle Analyses
Includes:
s s s s
Performing Full-Vehicle Analyses, 85 Using the Driving Machine, 99 Defining Driver Control Files, 107 Defining Driver Control Data Files, 133
84
Running Analyses in ADAMS/Car Section II - Running Full-Vehicle Analyses
Performing Full-Vehicle Analyses
Overview
This chapter describes how to analyze full-vehicle assemblies.
s s s s
Full-Vehicle Analysis Process, 86 Assembling Your Vehicle, 87 Checking Your Vehicle, 88 Performing Full-Vehicle Analyses, 89
86
Running Analyses in ADAMS/Car Performing Full-Vehicle Analyses
Full-Vehicle Analysis Process

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. You can also examine and understand the influence of component modifications, including changes in spring rates, damper rates, bushing rates, and anti-rollbar rates, on the total vehicle dynamics.
Figure 19 shows an overview of the process.
Figure 19. Full-Vehicle Analysis Process
Step 1: Open Assembly Step 2: Set Parameters Step 3: Perform Analysis Step 4: Animate and Plot
6 5 4 3 2 1 2 3 4 5
1, 3.00, 65%, 35%
87
Assembling Your 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. To create a full-vehicle assembly, you must select a test rig appropriate for the analyses you want to perform. For open-loop and ADAMS/Driver analyses, select the __MDI_DRIVER_TESTRIG. For quasi-static analyses, select either the __MDI_DRIVER_TESTRIG or the __MDI_SDI_TESTRIG. For Driving Machine (closed-loop) analyses, select the __MDI_SDI_TESTRIG. 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, that mount point cannot move with the full vehicle, which causes the ADAMS/Car analysis to fail.
88
Checking Your 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:
s s s
Is the front suspension in the correct place? Is the body graphic positioned correctly? Are the wheels somewhere near the same height?
To perform open-loop and ADAMS/Driver analyses, use the test rig __MDI_DRIVER_TESTRIG. To perform Driving Machine (closed-loop) analyses, use the test rig __MDI_SDI_TESTRIG. Finally, 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 2 3
From the File menu, point to Info, and then select Assembly. In the Assembly Name box, enter the name of your assembly. Select OK. ADAMS/Car displays the Information window, with the test rig name listed at the top of the window.
89
Performing Full-Vehicle Analyses

You can perform a variety of full-vehicle analyses using ADAMS/Car. The next sections describe the different types of analyses you can perform starting with an overview of the different analysis types.
s s s s s
Overview Of Analyses, 90 Open-Loop Analyses, 91 Driving Machine Analyses, 93 Quasi-Static Analyses, 95 ADAMS/Driver Analyses, 97
90
Overview Of Analyses
You can perform four types of full-vehicle analyses using ADAMS/Car:
s
Open loop - In open-loop analyses, the steering, throttle, brake, gear, and clutch inputs to your full vehicle are functions of time. Open-loop analyses use the __MDI_DRIVER_TESTRIG.
Driving Machine (open and closed loop) - Driving Machine analyses combine open- and closed-loop control of the steering, throttle, brake, gear, and clutch to perform complex analyses on your full vehicle, such as braking-in-turn. You can also script your own Driving Machine analyses using a driver control file (.dcf). For more information on .dcf files, see Defining Driver Control Files on page 107. Driving Machine analyses use the __MDI_SDI_TESTRIG.
Quasi-static - 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.1gs to 0.5gs does not show the lateral acceleration or yaw rate overshoot that a similar open-loop and closed-loop analysis might show. Quasi-static analyses use either the __MDI_DRIVER_TESTRIG or the __MDI_SDI_TESTRIG.
ADAMS/Driver analyses - ADAMS/Driver enables you to add the control actions of a human driver to your full-vehicle simulations. These actions include steering, braking, throttle position, gear shifting and clutch operation.
ADAMS/Driver analyses use the __MDI_DRIVER_TESTRIG.
91
Open-Loop Analyses
In open-loop analyses, the steering, throttle, brake, gear, and clutch inputs to your full vehicle are functions of time. ADAMS/Car provides a range of open-loop analyses, using the __MDI_DRIVER_TESTRIG, which are explained in the next sections:
s s s s s
Single Lane-Change Analysis, 91 Acceleration Test Analysis, 91 Braking Test Analysis, 92 Steering Analyses, 92 Data-Driven Analysis, 93
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:
s s s s
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.
For information on specifying a single lane-change analysis, see the online dialog box help.
Acceleration Test Analysis
An acceleration test analysis ramps the throttle demand from zero to your input rate. You can specify either free or locked steering. An acceleration test analysis helps you study the anti-lift and anti-squat properties of a vehicle.
For information on specifying a acceleration test analysis, see the online dialog box help.
92
Braking Test Analysis
A braking test ramps the brake input from zero to your input rate. 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.
For information on specifying a braking test analysis, see the online dialog box help.
Steering Analyses
A steering analysis can be one of the following:

s
Step Steer - The purpose of this maneuver is to 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 step steer analysis, ADAMS/Car increases the steering input from an initial value to a final value over a specified time. Ramp Steer - The purpose of this maneuver is to 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. Impulse Steer - 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 have the option of running 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, vehicle roll and yaw rate both in time and frequency domain. Drift - 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, initial throttle, and initial velocity values. In seconds 1 through 4 of the analysis, ADAMS/Car ramps the steering angle/length from an initial value to a desired value. It then ramps the throttle from zero to the initial throttle value in seconds 5 through 10. Finally, it ramps the throttle value up to the desired value from a time of 10 seconds to the desired end time.
93
Swept-Sine Steer - 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 speed, and 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.
For more information on specifying steering analyses, see the online dialog box help.
Data-Driven Analysis
You define the inputs for a data-driven analysis in a driver loadcase file (dri.). A driver loadcase file specifies inputs to the vehicle as steering value, desired velocity, braking pressure, and so on.
For more information on specifying a data-driven analysis, see the online dialog box help.
Driving Machine Analyses

You use Driving Machine analyses to perform complex analyses combining both open- and closed-loop control of your full vehicle. To use the Driving Machine, assemble your full-vehicle model with the __MDI_SDI_TESTRIG. For more information on the Driving Machine, see Chapter 5, Using the Driving Machine. ADAMS/Car provides three standard Driving Machine analyses and lets you also script and then submit your own Driving Machine analyses:
s s s s
Braking-In-Turn Analysis, 94 Constant Radius Cornering Analysis, 94 ISO-Lane Change Analysis, 94 Driver-Control-File-Driven Analysis, 94
94
Braking-In-Turn Analysis
Braking in a turn is one of the most critical analyses encountered in everyday driving. The purpose of this maneuver is to examine path and directional deviations caused by sudden braking during cornering. Typical results collected from the braking-in-turn test include lateral acceleration, variations in turn radius, and yaw angle as a function of longitudinal deceleration. In a braking-in-turn analysis, the Driving Machine drives your full-vehicle down a straight road, turns onto a skidpad, and then accelerates to achieve a desired lateral acceleration. Once the desired lateral acceleration is reached, the Driving Machine holds the longitudinal speed and radius constant for a time to let any transients settle. Then, it locks the steering wheel and brakes your full vehicle at a constant deceleration rate. It maintains the deceleration rate for a given duration or until the vehicle speed drops below 2.5 meters/second. You can use the plot configuration, mdi_fva_bit.plt, in the shared ADAMS/Car database to generate the plots that are typically of interest for this type of analysis.
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 full vehicles understeer characteristics.
ISO-Lane Change Analysis
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 input.
Driver-Control-File-Driven Analysis
The driver-control-file-driven analysis lets you run a analysis described in an existing driver control file (.dcf). For the format and content of .dcf files, see Defining Driver Control Files on page 107. Having direct access to .dcf files allows you to easily perform non-standard analyses on your full-vehicle assembly because all you have to do is to generate a new .dcf file describing the analysis.
95
Quasi-Static Analyses
The following sections introduce quasi-static analyses:
s s s
Quasi-Static Analysis Setup, 95 Constant Radius Cornering Analysis, 96 Constant Velocity Cornering Analysis, 96
Quasi-Static Analysis Setup
Before you submit a quasi-static analysis, you must set up the assembly to run quasistatic analyses. You set up a quasi-static analysis by selecting the Setup button from the constant radius cornering or constant velocity corning dialog boxes. ADAMS/Car then adds additional modeling elements that do not exist by default in the standard MDI fullvehicle assemblies. If necessary, as part of the setup procedure, ADAMS/Car prompts you to identify various elements in your assembly. You can avoid being prompted for these elements by including the following communicators in the appropriate templates, as follows:
s
Body template:
x
cos_body communicator: part communicator
Front/rear suspension template:

x x
co[lr]_suspension_upright: part communicator co[lr]_suspension_mount: part communicator
Steering template:
x
cos_steering_wheel_joint: joint communicator
Powertrain template:
x x x
co[lr]_output_torque: force communicator cos_drive_torque_left: solver variable communicator cos_drive_torque_right: solver variable communicator
These communicators are defined in the standard templates distributed with ADAMS/Car.
96
Constant Radius Cornering Analysis
You use a constant radius cornering analysis to evaluate your full vehicles understeer/oversteer characteristics. The constant radius cornering analysis holds the turn radius constant and varies the vehicle velocity to produce increasing amounts of lateral acceleration. You can 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. Before submitting a constant radius cornering analysis, you must select the Setup button to set up your full-vehicle assembly for a quasi-static analysis.
Constant Velocity Cornering Analysis
You use a constant velocity cornering analysis to evaluate your full vehicles understeer/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 the vehicle longitudinal velocity is specified instead of turn radius. 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. Before submitting a constant velocity cornering analysis, you must select the Setup button to set up your full-vehicle assembly for a quasi-static analysis.
97
ADAMS/Driver Analyses
ADAMS/Driver enables you to add the control actions of a human driver to your fullvehicle simulations. These actions include steering, braking, throttle position, gear shifting and clutch operation. Using ADAMS/Driver, you can extend the set of fullvehicle events available in ADAMS/Car. ADAMS/Car simulates the vehicle on a user-defined track representing a road. For information on using ADAMS/Driver, see the guide, Using ADAMS/Driver, and the online dialog box help. You must have a license to ADAMS/Driver to run an ADAMS/Driver analysis.
98
Using the Driving Machine
Overview
This chapter explains how you can work with the Driving Machine to perform full-vehicle maneuvers. It includes the following sections:
s s s s s
About the Driving Machine, 100 About Data Flow in the Driving Machine, 101 What You Can Do with the Driving Machine, 103 How You Benefit From Using the Driving Machine, 103 Steps in Using the Driving Machine, 104
100
Running Analyses in ADAMS/Car Using the Driving Machine
About the Driving Machine

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 open-loop or closed-loop controllers, or both, to carry out your instructions. You can instruct the Driving Machine to switch between open- and closed-loop control during a simulation.
s
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. Using closed-loop control, the Driving Machine can steer a vehicle around a skid-pad, while gradually increasing speed.
You script your instructions to the Driving Machine in a text file called a driver control file (.dcf). Recorded open-loop signals and vehicle path and velocity are read from text files called driver control data files (.dcd). For more information about .dcf files, see Chapter 6, Defining Driver Control Files. For more information about .dcd files, see Chapter 7, Defining Driver Control Data Files. To help you calculate the control signals, the Driving Machine passes vehicle states such as position, velocity, and acceleration, to your driver controller and provides a means for defining and passing sets of command signals, feedback signals, and parameters for each of the five control signals. When working with the Driving Machine, you can use two types of data to control the vehicle: open-loop and closed-loop data. For more information on the types of data, see Chapter 7, Defining Driver Control Data Files.
101
About Data Flow in the Driving Machine

When you submit a simulation using the Driving Machine, ADAMS/Car generates an ADAMS Solver dataset file (.adm), an ADAMS Solver command file (.acf), and a driver control file (.dcf). The .adm file references the driver control file, and the .acf file invokes a CONSUB subroutine included in the ADAMS/Car Solver that reads and processes the .dcf file to perform the maneuver described in the file. ADAMS/Car Solver then provides the standard output files: .msg, .req, .res, .gra, and .out. The driver control file describes the maneuver you want to perform as a list of minimaneuvers. The driver control file can reference one or more driver control data files. Driver control data files contain either vehicle path and speed for use by the machine (closed-loop) controller or steering, throttle, brake, gear, and/or clutch signals for use as open-loop inputs to the vehicle.
Figure 20 summarizes the data flow specific to the Driving Machine.
102
Figure 20. Driving Machine Data Flow ADAMS/Car Interface
Driver control data file (.dcd)
Driver control file (.dcf)
ADAMS command file (.acf)
ADAMS dataset file (.adm)
ADAMS/Car Solver
.msg .req .res .gra .out Output files
103
What You Can Do with the Driving Machine

Using the Driving Machine, you can:
s
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. 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 travelled.
How You Benefit From Using the Driving Machine

When working with the Driving Machine, you have the following benefits:
s
You save the time you previously needed to set proper gains for closed-loop controllers. The Driving Machine incorporates proprietary control algorithms from IPG. You shorten simulation times by ending simulations based on targets for lateral acceleration, longitudinal velocity, and distance travelled. 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.
104
Steps in Using the Driving Machine

Using the Driving Machine involves the following steps:
1 2
Assemble a full-vehicle model with the Driving Machine test rig or open an existing full-vehicle assembly. Do either of the following:
s
From the Simulate menu, point to Full-Vehicle Analysis, point to Driving Machine, and then select the type of analysis you want to perform. Create your own .dcf files to perform your specific set of simulations.
Figure 21 illustrates how the Driving Machine works in a virtual prototyping model.
105
Figure 21. Driving Machine in the ADAMS Model FULL-VEHICLE MODEL

Feedback Channels Actuator Application Areas Steering Traction Braking Transmission Clutch
DRIVING MACHINE
Standard Driver Interface Open Loop Closed Loop Machine Control Human Control
SDI Router Subroutine
Command Interpreter
Interface (GUI) Command Generator
DRIVING MACHINE COMMAND SET (.dcf and .dcd files)
106
Defining Driver Control Files
Overview
You use driver control files (.dcf) to describe the maneuvers that you want the Driving Machine to perform. This chapter introduces you to the following topics:
s s s s s s
About Driver Control Files, 108 Driver Control File Structure, 110 Specifying Attributes, 113 Creating .dcf Files, 130 Referencing .dcd Files, 130 Example .dcf File, 131
108
Running Analyses in ADAMS/Car Defining Driver Control Files
About Driver Control Files

Driver control files (.dcf) describe how you want the Driving Machine to drive your vehicle during an experiment or analysis. The driver control file instructs the Driving Machine how fast to drive the vehicle, where to drive the vehicle (for example, on a 80m radius skidpad), and when to stop an experiment (lateral acceleration = 8m/s). Driver control files specify what kinds of controllers the Driving Machine should use for which input signals, such as steering, throttle, and so on. A driver control file can reference other files, primarily driver control data files (.dcd), to obtain necessary input data, such as speed versus time. For information on referencing .dcd files, see Referencing .dcd Files on page 130. Driver control files organize complex experiments into a set of smaller, simpler steps called mini-maneuvers. A driver control file primarily contains a list of minimaneuvers in an experiment block followed by blocks of data: one for each minimaneuver. The data block for each mini-maneuver in turn specifies how the Driving Machine is to control the steering, throttle, brake, gear, and clutch. As an example, you might instruct a test driver to perform a brake-in-turn experiment in three steps:
1
Drive forward in third gear for 50 m starting at 18 m/s (65 kph). Then turn left onto an 80 m radius skidpad and accelerate until the vehicle is cornering at 7 m/s/s lateral acceleration. For two seconds, continue turning left on an 80m radius while maintaining lateral acceleration at 7 m/s/s to let any transients from longitudinal acceleration damp out. Start the data recorder, then holding the steering wheel fixed, brake at 3 m/s/s deceleration until the vehicle velocity decreases to 3 m/s (~10 k/h).
109
A driver control file you create to describe this same experiment would first list the three mini-maneuvers (set_up, settle_time, and braking) in an experiment block. The experiment block in the .dcf file looks like this:
[EXPERIMENT] EXPERIMENT_NAME = Braking in Turn INITIAL_SPEED = 20.000 {mini_maneuver SET_UP SETTLE_TIME BRAKING pri_end ACCELERATION TIME VELOCITY pri_value 7.0 2.0 3.0 abort_time 10.0 2.0 5.0 step_size} 0.05 0.05 0.02
Following the experiment block, the file would contain a data block for each minimaneuver. The settle_time mini-maneuver block looks like this:
[SETTLE_TIME] (STEERING) ACTUATOR_TYPE METHOD (THROTTLE) METHOD (BRAKING) METHOD (GEAR) METHOD MODE CONTROL_TYPE CONTROL_VALUE (CLUTCH) METHOD MODE CONTROL_TYPE CONTROL_VALUE
= ROTATION = MACHINE
= MACHINE
= MACHINE
= OPEN = ABSOLUTE = CONSTANT =3
= OPEN = ABSOLUTE = CONSTANT =0
To complete the brake-in-turn experiment, you must also supply data blocks for the setup and braking mini-maneuvers.
110
Driver Control File Structure

Driver control files, like other ADAMS/Car property files, use a TiemOrbit style format. The TiemOrbit format is described in terms of blocks, sub-blocks, attributes, and tables. The following are the required data blocks for any .dcf file:
s
MDI header block - Identifies the file as a .dcf file and provides version information. The following shows an example header block:
$---------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME = braking_in_turn.dcf FILE_TYPE = dcf FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCF file of braking in a turn simulation
Units block - Identifies the units of the parameters in the .dcf file. The following shows an example units block:
$--------------------------------------------------------------------------UNITS [UNITS] LENGTH = meter FORCE = newton ANGLE = rad MASS = kg TIME = sec
Experiment block - Specifies the initial vehicle velocity and a list of mini-maneuvers for the experiment. The Driving Machine executes each mini-maneuver in the order listed, until the list is ended or a mini-maneuver is terminated. For each mini-maneuver, the experiment block also specifies the primary end condition and value, the end time, and the output step size. If the primary end condition is satisfied, the Driving Machine terminates the
111
mini-maneuver and proceeds to execute the next mini-maneuver in the list. If the end time is reached before the end condition is satisfied, the Driving Machine terminates the experiment. Primary end conditions include:
s s s
VELOCITY - Vehicle longitudinal velocity ACCELERATION - Vehicle lateral acceleration DISTANCE - Total distance travelled by the vehicle during a
mini-maneuver
s
TIME - Simulation time
Primary end conditions are satisfied when the measured value is within +/- 0.2% of the pri_value in the experiment block. For example, if the primary end condition for a mini-maneuver is VELOCITY and the pri_value is 10 m/s, the Driving Machine terminates the mini-maneuver when the measured vehicle longitudinal velocity is greater than 9.98 m/s and less than 10.02 m/s. The following shows an example experiment block:
$---------------------------------------------------------------------EXPERIMENT [EXPERIMENT] EXPERIMENT_NAME= Braking in a Turn: INITIAL_SPEED = 17.1 INITIAL_GEAR =3 {mini_maneuver pri_end pri_value INITIAL_SET TIME 10.0 BRAKE_TURN TIME 5.0
s
abort_time 10.0 5.0
step_size} 0.05 0.02
Mini-maneuver block - A driver control file can contain an unlimited number of mini-maneuver blocks. Each mini-maneuver block must contain steering, throttle, brake, gear, and clutch sub-blocks. A mini-maneuver block must also contain sub-blocks that define the control methods. For more information on control methods, see Specifying a Control Method on page 115.
112
The following shows an example mini-maneuver block, complete with subblocks:

$---------------------------------------------------------------------BRAKE_TURN [BRAKE_TURN] (STEERING) ACTUATOR_TYPE= ROTATION' METHOD= 'OPEN' MODE = RELATIVE' CONTROL_TYPE= CONSTANT' CONTROL_VALUE= 0 (THROTTLE) METHOD = 'OPEN' MODE = 'ABSOLUTE' CONTROL_TYPE= 'CONSTANT' CONTROL_VALUE= 0 (BRAKING) METHOD= 'OPEN' MODE= 'ABSOLUTE' CONTROL_TYPE= 'STEP' START_TIME= 0.0 INITIAL_VALUE= 0.0 FINAL_VALUE= 2.0E+07 DURATION= 0.5 (GEAR) METHOD= 'OPEN' MODE= 'ABSOLUTE' CONTROL_TYPE= 'CONSTANT' CONTROL_VALUE= 3 (CLUTCH) METHOD= 'OPEN' MODE= 'ABSOLUTE' CONTROL_TYPE= 'CONSTANT' CONTROL_VALUE = 0
For examples of .dcf files, see Appendix D, Example Driver Control Files.
113
Specifying Attributes
To define the different sub-blocks, you must specify their attributes. Table 1 lists the attributes you must specify for each sub-block.
Table 1. Attributes Required by Sub-blocks These sub-blocks: Require these attributes:
x x x
Steering
ACTUATOR_TYPE METHOD MODE METHOD MODE
Throttle, brake, gear, and clutch
x x
You specify attributes as described in the following sections:

s s s
Specifying an Actuator Type, 113 Specifying a Control Method, 115 Specifying a Mode, 129
Specifying an Actuator Type

When defining a steering sub-block, you must specify its 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, as described next.
114
ACTUATOR_TYPE
Definition
The actuator type specifies where and by what means the Driving Machine steers the vehicle. The Driving Machine steers the vehicle from the steering wheel or the steering rack, using a motion or a force. For example, when you specify ACTUATOR_TYPE = 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 in the .dcf file. For example, if you specify ACTUATOR_TYPE = TORQUE, then the Driving Machine interprets the AMPLITUDE parameter for an open loop sinusoidal input as torque (with units of length*force). However, if you specify ACTUATOR_TYPE='ROTATION', the Driving Machine then interprets the AMPLITUDE as an angle.
Arguments
ACTUATOR_TYPE = ROTATION || TRANS || FORCE || TORQUE

s
ROTATION - When you specify ACTUATOR_TYPE = 'ROTATION', the Driving Machine steers the vehicle using a MOTION statement on the steering wheel revolute joint. TRANS - When you specify ACTUATOR_TYPE = 'TRANS', the Driving Machine steers the vehicle using a
motion on the steering rack translational joint.

s
FORCE - When you specify ACTUATOR_TYPE = 'FORCE', the Driving Machine steers the vehicle by
applying a force to the steering rack.

s
TORQUE - When you specify ACTUATOR_TYPE = 'TORQUE', the Driving Machine steers the vehicle by
applying torque to the steering wheel.
115
Specifying a Control Method

When defining any sub-block, you must specify the control method that you want to use. You can choose from three control methods, as follows:
s s s
OPEN_CONTROL, 116 MACHINE_CONTROL, 124 HUMAN_CONTROL, 127
116
OPEN_CONTROL
Definition
You cannot switch from an open-loop control mini-maneuver to a human control mini-maneuver. You can, however, switch human control in a preceding mini-maneuver to open-loop control in a following mini-maneuver. When you specify METHOD = OPEN for steering or any other signal, the Driving Machine output for that signal is a function of time, and you must specify the function using the CONTROL_TYPE argument.
Arguments
CONTROL_TYPE = CONSTANT || STEP || RAMP || IMPULSE || SINE || SWEPT_SINE || DATA_DRIVEN
Not all control types are valid for all sub-blocks. For example, SWEPT_SINE is not valid for the THROTTLE sub-block. Table 2 shows the valid control types for the steering, throttle, brake, gear, and clutch sub-blocks.
Table 2. CONTROL_TYPE Arguments This sub-block: Uses these CONTROL_TYPE arguments:
x x x x x x x
Steering
CONSTANT STEP RAMP IMPULSE SINE SWEPT_SINE DATA_DRIVEN CONSTANT STEP RAMP DATA_DRIVEN CONSTANT STEP RAMP DATA_DRIVEN
Throttle
x x x x
Brake
x x x x
117
Table 2. CONTROL_TYPE Arguments (continued) This sub-block: Uses these CONTROL_TYPE arguments:
x x
Clutch Gear
CONSTANT DATA_DRIVEN CONSTANT DATA_DRIVEN
x x
Depending on the sub-block youre defining (see Table 2), you must specify the following CONTROL_TYPE arguments:
s
CONSTANT - Specify CONTROL_TYPE = CONSTANT
to have the Driving Machine input a constant signal to your vehicle model. When you specify CONTROL_TYPE = CONSTANT, you must also supply a CONTROL_VALUE = real.
s
STEP - When you specify CONTROL_TYPE = STEP, the Driving Machine inputs a cubic STEP function to your vehicle model based on the following input parameters, which you must supply: START_TIME DURATION INITIAL_VALUE 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.
118
Figure 22. STEP Function
final value initial value
start time duration
RAMP - When you specify CONTROL_TYPE = RAMP, the Driving Machine supplies a ramp input. To define the ramp, you must supply the following parameters: START_TIME INITIAL_VALUE RAMP_VALUE 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.
119
IMPULSE - When you specify METHOD = OPEN and CONTROL_TYPE = 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 parameters:
s
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.
s s
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. The function definition for IMPULSE is 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
120
The following plot illustrates the IMPULSE function:

Figure 23. IMPULSE Function
1.5
1.2
0.9
0.6
MAXIMUM VALUE
0.3
0.0
START TIME
-0.3 0.0 0.5
DURATION
1.0 T IME 1.5 2.0
SINE - When you specify METHOD = OPEN and CONTROL_TYPE = 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.
s
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.
s
CYCLE_LENGTH - The length of time to complete
one cycle of the sinusoid.

s s
INITIAL_VALUE - The starting value of the output. AMPLITUDE - The amplitude of the sinusoid.
121
The function definition for SINE is 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 ) OUTPUT = INITIAL_VALUE + AMPLITUDE * SIN( 2.0*PI*(TIME - START_TIME)/ CYCLE_LENGTH) IF ( T1 > 1.0 and 0.0 < T2 < 1.0 ) OUTPUT = INITIAL_VALUE + AMPLITUDE * 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
122
The following plot illustrates the SINE function:

Figure 24. SINE Function
1.0
0.5
0.0 INITIAL_VALUE
-0.5
AMPLITUDE -1.0
-1.5 0.0 0.5 1.0 TIME 1.5 2.0
SWEPT_SINE - Swepts 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:
s
START_TIME - The starting time of the function,
measured from the beginning of the mini-maneuver.

s
INITIAL_VALUE - The initial value of the swept sine
function.
s
AMPLITUDE - The amplitude of the swept sine
function.
s
INITIAL_FREQUENCY - The starting frequency of
the swept sine function in <cycles/time>.
123
FREQUENCY_RATE - The rate the frequency is swept
from the initial frequency to the maximum frequency <cycles/time/time>.

s
MAXIMUM_FREQUENCY - The maximum frequency
of the swept sine function in <cycles/time>. The following plot illustrates the SWEPT_SINE open-loop function:
Figure 25. SWEPT_SINE Function
1.0
0.5
0.0 Output INITIAL_VALUE START_TIME -0.5
AMPLITUDE -1.0
-1.5 0.0 0.5 1.0 Time 1.5 2.0
DATA_DRIVEN - Specifies that the control signal comes from a driver control data file (.dcd). You specify the .dcd filename using the FILE = argument and the Driving Machine opens the .dcd file and reads the appropriate column of signal data (STEERING, THROTTLE, BRAKE, GEAR, CLUTCH) from the [OPEN_LOOP] block.
s
FILE - Enter a .dcd file name, including the path or
ADAMS/Car database alias. For example:

FILE = <SHARED>/example.dcd
124
MACHINE_CONTROL
Definition
The MACHINE_CONTROL sub-block in the .dcf file specifies the vehicle path, speed profile, and other parameters used by machine control for the mini-maneuver block in which it resides. We recommend that if you use machine control for throttle, you also use machine control for braking. Also, if you use machine control for gear, you should use machine control for clutch. When you select MACHINE_CONTROL for gear and clutch, you must also supply the maximum and minimum engine speed. Machine control will up-shift to keep the engine speed less than the maximum, and down-shift to keep the engine speed greater than the minimum. When using machine control, you have to make sure that your .dcf file has a machine control sub-block. In the machine sub-block, specify the speed control and the steering control.
Note: If SPEED_CONTROL = LAT_ACCEL, then you must set STEERING_CONTROL to SKIDPAD.
Arguments
STEERING_CONTROL = FILE || STRAIGHT || SKIDPAD Depending on the option you select for STEERING_CONTROL, you must specify additional arguments:
s
FILE - Supply a .dcd file containing the path data: DCD_FILE_STEERING = string
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 dont need to specify additional arguments.
125
SKIDPAD - Specify the following arguments defining the
path:
TURN_DIRECTION = LEFT || RIGHT TURN_ENTRY_DISTANCE = value <length> RADIUS = value <length>
where:
s
TURN_DIRECTION - Specifies which way the vehicle turns when travelling forward. TURN_ENTRY_DISTANCE - Specifies the length of
straight path preceding the turn. Note all paths are relative to the position of the vehicle at the end of the preceding mini-maneuver. If preceding minimaneuver was a skidpad and you want the vehicle to continue on the same circle in the current minimaneuver, then specify zero (0) for TURN_ENTRY_DISTANCE.
s
RADIUS - specifies the radius of the skidpad.
SPEED_CONTROL = FILE || LAT_ACCEL || MAINTAIN || VEL_POLYNOMIAL
Depending on the option you select for SPEED_CONTROL, you must specify additional arguments:
s
FILE - Supply a .dcd file name containing closed-loop
data.
s
LAT_ACCEL - Specify the following arguments that
define the engine speed:

LAT_ACCEL_TARGET = VALUE <length/time> MAX_ENGINE_SPEED = value <rpm> MIN_ENGINE_SPEED = value <rpm>
126
MAINTAIN - When you specify 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. You dont need to specify additional arguments.
s
VEL_POLYNOMIAL - 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 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>
127
HUMAN_CONTROL
Definition
The HUMAN_CONTROL sub-bock in the .dcf file specifies the input files and parameters for ADAMS/Driver. ADAMS/Driver approximates the behavior of a human driver and is capable of learning and adapting to the characteristics of different vehicles. Before using ADAMS/Driver, we recommend that you read Chapter 4 of the printed guide, Using ADAMS/Driver, which gives an overview of how ADAMS/Driver functions. Although you cannot switch from an open-loop control minimaneuver to a human control mini-maneuver, you can switch from a human control mini-maneuver to an open-loop control minimaneuver.
Arguments
DRIVER_INPUT_FILE = STRING <filename.din>
Enter the name of the ADAMS/Driver input file. This file specifies the options that ADAMS/Driver uses to control the vehicle. You must supply this file. For more information, see Chapter 2 of the printed guide, Using ADAMS/Driver. Note that you can create an ADAMS/Driver input file using ADAMS/Car, as follows: from the Simulate menu, point to Full-Vehicle Analysis, and then select ADAMS/Driver.
DRIVER_ROAD_FILE = STRING <filename.drd>
Enter the name of the ADAMS/Driver road input file. This files specifies the road as a set of x, y, z coordinates and lane widths. You must supply this file. For more information, see Chapter 2 of the printed guide, Using ADAMS/Driver.
START_DRIVER_ACTIVITIES = VALUE <time>
Enter the time after the beginning of the mini-maneuver when you want ADAMS/Driver to start controlling the vehicle. If the mini-maneuver is the first in the experiment (simulation), this time must be greater than zero.
128
LEARNING_ACTIVITIES = LATERAL_DYNAMICS || LONGITUDINAL_DYNAMICS || BASIC_DYNAMICS || LIMIT_HANDING || NONE
ADAMS/Driver has the ability to learn and adapt to a particular vehicles characteristics. Using LEARNING_ACTIVITIES you specify the kind of learning ADAMS/Driver does. ADAMS/Driver stores what it learns about your vehicle in the output knowledge file for use in subsequent simulations.
s
LATERAL_DYNAMICS - ADAMS/Driver learns and adapts to the vehicles lateral dynamics only. LONGITUDINAL_DYNAMICS - ADAMS/Driver learns
and adapts to the vehicles longitudinal dynamics only.

s
BASIC_DYNAMICS - ADAMS/Driver learns and adapts
to the vehicle lateral and longitudinal dynamics.

s
LIMIT_HANDING - ADAMS/Driver learns and adapts to
the vehicles limit handling characteristics. To learn the limit handling characteristics of a vehicle ADAMS/Driver attempts to drive the vehicle as quickly as possible.
s
NONE - ADAMS/Car does not record any of the
information resulting from the mini-maneuver.

REMEMBER = YES || NO
Select an option for REMEMBER. When you select YES, ADAMS/Driver reads the knowledge file you specify using the KNOWL_INPUT_FILE argument. Each time you run ADAMS/Driver, it creates a knowledge file, KNOWL_OUTPUT_FILE, to store what it learns about the vehicles characteristics.
KNOWL_INPUT_FILE = limit_handling.kno
Enter a path and the name of the input knowledge file.

KNOWL_OUTPUT_FILE = limit_handling1.kno
Enter the path and the name of the output knowledge file.
129
Specifying a Mode
When defining any sub-block, you must specify the mode that you want to use.
MODE
Definition
You set MODE to tell the Driving Machine where to apply the output of the open loop, human, or machine controller.
MODE = RELATIVE || ABSOLUTE
s
Arguments
RELATIVE - When you specify MODE = 'RELATIVE', the signal the Driving Machine applies is relative to the ending value from the last mini-maneuver. For example, if you want to maintain the ending steering value from the previous mini-maneuver you leave the ACTUATOR_TYPE unchanged and set: (STEERING) ... METHOD = 'OPEN' MODE = 'RELATIVE' CONTROL_TYPE = 'CONSTANT' CONTROL_VALUE= 0.0
ABSOLUTE - When you specify MODE = 'ABSOLUTE', the
signal the Driving Machine applies is independent of the signals ending value from the previous mini-maneuver.
130
Creating .dcf Files

MDI gives you .dcf files that you can modify and then use when running full-vehicle analyses. You can also create your own .dcf files using a text editor.
To create .dcf files using a text editor: 1 2 3
Create a new file in a text editor. Create a .dcf file. Save the file and use it when running a full-vehicle analysis.
Referencing .dcd Files

You can reference driver control data files through driver control files to specify data for the method of control of the vehicle. When referencing .dcd files, .dcf files can obtain two types of data:
s
Open-loop data - Includes steering wheel angle, throttle position, brake pressure, gear, and clutch position tabulated against time or distance traveled. Closed-loop data - Is data used by machine control 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 travelled (s). Closed-loop data may also include vehicle speed and lateral acceleration which the machine controller integrates to determine the desired vehicle path and speed.
The DATA_DRIVEN keyword in the .dcf file specifies that you want to use data stored in a .dcd file. That is, you use the DATA_DRIVEN keyword with machine control or open control in a mini-maneuver of a .dcf file to specify that you want to obtain control data from a .dcd file. For an example of a .dcf file that references a .dcd file, see Data-Driven Test on page 203.
131
Example .dcf File

$---------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME = iso_lane_change.dcf FILE_TYPE = dcf FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCF File for Closed Loop ISO-Lane Change $--------------------------------------------------------------------------UNITS [UNITS] LENGTH = meters FORCE = newton ANGLE = radians MASS = kg TIME = sec $---------------------------------------------------------------------EXPERIMENT [EXPERIMENT] EXPERIMENT_NAME = LIMIT_HANDLING INITIAL_SPEED = 16.667 {mini_maneuver pri_end pri_value abort_time step_size} LIMIT_HANDLING TIME 120.0 120.0 0.03 $--------------------------------------------------------------------LANE_CHANGE [LIMIT_HANDLING] (STEERING) ACTUATOR_TYPE = ROTATION METHOD = HUMAN (THROTTLE) METHOD = HUMAN
132
(BRAKING) METHOD = HUMAN (GEAR) METHOD = HUMAN (CLUTCH) METHOD = HUMAN (HUMAN_CONTROL) DRIVER_INPUT_FILE = <shared>/mdi_driver_001.din DRIVER_ROAD_FILE = <shared>/MDI_track.drd START_DRIVER_ACTIVITIES = 0.5 LEARNING_ACTIVITIES = LIMIT_HANDLING REMEMBER = YES KNOWL_INPUT_FILE = limit_handling.kno KNOWL_OUTPUT_FILE = limit_handling1.kno INITIAL_GEAR = 3
Defining Driver Control Data Files
Overview
This chapter introduces you to driver control data (.dcd) files. You use driver control data files to specify:
s
The path and speed, or closed-loop data, you want a vehicle to follow. The steering, throttle, brake, gear, and clutch signals, or the open loop data, you want to input to a vehicle.
To use a .dcd file, you must reference it from a driver control file (.dcf). This chapter includes the following sections:
s s s s s
About Driver Control Data Files, 134 Driver Control Data File Architecture, 135 Specifying Closed-Loop Data, 137 Example of .dcd File Architecture, 139 Creating .dcd Files, 141
134
Running Analyses in ADAMS/Car Defining Driver Control Data Files
About Driver Control Data Files

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 a driver control file (.dcf). An excerpt from a .dcf file 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, as follows:

s
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 openloop 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 may specify closed-loop data in several forms. For example, curvature and velocity versus distance travelled, or lateral acceleration and longitudinal acceleration versus time. You specify the type of data using the SPEED_CONTROL and STEERING_CONTROL attributes in the .dcd file. For more information on closed-loop data, see Specifying Closed-Loop Data on page 137.
135
Driver Control Data File Architecture

Driver control data (.dcd) files use a TiemOrbit format similar to other ADAMS/Car property files. Driver control data (.dcd) files must contain these data blocks:
s
MDI header block - Identifies the file as a .dcd (not a .dcf) file and provides version information. Units block - Identifies the units of the data contained in the .dcd file.
The driver control data (.dcd) file must also contain at least one of two data blocks:
s
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 may contain both open-loop and closed-loop blocks.
The following is an example .dcd file:

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

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

s s s s s s s s s
lon_vel = Vehicle longitudinal velocity lon_acc = Vehicle longitudinal acceleration lat_acc = Vehicle lateral acceleration T s k x y {} = Time = Aarc-length or distance traveled along the path = Curvature, k=1/radius = X position of vehicle relative to ISO-Earth Axis System = Y position of vehicle relative to ISO-Earth Axis System = Set of inputs
138
Table 3 summarizes the closed-loop data that a .dcd file may 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, vt} as needed by Driver-Lite.
Table 3. Closed-Loop Data in .dcd Files SPEED_CONTROL none STEERING_CONTROL lon_vel (p1=0) lon_acc (p1=1) lat_acc (p1=2) path (p1=3)
none
NOT VALID
{(distance or time), lon_vel}
{(distance or time), lon_acc} {(distance or time), curvature, lon_acc} {x, y, lon_acc}
NOT VALID
NOT VALID
curvature (p1 = 0)
{distance, {(distance curvature} or time), curvature, lon_vel} {x, y} {x, y, vt}
{(distance or NOT time), curvature, VALID lat_acc} {x, y, lat_acc} {x, y, time} NOT VALID
path (p1 = 1)
lat_acc (p1 = 2)
NOT VALID
{distance or time, lat_acc, lon_vel}
{distance or NOT VALID time, lat_acc, lon_acc}
139
Example of .dcd File Architecture

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 FORCE ANGLE TIME = 'meter' || 'millimeter' || 'centimeter' || 'kilometer' || etc. = 'newton' || 'kilogram_force' || etc. = 'deg' MASS = 'kg' = 'sec'
[CLOSED_LOOP] comment steering_control speed_control ordinal lon_vel_max lon_vel_min lon_acc_max lon_acc_min lat_acc_max lat_acc_min = string = 'none' || 'curvature' || 'path' || 'lat_acc' = 'none' || 'lon_vel' || 'lon_acc' || 'lat_acc' || 'path' = 'distance' || 'time' = float = float = float = float = float = float
140
(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 && k } $ 7 Case{curvature, lon_vel} $ 8 Case{curvature, lon_acc} $ 9 Case{curvature, lat_acc} $10 Case{curvature, path} -- NOT VALID { ( distance || time ) && k && ( 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 ) }
141
[OPEN_LOOP] ordinal = time || distance {distance || time 0.0 0.1 steering 0.0 0.0 throttle 0.0 0.0 brake 0.0 0.0 gear 2 2 clutch} 0.0 0.0
Creating .dcd Files

You can use the sample .dcd files that MDI provides or you can create your own .dcd files.
To create .dcd files: 1
You can use one of three methods to create .dcd files:

s
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 on page 137 and Example of .dcd File Architecture on page 139.
s s
Save the file and reference it through a .dcf file.
142
Section III - Plotting Analysis Results
Includes:
s
Managing Plots, 145
144
Running Analyses in ADAMS/Car Section III - Plotting Analysis Results
Managing Plots
Overview
You can plot the results of suspension or full-vehicle analyses using the standard functionality in ADAMS/PostProcessor. To help you manage your plots, however, ADAMS/Car provides plot configuration files that define a series of plots. The following sections describe the standard plot configuration files and how to create your own.
s s s s
About Plot Configuration Files, 146 Standard Plot Configuration Files, 147 Viewing Plots Using Plot Configuration Files, 148 Creating Plot Configuration Files, 149
For information on using ADAMS/PostProcessor, see the guide, Using ADAMS/PostProcessor.
146
Running Analyses in ADAMS/Car Managing Plots
About Plot Configuration Files

Plot configuration files let you to define a series of standard plots that you might want to plot for each type of analysis. Using a plot configuration file, you can generate different predefined sets of plots. The plot configuration file tells ADAMS/Car which plots to create and specifies the vertical and horizontal components that it should plot. It also defines general settings and preferences, such as titles, labels, horizontal and vertical spacings, scaling and legend text, and more. You can generate a plot configuration file containing the description of all or part of the plots that are currently defined during a session. You can, for example, create a plot configuration file that defines a set of plots that are significant for a particular type of suspension or full-vehicle event. You can also include a set of ADAMS/View commands to execute after youve loaded the defined plots. These commands might change the format of plots or modify the data associated with a curve. ADAMS/Car creates the plot configuration file in the plot_configs.tbl directory in your default writable database. For information on your default writable database, see Setting the Writable Database on page 15 of the guide, Configuring ADAMS/Car.
147
Standard Plot Configuration Files

ADAMS/Car comes with three standard plot configuration files. They are:
s
mdi_full_vehicle.plt - Contains a series of plots for displaying the results of a full-vehicle analysis. The plots include steering demand versus time, velocity versus time, vehicle path, and more. mdi_suspension_parallel.plt - Contains a series of plots for displaying the suspension characteristics that ADAMS/Car calculates for a suspension during analysis. For more on the different suspension characteristics, see Chapter 3, Understanding Suspension Characteristic Calculations. mdi_suspension_short.plt - Contains only 10 plots of the total characteristics
that ADAMS/Car calculates during a suspension analysis.
To view the different plot configuration files and the characteristics that they plot, open them into ADAMS/View or a text editor from the ADAMS/Car shared database.
148
Viewing Plots Using Plot Configuration Files

After youve run an analysis, you can view the series of plots defined in a plot configuration file. If your plot configuration file contains customization commands, you can have ADAMS/Car execute these commands after it creates the plots and curves.
To view the plots defined in a plot configuration file:
1 2
From the Review menu, select Postprocessing Window or press F8. From the Plot menu, select Create Plots. The Create Plots dialog box appears.
Tip:
For information on entering values in the Create Plots dialog box, press F1 when the cursor is in the main window, and then click anywhere on the dialog box.
3 4 5 6
In the Analyses box, enter the analysis or analyses from which you want to view results. In the Plot Configuration File box, enter the name of the plot configuration file defining the plots that you want to view. In the Plot Title box, enter the title to appear at the top of the plots. Select Cross Plotting to plot analysis data on existing plots containing data from other analyses. If you selected multiple analyses in the Analyses box, ADAMS/Car automatically plots the data from the different analyses on the same plots. If you have plot-customization commands in the plot configuration file you selected in Step 4, then select Execute custom macro. ADAMS/Car executes any commands that customize the plots.
Select OK.
149
Creating Plot Configuration Files

You can create a plot configuration file containing all of the plots currently in ADAMS/PostProcessor or only a selected set of plots. ADAMS/Car stores the configuration files in the plot_config table of your default writable database.
To create a plot configuration file:
1 2
From the Review menu, select Postprocessing Window or press F8. Create and configure plots as desired, including specifying labels and spacing. For example, you can create a set of plots and add subtitles to all of them that describe the type of analysis with which the plots are associated. From the File menu, point to Export, and then select Plot Configuration File. The Save Plot Configuration File dialog box appears.
Tip:
For information on entering values in the Save Plot Configuration File dialog box, press F1 when the cursor is in the main window, and then click anywhere on the dialog box.
4 5 6 7
In the Configuration File Name box, enter the name for the plot configuration. If you want to include all plots currently in the Plotting window, including every page, select All Plots. If you did not select All Plots, in the Plot Name(s) box, enter the names of the plots that you want included in the plot configuration file. In the Plots and Curves boxes, enter commands to customize the plots and curves. ADAMS/Car saves these commands with your plotting configuration file. It executes the commands after it creates the plots and curves. Select OK.
150
Section IV - Appendixes
Includes:
s s s s
Example Suspension Loadcase File, 153 Example Wheel-Envelope Files, 157 Driving Machine Test Rig Structure, 161 Example Driver Control Files, 195
152
Running Analyses in ADAMS/Car Section IV - Appendixes
Example Suspension Loadcase File
Overview
This appendix contains an example loadcase file that you can use to specify different types of suspension analyses in ADAMS/Car.
154
Running Analyses in ADAMS/Car Example Suspension Loadcase File
$---------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_TYPE = lcf FILE_VERSION = 4.0 FILE_FORMAT = ASCII $--------------------------------------------------------------------------UNITS [UNITS] LENGTH ANGLE FORCE MASS TIME
= mm = degrees = newton = kg = 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
155
$---------------------------------------------------------------------------data [DATA] $COLUMN: $ (c1) $ (c2) $ (c3) $ (c4) $ (c5 $ (c6) $ (c7) $ (c8) $ (c9) $ (c10) $ (c11)
{ whl_z_l -100.0000 -80.0000 -60.0000 -40.0000 -20.0000 0.0000 20.0000 40.0000 60.0000 80.0000 100.0000
input type: wheel z wheel z lateral lateral aligning aligning brake brake driving driving steering
whl_z_r lat_l
type of input data: disp / force disp / force force (y) force (y) torque (z-axis) torque (z-axis) force (y) force (y) force (y) force (y) force / steer angle / rack travel
lat_r 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 align_l 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 align_r 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
side: left right left right left right left right left right
drive_r 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 steer} 0.0000 0.0000 0.0000 0.0000 0.0000 0.000 0.0000 0.0000 0.0000 0.0000 0.0000
brake_l brake_r drive_l 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.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
-100.0000 -80.0000 -60.0000 -40.0000 -20.0000 0.0000 20.0000 40.0000 60.0000 80.0000 100.0000
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
156
Example Wheel-Envelope Files
Overview
This appendix contains examples of wheel-envelope files:
s s
Example Wheel-Envelope Input File, 158 Example Wheel-Envelope Output File, 160
158
Running Analyses in ADAMS/Car Example Wheel-Envelope Files
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.
$---------------------------------------------------------------------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: $ (c1) wheel z $ (c2) wheel z
type of input data: disp / force disp / force
side: left right
159
$ (c3) $ (c4 $ (c5) $ (c6) $ (c7) $ (c8 $ (c9) $ (c10) $ (c11) $ { whl_z_l -120.0 80.0 90.0 120.0 120.0 85.0 80.0 60.0 30.0 -30.0 -75.0 -120.0
lateral lateral aligning aligning brake brake driving driving steering
force (y) left force (y) right torque (z-axis) left torque (z-axis) right force (y) left force (y) right force (y) left force (y) right force / steer angle / rack travel
whl_z_r -120.0 80.0 90.0 120.0 120.0 85.0 80.0 60.0 30.0 -30.0 -75.0 -120.0
lat_l 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
lat_r 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
align_l 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
align_r 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
brake_l 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
brake_r 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
drive_l 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
drive_r 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
steer} -500.0 -500.0 -300.0 -200.0 200.0 350.0 500.0 500.0 450.0 450.0 500.0 500.0
160
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 the order listed below:
s s s
Type of file ADAMS dataset title Date and time of file creation
The table that follows the header contains the following information:
s s s s s
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 2 3 4 5 6 7 8 9 -4.2702 -673.57 205.00 -4.6463 -681.45 225.00 -348.83 -1611.7 170.29 7.0293 -344.63 -1621.7 206.15 6.7629 -340.16 -1630.0 239.60 6.5706 -334.67 -1637.0 271.40 6.3755 -328.07 -1643.0 301.70 6.1779 -320.38 -1648.0 330.44 5.9864 -311.59 -1652.1 357.51 5.8099 -301.72 -1655.3 382.78 5.6583 -290.74 -1657.8 406.03 5.5424 -278.64 -1659.4 426.98 5.4752 670.69 678.55 684.92 689.93 693.66 696.18 697.55 697.79 696.93 695.00 205.00 225.00 245.00 265.00 285.00 305.00 303.63 1620.7 107.88 307.97 1628.3 139.91 311.28 1634.4 170.26 314.35 1639.0 198.89 317.43 1642.1 225.76 320.67 1643.8 250.76
-4.9532 -687.82 245.00 -5.2433 -692.82 265.00 -5.5240 -696.55 285.00 -5.7905 -699.08 305.00 -6.0372 -700.45 325.00 -6.2583 -700.71 345.00 -6.4469 -699.89 365.00
325.00 324.25 1644.1 273.76 345.00 365.00 385.00 328.31 1643.0 294.55 333.04 1640.3 312.88 338.63 1636.2 328.39
10 -6.5953 -698.01 385.00 ... ..............
Driving Machine Test Rig Structure
Overview
The Driving Machine exists in ADAMS/Car as a test rig model (__MDI_SDI_TESTRIG). This chapter describes the ADAMS/Solver statements that comprise the Driving Machine and the subroutine interface, or the standard driver interface (SDI), for defining your own controller. This chapter introduces you to the following topics:
s s s s s s s
About Dataset Elements, 162 Human Control Specifications for Dataset Elements, 163 Machine Control Specifications for Dataset Elements, 165 Example SDI ADAMS/Solver Dataset Fragment, 168 Feedback Signals - Machine/Human Control, 177 Examples of Dataset Elements, 178 Subroutine (SDISUB) Parameters, 186
162
Running Analyses in ADAMS/Car Driving Machine Test Rig Structure
About Dataset Elements

For each vehicle controlled during a simulation, the Driving Machine requires a set of dataset elements consisting of:
s
A general state equations (GSE) statement and associated input (U), output (Y), and states (X) ARRAY statements. The GSE computes the steering, throttle, brake, gear, and clutch control signals and outputs these signals using the output (Y) ARRAY as input to actuators (for example, the engine is an actuator that converts a throttle signal to torque). A SENSOR statement that determines the time for each successful integration step. Five control signal ARRAY statements, one for each control signal (steering, throttle, brake, gear, and clutch). The control signal ARRAY statements point to other ARRAY statements in the dataset that contain information about feedback signals, command signals, control signal limits, and driver controller parameters associated with a control signal. A VARIABLE statement used to signal reinitialization of driver controllers. You can re-initialize SDI and any driver controllers by toggling the value of this variable from 0 to 1 during a simulation.
Optionally, you can include dataset elements that provide additional inputs to your driver controller subroutine. These elements are:
s s
Control signal limits ARRAY statements. Feedback signal variables ARRAY statements and associated VARIABLE statements. Command signal variables ARRAY statements and associated VARIABLE statements. Driver parameters ARRAY statements.
Note: The ADAMS IDs for dataset elements can vary from model to model.
163
Human Control Specifications for Dataset Elements

GSE/1, NS=5, NO=5, , X = 1, Y= 2, U=3, , XX=USER, XU=USER, YX=USER, YU=USER, , FUNCTION = USER(980,sdi_parameters_array.adams_id)\ ! SDI Parameters Array ARRAY/id, , numbers = 900,011,012,013,014,015,004,001,001\ ! ! Where the user parameters p1...p10 are: ! ! p1 = 980: Branch to Standard Driver Interface (SDI) ! p2 = 900: Branch to Human Controller (IPG-Driver) ! p3 = 011: Control Signal Parameters Array id - Steering ! p4 = 012: Control Signal Parameters Array id - Throttle ! p5 = 013: Control Signal Parameters Array id - Brake ! p6 = 014: Control Signal Parameters Array id - Gear ! p7 = 015: Control Signal Parameters Array id - Clutch ! p8 = 004: Vehicle States Parameters ARRAY id ! p9 = 001: SENSOR Array id ! p10= 001: Reset VARIABLE statement id ! driving_machine_states_array: ARRAY/1, X ! driving_machine_control_signals(output) array: ARRAY/2, Y ! driving_machine_input_array ! (aggregated_feedback and command signals ARRAY/3, U, VARIABLES=801,...... ARRAY/11, , NUMBERS = 1, cns_limits_arr_id, cms_arr_id, fbs_arr_id, 5001
164
Driver Parameters Array - Steering

! SDI: Driver Parameters ARRAY - Steering for - IPG-DRIVER ARRAY/5001, , NUMBERS = 921, 922, 923, 924, 252 ! n1: String id road input filename ! n2: String id driver input filename ! n3: String id knowledge output file suffix ! n4: String id knowledge input file suffix ! n5: ARRAY id Learning parameters
Other Inputs for IPG-Driver

! adams_view_name=driver_road_input_filename STRING/921 , STRING =MDI_track !used to identify the driver file for input parameters ! adams_view_name=driver_driver_input_filename STRING/922 , STRING =mdi_driver_001.din !Output Knowledge Filename ! adams_view_name=driver_knowledge_output_filename STRING/923 , STRING =iso_lanechange_1.kno !Input knowledge file ! adams_view_name=driver_knowledge_input_filename STRING/924 , STRING =iso_lanechange_0.kno ! adams_view_name=driver_learn_parameters ARRAY/252 , IC , SIZE = 5 , NUMBERS = 0, 1, 1, 0, 0.1 ! n1: Remember( 1=yes, 0=no ) ! 1=yes, read a knowledge file as input to this simulation ! 0=no, Do not use knowledge from a past simulation. ! n2: Learn Lateral Dynamics (1=yes,0=no) ! n3: Learn Longitudinal Dynamics (1=yes, 0=no) ! n4: Learn Maximum Speed (1=yes, 0=no) ! n5: Starting time for Driver.
165
Machine Control Specifications for Dataset Elements

GSE/1, NS=10, NO=5, , X = 1, Y= 2, U=3, , XX=USER, XU=USER, YX=USER, YU=USER, , FUNCTION = USER(980,sdi_parameters_array.adams_id)\ ! SDI Parameters Array ARRAY/id, , numbers = 960,011,012,013,014,015,004,001,001\ ! ! Where the user parameters p1...p10 are: ! ! p1 = 980: Branch to Standard Driver Interface (SDI) ! p2 = 960: Branch to ACAR-AT Driving Machine ! p3 = 011: Control Signal Parameters Array id - Steering ! p4 = 012: Control Signal Parameters Array id - Throttle ! p5 = 013: Control Signal Parameters Array id - Brake ! p6 = 014: Control Signal Parameters Array id - Gear ! p7 = 015: Control Signal Parameters Array id - Clutch ! p8 = 004: Vehicle States Parameters ARRAY id ! p9 = 001: SENSOR Array id ! p10= 001: Reset VARIABLE statement id ! driving_machine_states_array: ARRAY/1, X ! driving_machine_control_signals(output) array: ARRAY/2, Y ! driving_machine_input_array ! (aggregated_feedback and command signals ARRAY/3, U, VARIABLES=801,......
Driver Parameters Steering

! Driver parameters array steering ARRAY/id, IC, SIZE = n, , NUMBERS=p1,p2, .... pn ! p1: 0 = steering control by driver-lite ! .....1 = steering control by driver-lite using path-data array ! .....2 and higher reserved for other controller types ! Vehicle initial conditions: ! p2: vehicle mass ! p3: vehicle starting distance < l > relative to ISO-EAS ! p4: id of ARRAY statement containing path data. ! p5: 0 = Steering wheel angle output, 1 = steering wheel torque output
166
Driver Parameters Throttle

! Driver parameters array throttle (speed control) ARRAY/id, IC, , NUMBERS=p1,p2, .... pn ! p1 = 0 : speed control by driver-lite using .dcd file as input ! .....1 : pseudo-open-loop throttle with transmission shifting by driver-lite. ! .....2 : speed control by driver-lite using speed profile array ! .....3 and higher reserved for other controller types ! p2 : vehicle mass < m > ! p3 : starting distance s0 < l > ! p4 : number of gears ! p5 : minimum engine speed < revolutions/minute (rpm) > ! p6 : maximum engine speed < revolutions/minute (rpm) > ! p7 : average tire rolling radius < l > ! p8 : differential ratio (pinion revolutions per ring gear revolution) < nu > ! p9 : id of SPLINE containing the transmission gear ratios ! p10: id of ARRAY statement containing speed profile array.
Generated Paths
Generated paths are created during ADAMS/Solver run-time, rather then being read from a .dcd file. You can use only straight and constant radius curve paths.
Straight-Line Path Data
To define the straight line you want the vehicle to follow, you must enter the starting point of the straight line and a unit vector giving the direction of the line in the ISO-Earth Axis System.
ARRAY/id, , NUMBERS= p1, p2, p3, p4, p5 ! p1 : id of STRING statement for .dcd file for path ! p2 : 0, path type = straight-line
167
Radius Path Data
To define an arc of a given radius you want the vehicle to follow, you must enter the starting point of the path, a vector giving the tangent to the path at the starting point, the length of the tangent (straight) before the radius, the radius, and the turning direction. You must supply the values in model units.
ARRAY/id, , NUMBERS= p1, p2, p3, p4, p5, p6, p7, p8 ! p1 : id of STRING statement for .dcd file for path ! p2 : 1, path type = radius ! p3 : Length of tangent (straight) before radius (sign is ignored) <l> ! p4 : Radius (sign is ignored) <l> ! p5 : turn direction about ISO-EAS Z{+1 = left , -1 = right }
For example, assume you want the vehicle to turn left (counter-clockwise rotation) on an 80m radius after following a straight line for 50m in the +X direction, and you are given the current position of the vehicle as {0,0,0}m in ISO-EAS. Then the path parameters for the radius controller are:
ARRAY/id, , NUMBERS= 21, 1, 50.0, 80.0, 1.0
Generated Speed Profiles

The Driving Machine creates generated speed profiles at run time rather then reading them from a .dcd file. The speed profile is given as a Taylor series expansion in time of the initial speed, acceleration, and jerk. By setting the jerk and acceleration to zero (0), you can create a constant velocity profile. By setting the jerk to zero (0) and entering a non-zero acceleration, you can create a ramped velocity profile. Finally, by entering a non-zero value for jerk, you can create a ramped acceleration profile (quadratic velocity profile).
ARRAY/id, IC, , NUMBERS=p1,p2, .... pn ! p1 : 0, speed profile type = constant speed, acceleration, or jerk ! p2 : v0 - Initial longitudinal speed < l / t > ! p3 : a0 - Initial longitudinal acceleration < l / t2 > ! p4 : j0 - Jerk < l / t3 > ! p5 : T0 - Starting Time ! p6 : T - Duration of speed profile in time < t >.
168
The Driving Machine computes the velocity profile using the following logic:
If ( time < T0 ) then Longitudinal Speed (ds/dt(time)) = v0 If ( time => T0 ) then: Longitudinal Speed (ds/dt(time)) = v0 + a0*(time - T0) + 1/2 * j0 *(time - T0)**2 Path Position (s(time)) = s0(p3 from driver parameters array throttle) + v0*time + 1/2 * a0 *( time -T0)**2 + 1/6 * j0 * (time-T0)**3
Example SDI ADAMS/Solver Dataset Fragment

You can use this fragment for both machine (driver-lite) and human control (driver). As shown it would use human control.
! SDI: IPG-DRIVER GSE/101, NS=3, NO=5, , X = 101, , Y = 102, , U = 103, , STATIC_HOLD, , XX=USER, XU=USER, YX=USER, YU=USER, , FUNCTION = USER( 980, 100 )\ ! ! Where the user parameters p1 and p2 are: ! p1 : 980 Branch to Standard Driver Interface (SDI) ! p2 : ARRAY id for SDI parameters Array ! SDI: States ARRAY ARRAY/101, X ! SDI: Output ARRAY ARRAY/102, Y ! SDI: Input ARRAY ARRAY/103, U, , VARIABLES = , 2, 3, 4, 5, 6, ! Open Loop Command Signals: , 1001,1002,1011,1012,1021,1022,! Body dis, vel, acc , 1006,1016,1026, ! Body Yaw, Yaw rate, Yaw acc , 2036,2006,2016,1026, ! Steering wheel torque, ang, ang vel, ang acc , 24,3002,53 ! Engine Speed, Transmission gear, Time
169
! SDI: Parameters Array - HUMAN CONTROL (IPG-DRIVER) ARRAY/100, , NUMBERS = 900,1001,1002,1003,1004,1005, 0,1001,2001 ! ! Where the parameters p1-p9 are: ! p1 : Branch to Driver Controller ( 900 = human, 960 = machine ) ! p2 : Control Signal ARRAY id - Steering ! p3 : Control Signal ARRAY id - Throttle ! p4 : Control Signal ARRAY id - Brake ! p5 : Control Signal ARRAY id - Gear ! p6 : Control Signal ARRAY id - Clutch ! p7 : Vehicle States Parameter Array id ! p8 : SENSOR Statement id ! P9 : Reset VARIABLE statement id ! SDI: Parameters Array - MACHINE CONTROL (IPG-DRIVER-Lite) !ARRAY/100, !, NUMBERS = 960,1001,1002,1003,1004,1005, 0,1001,2001 ! ! Where the parameters p1-p9 are: ! p1 : Branch to Driver Controller ( 900 = human, 960 = machine ) ! p2 : Control Signal ARRAY id - Steering ! p3 : Control Signal ARRAY id - Throttle ! p4 : Control Signal ARRAY id - Brake ! p5 : Control Signal ARRAY id - Gear ! p6 : Control Signal ARRAY id - Clutch ! p7 : Vehicle States Parameter Array id ! p8 : SENSOR Statement id ! P9 : Reset VARIABLE statement id ! SDI::Reset Variable VARIABLE/2001, FUNCTION = 0.0\ ! SDI::SENSOR ! Traps converged integration steps SENSOR/1001, VALUE = 1.0, ERROR=0.01, HALT , FUNCTION=USER(980)\ ! SDI::FEEDBACK VARIALBES FOR MACHINE/HUMAN CONTROL ! SDI: IPG-Driver Input (feedback) Variables: ! marker/3001 body reference marker X points forward, Z up, Y-left (ISO-VAS) ! marker/4001 road reference marker on ground, X points forward, Z up, Y-Left ! marker/699 steering wheel joint i-marker ! marker/578 steering wheel joint j-marker
170
! ! Displacement-X VARIABLE/1001 , FUNCTION = DX(3001,4001,4001)\ ! ! Displacement-Y VARIABLE/1002 , FUNCTION = DY(3001,4001,4001)\ ! ! Velocity-X VARIABLE/1011 , FUNCTION = VX(3001,4001,4001)\ ! ! Velocity-Y VARIABLE/1012 , FUNCTION = VY(3001,4001,4001)\ ! VARIABLE/1021 , FUNCTION = ACCX(3001,4001,4001)\ ! VARIABLE/1022 , FUNCTION = ACCY(3001,4001,4001)\ ! ! adams_view_name=body_yaw_angle VARIABLE/1006 !, FUNCTION = -YAW(3001,4001)\ , FUNCTION = AZ(3001,4001)\ ! adams_view_name=body_yaw_rate VARIABLE/1016 , FUNCTION = WZ(3001,4001,4001)\ ! ! adams_view_name=body_yaw_acce VARIABLE/1026 , FUNCTION = WDTZ(3001,4001,4001)\ ! ! Steering Wheel Torque VARIABLE/2036 , FUNCTION = TZ( 699,578,578 )\ ! Steering wheel angle ! adams_view_name=steering_wheel_angle VARIABLE/2006 , FUNCTION = AZ( 699,578)\
171
! Steering wheel velocity } VARIABLE/2016 , FUNCTION = WZ( 699,578,578)\ ! Steering wheel acceleration VARIABLE/2026 , FUNCTION = WDTZ( 699,578,578 )\ ! Engine Speed ! See VARIABLE/24 ! Transmission Gear VARIABLE/3002 , IC = 2 , FUNCTION = ARYVAL(102,4)\ ! SDI::CONTROL SIGNAL PARAMETERS ARRAYS: ! SDI: Control Signal Array - Steering: ARRAY/1001, , NUMBERS=1, 2001, 3001, 4001, 5001 ! ! Where the user parameters p1...p5 are: ! n1 : Control Flag (0 = open loop, 1 = close loop) ! n2 : Control Signal Limits Array id ! n3 : Command Signal Variables Array id ! n4 : Feedback Signal Variables Array id ! n5 : Driver Controller Parameters Array id ! SDI: Control Signal Array - Throttle: ARRAY/1002, , NUMBERS=1, 2002, 3002, 4002, 5002 ! ! Where the user parameters p1...p5 are: ! n1 : Control Flag (0 = open loop, 1 = close loop) ! n2 : Control Signal Limits Array id ! n3 : Command Signal Variables Array id ! n4 : Feedback Signal Variables Array id ! n5 : Driver Controller Parameters Array id
172
! SDI: Control Signal Array - Brake: ARRAY/1003, , NUMBERS=1, 2003, 3003, 0, 0 ! ! Where the user parameters p1...p5 are: ! n1 : Control Flag (0 = open loop, 1 = close loop) ! n2 : Control Signal Limits Array id ! n3 : Command Signal Variables Array id ! n4 : Feedback Signal Variables Array id ! n5 : Driver Controller Parameters Array id ! SDI: Control Signal Array - Gear: } ARRAY/1004, , NUMBERS=1, 2004, 3004, 0, 0 ! ! Where the user parameters p1...p5 are: ! n1 : Control Flag (0 = open loop, 1 = close loop) ! n2 : Control Signal Limits Array id ! n3 : Command Signal Variables Array id ! n4 : Feedback Signal Variables Array id ! n5 : Driver Controller Parameters Array id ! SDI: Control Signal Array - Clutch: ARRAY/1005, , NUMBERS=1, 2005, 3005, 0, 0 ! ! Where the user parameters p1...p5 are: ! n1 : Control Flag (0 = open loop, 1 = close loop) ! n2 : Control Signal Limits Array id ! n3 : Command Signal Variables Array id ! n4 : Feedback Signal Variables Array id ! n5 : Driver Controller Parameters Array id ! SDI::CONTROL SIGNAL LIMITS ARRAYS: ! SDI: Control Signal Limits Array - Steering ARRAY/2001, , NUMBERS= 1, 0, 0, -720D, 720D ! n1: Control Signal Application ! (1=steering,2=throttle,3=brake,4=gear,5=clutch) ! n2: Signal_Mode ( 0 = Absolute, 1 = Relative ) ! n3: Initial Value ! n4: Minimum Signal Value ! n5: Maximum Signal Value
173
! SDI: Control Signal Limits Array - Throttle ARRAY/2002, , NUMBERS= 2, 0, 0.22, 0, 1 !, NUMBERS= 2, 0, 22, 0, 100 ! n1: Control Signal Application ! (1=steering,2=throttle,3=brake,4=gear,5=clutch) ! n2: Signal_Mode ( 0 = Absolute, 1 = Relative ) ! n3: Initial Value ! n4: Minimum Signal Value ! n5: Maximum Signal Value ! SDI: Control Signal Limits Array - Brake ARRAY/2003, , NUMBERS= 3, 0, 0, 0, 500 ! n1: Control Signal Application ! (1=steering,2=throttle,3=brake,4=gear,5=clutch) ! n2: Signal_Mode ( 0 = Absolute, 1 = Relative ) ! n3: Initial Value ! n4: Minimum Signal Value ! n5: Maximum Signal Value ! SDI: Control Signal Limits Array - Gear ARRAY/2004, , NUMBERS= 4, 0, 2, -1, 6 ! n1: Control Signal Application ! (1=steering,2=throttle,3=brake,4=gear,5=clutch) ! n2: Signal_Mode ( 0 = Absolute, 1 = Relative ) ! n3: Initial Value ! n4: Minimum Signal Value ! n5: Maximum Signal Value ! SDI: Control Signal Limits Array - Clutch ARRAY/2005, , NUMBERS= 5, 0, 0, 0, 1 ! n1: Control Signal Application ! (1=steering,2=throttle,3=brake,4=gear,5=clutch) ! n2: Signal_Mode ( 0 = Absolute, 1 = Relative ) ! n3: Initial Value ! n4: Minimum Signal Value ! n5: Maximum Signal Value ! SDI::COMMAND SIGNAL ARRAYS ! SDI: COMMAND SIGNAL ARRAYS - First variable is old driver demand ARRAY/3001, NUM=2 ! Steering ARRAY/3002, NUM=3 ! Throttle ARRAY/3003, NUM=4 ! Brake ARRAY/3004, NUM=5 ! Gear ARRAY/3005, NUM=6 ! Clutch
174
! SDI::FEEDBACK SIGNAL ARRAYS ! adams_view_name=feedback_signals_array_steering ARRAY/4001, , NUMBERS = , 1001,1002, ! Body X-dis,Y-dis , 1011,1012, ! Body X-vel,y-vel , 1021,1022, ! Body X-Acc, Y-Acc , 1006,1016,1026, ! Body Yaw, Yaw rate, Yaw acce. , 2036,2006,2016,1026 ! Steering wheel torque, ang, ang vel, ang acc ! adams_view_name=feedback_signals_array_throttle ARRAY/4002, IC, , NUMBERS = , 24,3002, ! Engine Speed, Transmission gear , 1011,1012, ! Body X-Vel, Y-Vel , 1021,1022, ! Body X-Acc, Y-Acc , 1006 ! Body Yaw angle ! No feedback for brake, gear, and clutch !ARRAY/4003 !ARRAY/4004 !ARRAY/4005 ! SDI::DRIVER PARAMETERS ARRAYS ! SDI: Driver Parameters ARRAY Steering - HUMAN CONTROL (IPG-DRIVER) ARRAY/5001, , NUMBERS = 921, 922, 923, 924, 252 ! n1 : String id road input filename ! n2 : String id driver input filename ! n3 : String id knowledge output file suffix ! n4 : String id knowledge input file suffix ! n5 : ARRAY id Learning parameters ! SDI: Driver parameters array steering - MACHINE CONTROL (IPG-DRIVER-LITE) !ARRAY/5001, !, NUMBERS= 0, 1500.0, 0.0, 0, 6001, 0 ! p1 : 0 = steering control by driver-lite ! .....1 and higher reserved for other controller types ! Vehicle initial conditions: ! p2 : vehicle mass ! p3 : vehicle starting distance < l > relative to ISO-EAS ! p4 : id of .dcd Path Data Array ! p5 : -1 ( use .dcd file) -or- id of generated path array (.dcd file ignored). ! p6 : 0 = Steering wheel angle output, 1= steering wheel torque output ! Driver parameters array throttle (speed control)
175
ARRAY/5002 , NUMBERS= 0, 1500.0, 0.0, 6, 2000, 6500, 340., 4.11, 3, 0, 6002 ! p1 = 0 : speed control by driver-lite using .dcd file as input ! .....1 : pseudo-open-loop throttle with transmission shifting by driver-lite. ! .....2 and higher reserved for other controller types ! p2 : vehicle mass < m > ! p3 : starting distance s0 < l > ! p4 : number of gears ! p5 : minimum engine speed < revolutions/minute (rpm) > ! p6 : maximum engine speed < revolutions/minute (rpm) > ! p7 : average tire rolling radius < l > ! p8 : differential ratio (pinion revolutions per ring gear revolution) < nu > ! p9 : id of SPLINE containing the transmission gear ratios ! p10: id of .dcd file speed profile array ! p11: -1 (use .dcd file) -or- id of generated speed profile array (.dcd file ignored). ! adams_view_name=path_array_steering ARRAY/6001, IC, , NUMBERS= 0, 301.15, -0.015021, 1.0, 0.0, 100000, 1 !, NUMBERS= -1200,0.0,1.0,0.0 ! p1 : 0 = straight, 1 = skid pad (radius) ! p1 : X coordinate start location in ISO-EAS <l> ! p2 : Y coordinate start location in ISO-EAS <l> ! p3 : X component of tangent vector in ISO-EAS <nu> ! p4 : Y component of tangent vector in ISO-EAS <nu> ! adams_view_name=speed_profile_array_throttle ARRAY/6002, IC, , NUMBERS = 0, 2.77778e4, 0, 0 ! p1 : 0 = ! p2 : velocity coefficient <l/t> ! p3 : acceleration coefficient <l/t/t> ! p4 : jerk coefficient <l/t/t/t> ! ! vt(T) = p1*T + 1/2*p2*T**2 + 1/6*p3*T**3 ! No Driver parameters array for brake, gear and clutch. !ARRAY/5003 !ARRAY/5004 !ARRAY/5005
176
! SDI::OTHER HUMAN CONTROL INPUTS: ! adams_view_name=driver_learn_parameters ARRAY/252 , IC , SIZE = 5 , NUMBERS = 0, 1, 1, 0, 0.1 ! n1: Remember( 1=yes, 0=no ) ! 1=yes, read a knowledge file as input to this simulation ! 0=no, Do not use knowledge from a past simulation. ! n2: Learn Lateral Dynamics (1=yes,0=no) ! n3: Learn Longitudinal Dynamics (1=yes, 0=no) ! n4: Learn Maximum Speed (1=yes, 0=no) ! n5: Starting time for Driver. ! ! adams_view_name=driver_road_input_filename
STRING/921 , STRING =MDI_track ! !used to identify the driver file for input parameters ! adams_view_name=driver_driver_input_filename STRING/922 , STRING =mdi_driver_001.din ! !used by adams driver to identify learning result ! adams_view_name=driver_knowledge_output_filename STRING/923 , STRING =iso_lanechange_1.kno ! !used by adams driver to identify knowledge file ! adams_view_name=driver_knowledge_input_filename STRING/924 , STRING =iso_lanechange_0.kno
177
Feedback Signals - Machine/Human Control

The following feedback signals are common to both machine and human control:
s s
Feedback Signals Steering, 177 Feedback Signals Throttle, 177
Feedback Signals Steering

ARRAY/id, IC, , NUMBERS=id1,id2, .... id12, id13 ! id1 : Vehicle X position in ISO-EAS <l> ! id2 : Vehicle Y position in ISO-EAS <l> ! id3 : Vehicle X velocity in ISO-EAS <l/t> ! id4 : Vehicle Y velocity in ISO-EAS <l/t> ! id5 : Vehicle X acceleration in ISO-EAS < l/t/t > ! id6 : Vehicle Y acceleration in ISO-EAS < l/t/t > ! id7 : Vehicle yaw angle in ISO-EAS < r > ! id8 : Vehicle yaw velocity in ISO-EAS < r/t > ! id9 : Vehicle yaw acceleration in ISO-EAS < r/t/t> ! id10: Steering wheel torque < f*l > ! id11: Steering wheel angle < r > + Left Turn (Counter Clock Wise rotation). ! id12: Steering wheel angular velocity < r/t > + Left Turn (Counter Clock Wise rotation). ! id13: Steering wheel angular acceleration < r/t/t >
Feedback Signals Throttle

ARRAY/id, IC, , NUMBERS=id1,id2, .... id7 ! id1 : Engine speed < r/t > ! id2 : Transmission gear < nu > ! id3 : Vehicle X velocity in ISO-EAS <l/t> ! id4 : Vehicle Y velocity in ISO-EAS <l/t> ! id5 : Vehicle X acceleration in ISO-EAS < l/t/t > ! id6 : Vehicle Y acceleration in ISO-EAS < l/t/t > ! id7 : Vehicle yaw angle in ISO-EAS < r >
178
Examples of Dataset Elements

The following sections provide examples of the dataset elements used in the implementation of the Driving Machine in the .adm file:
s
General State Equations (GSE) Statement and Associated ARRAY Statements, 179 Control Signal ARRAY Statements, 180 Control Signal Limits ARRAY, 181 SENSOR Statement, 182 Command Signal Variables Array, 182 Feedback Signal Variable Arrays, 184 Driver Controller Parameter Arrays, 185
s s s s s s
179
General State Equations (GSE) Statement and Associated ARRAY Statements

GSE/id, NS=1, NO=5, , X = id, , Y = id, , U = id, , XX=USER, XU=USER, YX=USER, YU=USER, , FUNCTION = USER(p1,p2,p3,p4,.....p10)\ ! ! Where the user parameters p1...p11 are: ! ! p1 : 980 Branch to Standard Driver Interface (SDI) ! p2 : Driver Controller Branch ! p3 : Control Signal ARRAY id - Steering ! p4 : Control Signal ARRAY id - Throttle ! p5 : Control Signal ARRAY id - Brake ! p6 : Control Signal ARRAY id - Gear ! p7 : Control Signal ARRAY id - Clutch ! p8 : Vehicle States Parameter Array id ! p9 : SENSOR Statement id ! p10: Reset VARIABLE statement id ARRAY/id, X ARRAY/id, Y ARRAY/id, U, VARIABLES=id1,id2,id3,.....idn
180
Control Signal ARRAY Statements

The control signal array communicates information to the Driving Machine about how a control signal should be calculated and which VARIABLES in the input (U) ARRAY are used as command and feedback signals. You must supply a control signal ARRAY for each of the actuator application areas, that is, steering, throttle, brake, gear, and clutch.
ARRAY/id, , NUMBERS=p1,p2,p3,p4,p5 ! ! Where the user parameters p1...p5 are: ! p1 : Control Flag (0 = open loop, 1 = close loop) ! p2 : Control Signal Limits Array id ! p3 : Command Signal Variables Array id ! p4 : Feedback Signal Variables Array id ! p5 : Driver Controller Parameters Array id Control_Flag ( 0 = open loop, 1 = close loop )
If you select open-loop control (p1 = 0), the Driving Machine calculates the control signal directly and ignores the value your SDIxxx subroutine returns. The Driving Machine calculates the open-loop control signal using the first command signal variable from the command signal array and the values from the corresponding control signal limits ARRAY. Please note the following:
s
The command signal, feedback signal, and driver controller arrays are optional. Setting the respective ID to zero (0) in the parameter list causes the Driving Machine to ignore the input. For example, if all the feedback your driver controller needs is supplied in vehicle states (VST) in the Driving Machine, then you dont need to supply your own feedback variables. Therefore, you can set the feedback variables array ID to zero (0) in all control signal ARRAYs. You must reference any VARIABLE statements that are referenced in the command signal or feedback signal ARRAYs in the GSEs input (U) ARRAY. Different control signal ARRAYs can reference the same control signal array, command signal array, feedback signal array, or driver controller parameters array.
181
For open-loop control (p1 = 0: Control Flag), you must supply a command signal ARRAY ID. When the command signal array lists more than one VARIABLE statement ID, the Driving Machine uses the first VARIABLE as the open-loop control signal.
Control Signal Limits ARRAY

Using the control signal limits array, you can specify minimum and maximum values for the control signal, and whether the control signal is relative to an initial value or absolute. The Driving Machine applies the limits to the control signal, so you dont need to do so in your SDIxxx subroutine.
ARRAY/1020, , NUMBERS= p1, p2, p3, p4, p5 ! p1: Control Signal Application (1=steering, 2=throttle, 3=brake, 4=gear, 5=clutch) ! p2: Signal_Mode ( 0=Absolute, 1=Relative ) ! p3: Initial Value ( Ignored when Signal_Mode=absolute ) ! p4: Minimum Signal Value ! p5: Maximum Signal Value
Please note the following:

s
SDI passes the control signal parameters to your driver controller subroutine for information purposes only. SDI reads and applies the parameters for each control signal. If the minimum signal value is equal to or greater than the maximum signal value, then the control signal is not limited.
182
SENSOR Statement
The sensor statement monitors the simulation and fixes the time of the last converged integration step.
SENSOR/id, VALUE=1.0, ERROR=0.01, HALT , FUNCTION = USER(p1,p2)\ ! ! Where the user parameters are: ! ! p1 : 980 Branch to Standard Driver Interface (SDI) ! p2 : Driver Controller GSE statement id.

s
There must be one and only one SENSOR statement for each driver controller. This SENSOR should never trigger. If it triggers, check its arguments, VALUE and ERROR, to make sure they are set according to specifications.
Command Signal Variables Array

For open-loop control of a given control signal like steering, SDI requires a command signal variable array that holds the ID of at least one VARIABLE statement that gives the open-loop input. For closed-loop control of a given area, such as steering or braking, the command signal variables arrays provide an optional means for inputting command signals to your Driving Machine-compatible driver controller. The form of a command signal variable array is:
ARRAY/id, , VARIABLES = id1, id2, .....idn
183

s
Any variables referenced by a command signal variables ARRAY must also be listed in the driver controller GSEs input (U) ARRAY statement. For closed-loop control of a signal, such as braking, the command signal variable array is optional. Setting the respective ID to 0 in the control signal VARIABLE parameter list causes the Driving Machine to ignore the input. Different control signal VARIABLE statements can reference the same command signal variables array. For open-loop control signal VARIABLEs, you must supply a command signal ARRAY ID. When the command signal variable array lists more than one VARIABLE statement ID, the Driving Machine uses the first VARIABLE as the open-loop control signal. The Driving Machine passes the current values of all command signal variables to your driver controller subroutine in the CMS array.
184
Feedback Signal Variable Arrays

The feedback signals variable arrays provide a means for inputting feedback signals from the dataset to your Driving Machine-compatible driver controller subroutine. Feedback signal variable arrays hold the IDs of VARIABLE statements you supply:
ARRAY/id, , VARIABLES = id1, id2, .....idn

s
Any variables referenced by a feedback signal variables ARRAY must also be listed in the driver controller GSEs input (U) ARRAY statement. Feedback signal variable arrays are optional. Setting the respective ID to 0 in the control signal VARIABLE parameter list causes the Driving Machine to ignore the input. Different control signal VARIABLE statements can reference the same feedback signal variables array. The Driving Machine passes the current values of all feedback signal variables to your driver controller subroutine in the FBS array.
185
Driver Controller Parameter Arrays

The driver controller parameter arrays provide a means for transferring information from the dataset to your Driving Machine-compatible driver controller subroutine. You define the meaning of each parameter. The form of the ARRAY statement is:
ARRAY/id, , NUMBERS= p1, p2, ..... pn

s
Driver controller parameter arrays are optional. You dont need to supply driver controller parameter arrays if your Driving Machine-compatible driver controller will not use them. In this case, set the driver parameter array ID to 0 in the control signal VARIABLE function parameters list. Two or more control signal VARIABLEs can reference the same driver controller parameter ARRAY. You can use one driver controller ARRAY statement for each control signal VARIABLE statement. The Driving Machine passes the driver controller parameters to your driver controller subroutine in the driver parameters array (DPR).
186
Subroutine (SDISUB) Parameters

The subroutine (SDISUB) parameters interpret dataset elements and control analyses based on that interpretation. The Driving Machine calls subroutine SDISUB to branch to various driver controller subroutines. The current MDI routines are SDI900 for human control and SDI960 for machine control. Open-loop control is handled outside of the SDISUB.
CALL SDISUB( id, BRANCH, JOBFLG, ANAFLG, & LCONV, FCONV, TCONV, & N_CNS, CNSFLG, CNS_MODE, CNS_LIM, CNS_ICS, & N_VST, VST, & AEAS, AIAS, AVAS, & MAX_SIG & N_CMS, CMS, & N_FBS, FBS, & N_STS, STS, & N_DPR, DPR, & CNS, dSTS, & N_DRV, DRVINF, DRVMSG, DRVERR ) c c----v-----------------------------------------------------------------I c----v-----------------------------------------------------------------I c DRIVER CONTROLLER id c INTEGER id c An integer identifying the Driver Controller (also the GSE statement id.) c c c BRANCH FLAG c INTEGER BRANCH c c An integer identifying the driver controller. c c JOB CONTROL FLAG c INTEGER JOBFLG c c The integer JOBFLG communicates the simulation status to the driver model.
187
c c 0 = Normal Mode c 1 = Inquiry - your SDISUB must return the number of states to be integrated for each c control signal. c 2 = First Initialization c 3 = Re-Initialization (new model) c 4 = Successful Simulation Step c 5 = Differencing mode c 6 = End Simulation c c ANALYSIS FLAG c INTEGER ANAFLG(2) c c The integer ANAFLG communicates the kind of analysis being performed. ANAFLG c is meaningful only when JOBFLG is 0, 4, or 5. c c ANAFLG(1) gives the ADAMS/Solver analysis mode: c c 1 = Kinematics c 2 = Reserved c 3 = Initial conditions c 4 = Dynamics c 5 = Statics c 6 = Quasi-statics c 7 = Linear analysis c c ANAFLG(2) Gives the ADAMS/Car analysis modes. Modes 1 through 4 are c performed during ADAMS/Solver static or quasi-static analysis. c (ANAFLG(1) = 5 or 6): c c 1 = Car:Mechanical-Adjustment c 2 = Car:Mass-Distribution-Adjustment c 3 = Car:Aero-Force Loading c 4 = Car:Inertial-Force Loading c 5 = Car:Dynamic Analysis c c----v-----------------------------------------------------------------I c UNIT CONVERSION FACTORS c c SDI provides a set of unit conversion factors as a matter of convenience for c driver controllers. The factors convert length, force, and time from model units to SI c (Newtons, Meters, Kilograms, Seconds). c
188
DOUBLE PRECISION LCONV DOUBLE PRECISION FCONV DOUBLE PRECISION TCONV c c LCONV - Length Conversion Factor. c c FCONV - Force Conversion Factor. c c TCONV - Time Conversion Factor. c c To convert velocity in model units to SI units (meters/second): c c velo_si = velo_model_units*LCONV/TCONV c c----v-----------------------------------------------------------------I c CONTROL SIGNALS INPUT INFORMATION c c SDI provides a set of information about the control signals to the driver controller. c INTEGER N_CNS c c Number of control signals. The number of control signals is five, but may be c increased in the future. c INTEGER CNSFLG(N_CNS) c c Control Signal Flag - identifies whether the ith control signal returned to SDI c interface is ignored (CNSFLG(i)=0), or used (CNSFLG(i)=1) by SDI. c c For example, if the vehicle employs an automatic transmission, then the clutch will c be ignored by SDI and CNSFLG(5) = 0. Another example, if you select open-loop c steering control, then SDI sets CNSFLG(1) = 0, and ignores any values returned by c the driver controller for steering in CNS(1). c c INTEGER CNS_MODE(N_CNS) c c For each control signal the output is interpreted by SDI as either: c c a) Relative (CNS_MODES(i) = 1) to the corresponding initial condition. In which c case SDI adds the initial condition to the control signal returned by the Driver
189
c Subroutine before outputting the signal to the dataset: c c CNSdataset(i) = CNS(i) + CNS_ICS(i). c c b) Absolute (CNS_MODES(i) = 0). In which case SDI passes the control signal c returned by the Driver Subroutine directly to the dataset. c DOUBLE PRECISION CNS_LIM( 2, N_CNS ) c c SDI limits the control signals between maximum and minimum values as input by c the user in the control signal parameters array. The limits are provided here for c information only. The driver controller need not enforce these limits, because c SDI does. c c CNS_LIM(1,i) minimum value for the ith control signal c CNS_LIM(2,i) maximum value for the ith control signal c c SDI does not apply the limits if: c CNS_LIM(2,i) - CNS_LIM(1,i) < Tolerance c c DOUBLE PRECISION CNS_ICS(N_CNS) c c Control Signal initial conditions. CNS_ICS(i) is the initial value of the ith control c signal at the start of a simulation. SDI ignores CNS_ICS(i) if CNS_MODE(i) = 0 c c c----v-----------------------------------------------------------------I c VEHICLE STATE DATA: c DOUBLE PRECISION VST(3,N_VST) c c Simulation Time: VST(*,1) c c VST(1, 1) = Current Simulation Time c VST(2, 1) = Time of last converged integration step (for example, last time c jobflg .eq. 4) c VST(3, 1) = Time of last output step (not yet supported) c c Translational displacement <m>: VST(*,2) c
190
c VST(1, 2) = X location c VST(2, 2) = Y location c VST(3, 2) = Z location c c SDI reports the translational and rotational velocities and accelerations of the c vehicle sprung mass in the ISO-Intermediate Axis System (IAS) (See Sections 1and c 2 of ISO 8855). Units are meters, seconds, and radians. c c Translational velocity <m/s>: VST(*,3) c c VST(1, 3) = longitudinal (Vx) velocity c VST(2, 3) = lateral (Vy) velocity c VST(3, 3) = vertical (Vz) velocity c c Translational acceleration <m/s^2>: VST(*,4) c c VST(1, 4) = longitudinal (Ax) acceleration c VST(2, 4) = lateral (Ay) acceleration c VST(3, 4) = vertical (Az) acceleration c c Rot. displacement <rad>: VST(*,5) c c VST(1, 5) = Yaw Angle (per ISO 8855) c VST(2, 5) = Pitch Angle (per ISO 8855) c VST(3, 5) = Roll Angle (per ISO 8855) c c Rot. velocity <rad/s>: VST(*,6) c c VST(1, 6) = Wx Angular Velocity about ISO-IAS X Axis c VST(2, 6) = Wy Angular Velocity about ISO-IAS Y Axis c VST(3, 6) = Wz Angular Velocity about ISO-IAS Z Axis c c Rot. Accel. <rad/s^2>: VST(*,7) c c VST(1, 7) = dWx/dt Angular Acceleration about ISO-IAS X Axis c VST(2, 7) = dWy/dt Angular Acceleration about ISO-IAS Y Axis c VST(3, 7) = dWz/dt Angular Acceleration about ISO-IAS Z Axis c c Engine Rot. speed <rad/s>: VST(*,8) c c VST(1, 8) = Engine Rotational Speed c VST(2, 8) = unused c VST(3, 8) = unused c c Left Front Tire: VST(*,9) c
191
c VST(1, 9) = longitudinal slip c VST(2, 9) = lateral slip c VST(3, 9) = Rotational Speed <rad/s> c c Right Front Tire: VST(*,10) c c VST(1,10) = longitudinal slip c VST(2,10) = lateral slip c VST(3,10) = Rotational Speed <rad/s> c c Left Rear Tire: VST(*,11) c c VST(1,11) = longitudinal slip c VST(2,11) = lateral slip c VST(3,11) = Rotational Speed <rad/s> c c Right Rear Tire: VST(*,12) c c VST(1,12) = longitudinal slip c VST(2,12) = lateral slip c VST(3,12) = Rotational Speed <rad/s> c c c----v-----------------------------------------------------------------I c AXIS SYSTEM INFORMATION: c DOUBLE PRECISION AEAS(3,4) DOUBLE PRECISION AIAS(3,4) DOUBLE PRECISION AVAS(3,4) c c AEAS Transformation from ISO-Earth Axis System to A/Solver ground. c c AEAS(*,1) ISO-EAS X axis expressed in A/Solver ground axis system c AEAS(*,2) ISO-EAS Y axis expressed in A/Solver ground axis system c AEAS(*,3) ISO-EAS Z axis expressed in A/Solver ground axis system c AEAS(*,4) Displacement to ISO-IAS from A/Solver ground expressed in A/Solver c ground axis system. c c AIAS Transformation from ISO-Intermediate Axis System to ISO-Earth Axis System. c c AIAS(*,1) ISO-IAS X axis expressed in ISO-EAS axis system c AIAS(*,2) ISO-IAS Y axis expressed in ISO-EAS axis system c AIAS(*,3) ISO-IAS Z axis expressed in ISO-EAS axis system c AIAS(*,4) Displacement to ISO-IAS from ISO-EAS expressed in ISO-EAS axis
192
c system c c AVAS Transformation from ISO-Vehicle Axis System to ISO-Earth Axis System. c c AVAS(*,1) ISO-VAS X axis expressed in ISO-EAS axis system c AVAS(*,2) ISO-VAS Y axis expressed in ISO-EAS axis system c AVAS(*,3) ISO-VAS Z axis expressed in ISO-EAS axis system c AVAS(*,4) Displacement to ISO-VAS from ISO-EAS expressed in ISO-EAS axis c system c c c----v-----------------------------------------------------------------I c COMMAND SIGNALS c c For each control signal there may be a set of command signals. c The number of command signals for each control signal is stored in the array c N_CMS. For example, the number of command signals for the steering control c signal is N_CMS(1), for traction N_CMS(2), etc. The actual command signals are c stored in the array CMS. c INTEGER N_CMS(N_CNS) DOUBLE PRECISION CMS(MAX_SIG,N_CNS) c c c----v-----------------------------------------------------------------I c FEEDBACK SIGNALS c c For each control signal there may be a set of associated feedback signals. The c number of feedback signals for each control signal is stored in the array N_FBS. For c example, the number of feedback signals for the steering control signal is N_FBS(1), c for traction N_FBS(2), etc. The actual feedback signals are stored in the array FBS. c INTEGER N_FBS(N_CNS) DOUBLE PRECISION FBS(MAX_SIG,N_CNS) c c c----v-----------------------------------------------------------------I c CONTROLLER STATES c c For each control signal there may be a set of associated controller states. Your c SDISUB computes the derivatives of these states (see dSTS) and returns them to c ADAMS/Solver. ADAMS/Solver integrates the derivatives and returns the states c (STS) for your use. For example, you might with to compute an integral error for
193
c the controller. c c To setup for integrating controller states ADAMS/Solver calls your SDISUB with c jobflg = 2 to inquire about how many states you need integrated. You return the c integer array n_STS with the number of states for each control signal and you return c the initial conditions for each state in the STS array. In a steering controller, for c example, you may wish to integrate yaw rate to get total yaw angle. So you set c N_STS(1) = 1, and return the initial yaw angle in STS(1). c INTEGER N_STS(N_CNS) DOUBLE PRECISION STS(MAX_SIG,N_CNS) c c c----v-----------------------------------------------------------------I c DRIVER PARAMETERS: c c For each control signal there may be a set of driver parameters. These may be used c to select between different kinds of controllers for various control signals and as c means to transfer parameters from the ADAMS dataset to SDI. The meaning of c these parameters is determined by the programmer. c c The number of driver parameters for each control signal is stored in the integer array c N_DPR. For example, the number of driver parameters for the steering control c signal is the value of N_DPR(1), for traction the value of N_DPR(2), etc. The driver c parameters are stored in the array DPR. c INTEGER N_DPR(N_CNS) DOUBLE PRECISION DPR(MAX_SIG,N_CNS) c c c----v-----------------------------------------------------------------I c OUTPUTS: c----v-----------------------------------------------------------------I c CONTROL SIGNALS: c DOUBLE PRECISION CNS(N_CNS) c c CNS(1) = Control Signal: Steering c CNS(2) = Control Signal: Traction c CNS(3) = Control Signal: Braking c CNS(4) = Control Signal: Gear c CNS(5) = Control Signal: Clutch
194
c c----v-----------------------------------------------------------------I c DERIVATIVES CONTROLLER STATES: c c For each controller state you must return the derivative with respect to time of the c state for A/Solver to integrate. DOUBLE PRECISION dSTS(MAX_SIG,N_CNS) c c DRIVER MODEL OUTPUT INFORMATION: c c Outputs information about the driver model such as the current preview distance, c and so on. c INTEGER N_DRV DOUBLE PRECISION DRVINF(N_DRV) c c ERROR STATUS: c c Message giving status of driver model c CHARACTER*256 DRVMSG c c Integer error code c INTEGER DRVERR c c DRVERR = 0; Normal execution c DRVERR = 1; Warning c DRVERR = 2; Error-Nonfatal: Ignore results c DRVERR = 3; Error-Fatal: Stop simulation c
Example Driver Control Files
Overview
The following example files show the new driver control file functionality and syntax. You can use .dcf files to reference .dcd files for machine-controlled events and for data-driven open-loop events, giving the simulation scripting language much more functionality. This chapter includes the following example files:
s s s s s s
Braking in a Turn, 196 Free Control Test, 199 Data-Driven Test, 203 Step Steer Test, 206 ISO Lane Change, 208 Lap Driving, 211
196
Running Analyses in ADAMS/Car Example Driver Control Files
Braking in a Turn
This file uses machine control to drive the vehicle clockwise around a 80 m radius skid pad, at 7.0 m/s/s lateral acceleration. Then, while holding the steering wheel fixed, brake with a constant line pressure.
$----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME FILE_TYPE = braking_in_turn.dcf = dcf
FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCF file of braking in a turn simulation $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH = meters FORCE = newton ANGLE MASS TIME = rad = kg = sec
$----------------------------------------------------------------------------------EXPERIMENT [EXPERIMENT] EXPERIMENT_NAME = Braking in a Turn: {mini_manuever INITIAL_SET BRAKE_TURN pri_end TIME TIME pri_value 10.0 5.0 abort_time 10.0 5.0 step_size} 0.05 0.02
197
$----------------------------------------------------------------------------------INITIAL_SET [INITIAL_SET] (STEERING) ACTUATOR_TYPE = ROTATION METHOD (THROTTLE) METHOD (BRAKING) METHOD (GEAR) METHOD MODE = OPEN = ABSOLUTE = MACHINE = MACHINE = MACHINE
CONTROL_TYPE = CONSTANT CONTROL_VALUE = 3 (CLUTCH) METHOD MODE = OPEN = ABSOLUTE
CONTROL_TYPE = CONSTANT CONTROL_VALUE = 0 (MACHINE_CONTROL) STEERING_CONTROL RADIUS TURN_DIRECTION SPEED_CONTROL LAT_ACCEL_TARGET = SKIDPAD = 80 = LEFT = LAT_ACCEL = 7.0
TURN_ENTRY_DISTANCE= 50
198
$----------------------------------------------------------------------------------BRAKE_TURN [BRAKE_TURN] (STEERING) ACTUATOR_TYPE = ROTATION METHOD MODE CONTROL_TYPE (THROTTLE) METHOD MODE CONTROL_TYPE (BRAKING) METHOD MODE CONTROL_TYPE START_TIME INITIAL_VALUE FINAL_VALUE DURATION (GEAR) METHOD MODE CONTROL_TYPE (CLUTCH) METHOD MODE CONTROL_TYPE = OPEN = ABSOLUTE = CONSTANT = OPEN = ABSOLUTE = CONSTANT = OPEN = ABSOLUTE = STEP = 0.0 = 0.0 = 2.0E+07 = 0.5 = OPEN = ABSOLUTE = CONSTANT = OPEN = RELATIVE = CONSTANT
CONTROL_VALUE = 0
CONTROL_VALUE = 0
CONTROL_VALUE = 3
CONTROL_VALUE = 0
199
Free Control Test

This file instructs the Driving Machine to drive the vehicle straight, to input an impulse to the steering wheel, and then to immediately release the steering wheel (zero torque) and show the response of the vehicle.
$----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME FILE_TYPE = free_control.dcf = dcf
FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCF file of free-control simulation $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH FORCE ANGLE MASS TIME [EXPERIMENT] INITIAL_SPEED = 33.3 EXPERIMENT_NAME = Free Control Experiment: Test GPAS R101a {mini_manuever STRAIGHT_LINE FREE_CONTROL pri_end TIME TIME pri_value 2.0 0.15 5.0 abort_time 10.0 0.15 5.0 step_size} 0.05 0.05 0.02 = meters = newton = deg = kg = sec
$----------------------------------------------------------------------------------EXPERIMENT
IMPULSE_STEER TIME
200
$----------------------------------------------------------------------------------STRAIGHT_LINE [STRAIGHT_LINE] (STEERING) ACTUATOR_TYPE METHOD (THROTTLE) METHOD (BRAKING) METHOD (GEAR) METHOD MODE CONTROL_TYPE CONTROL_VALUE (CLUTCH) METHOD MODE CONTROL_TYPE CONTROL_VALUE (MACHINE_CONTROL) STEERING_CONTROL= STRAIGHT SPEED_CONTROL VELOCITY ACCELERATION JERK = VEL_POLYNOMIAL = 33.3 = 0 = 0 = OPEN = ABSOLUTE = CONSTANT = 0 = OPEN = ABSOLUTE = CONSTANT = 5 = MACHINE = MACHINE = ROTATION = MACHINE
201
$----------------------------------------------------------------------------------SINE_STEER [IMPULSE_STEER] (STEERING) ACTUATOR_TYPE = ROTATION METHOD MODE CONTROL_TYPE START_TIME DURATION (THROTTLE) METHOD MODE CONTROL_TYPE (BRAKING) METHOD MODE CONTROL_TYPE (GEAR) METHOD MODE CONTROL_TYPE (CLUTCH) METHOD MODE CONTROL_TYPE = OPEN = ABSOLUTE = CONSTANT = OPEN = ABSOLUTE = CONSTANT = OPEN = RELATIVE = CONSTANT = OPEN = RELATIVE = CONSTANT = OPEN = RELATIVE = IMPULSE = 0.1 = 0.1
MAXIMUM_VALUE = 30.0
CONTROL_VALUE = 0
CONTROL_VALUE = 0
CONTROL_VALUE = 5
CONTROL_VALUE = 0
202
$----------------------------------------------------------------------------------FREE_CONTROL [FREE_CONTROL] (STEERING) ACTUATOR_TYPE = TORQUE METHOD MODE = OPEN = ABSOLUTE
CONTROL_TYPE = CONSTANT CONTROL_VALUE = 0 (THROTTLE) METHOD MODE = OPEN = RELATIVE
CONTROL_TYPE = CONSTANT CONTROL_VALUE = 0 (BRAKING) METHOD MODE = OPEN = RELATIVE
CONTROL_TYPE = CONSTANT CONTROL_VALUE = 0 (GEAR) METHOD MODE = OPEN = ABSOLUTE
CONTROL_TYPE = CONSTANT CONTROL_VALUE = 5 (CLUTCH) METHOD MODE = OPEN = ABSOLUTE
CONTROL_TYPE = CONSTANT CONTROL_VALUE = 0
203
Data-Driven Test
This is an example of an open-loop test driven by an external, measured data file. It shows the new functionality from which you can benefit by referencing .dcd files from .dcf files. The example demonstrates a mixture of open-loop, data-driven signals for steering, brakes, and throttle, coupled with machine-controlled signals for shifting.
$----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME FILE_TYPE = data_driven.dcf = dcf
FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCF file of open-loop data driven simulation referencing DCD file $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH = meters FORCE = newton ANGLE = deg MASS TIME = kg = sec
$----------------------------------------------------------------------------------EXPERIMENT [EXPERIMENT] EXPERIMENT_NAME = Sample Experiment: Data-Driven Simulation {mini_maneuver DATA_DRIVEN pri_end TIME pri_value 20.0 abort_time 20.0 step_size} 0.05
204
$----------------------------------------------------------------------------------DATA_DRIVEN [DATA_DRIVEN] (STEERING) ACTUATOR_TYPE = ROTATION METHOD = OPEN MODE = ABSOLUTE CONTROL_TYPE = DATA_DRIVEN FILE_NAME = data_driven.dcd (THROTTLE) MODE METHOD CONTROL_TYPE FILE_NAME (BRAKING) ACTUATOR_TYPE MODE METHOD CONTROL_TYPE FILE_NAME (GEAR) METHOD (CLUTCH) METHOD = = = = = = = = = ABSOLUTE OPEN DATA_DRIVEN data_driven.dcd FORCE ABSOLUTE OPEN DATA_DRIVEN data_driven.dcd
= MACHINE = MACHINE
(MACHINE_CONTROL) MIN_ENGINE_SPEED = 2000 MAX_ENGINE_SPEED = 5500
205
Example DCD File Referenced by DCF file for open-loop data driven $----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME FILE_TYPE = data_driven.dcd = dcd
FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCD file of open-loop measured data from actual driver $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH = meters FORCE ANGLE MASS TIME = newton = deg = kg = sec
$----------------------------------------------------------------------------------OPEN-LOOP [OPEN_LOOP] ordinal = time {time 0.0 0.1 ... ... ... ... steer 0.0 0.0 throttle 0.0 0.0 brake } 0.0 0.0
206
Step Steer Test

This is an example of an open-loop test that doesnt use external .dcd files.
$----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME FILE_TYPE = step_steer.dcf = dcf
FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCF file of open-loop step steer simulation $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH = meters FORCE ANGLE MASS TIME = newton = deg = kg = sec
$----------------------------------------------------------------------------------EXPERIMENT [EXPERIMENT] EXPERIMENT_NAME = Step-Steer example test {mini_maneuver STEP_STEER [STEP_STEER] (STEERING) ACTUATOR_TYPE METHOD MODE CONTROL_TYPE START_TIME DURATION FINAL_VALUE = = = = = = = ROTATION OPEN ABSOLUTE STEP 1.0 1.0 90 pri_end TIME pri_value 4.0 abort_time 4.0 step_size} 0.1
$----------------------------------------------------------------------------------STEP_STEER
207
(THROTTLE) METHOD
= MACHINE
(BRAKING) ACTUATOR_TYPE = FORCE METHOD = MACHINE (GEAR) METHOD MODE CONTROL_TYPE CONTROL_VALUE (CLUTCH) METHOD MODE CONTROL_TYPE CONTROL_VALUE = = = = = = = = OPEN ABSOLUTE CONSTANT 3 OPEN ABSOLUTE CONSTANT 0
(MACHINE_CONTROL) SPEED_CONTROL = VEL_POLYNOMIAL VELOCITY = 22.2 ACCELERATION = 0 JERK = 0
208
ISO Lane Change

This example uses Driver-Lite and a .dcd file to follow an arbitrary path. In this case, the path is the ISO standard lane change.
$----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME FILE_TYPE = iso_lane_change.dcf = dcf
FILE_VERSION = 1.0 FILE_FORMAT = 'ASCII' (COMMENTS) {comment_string} 'Example DCF file for Closed Loop ISO-Lane Change' $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH = 'meters' FORCE ANGLE MASS TIME = 'newton' = 'deg' = 'kg' = 'sec'
$----------------------------------------------------------------------------------EXPERIMENT [EXPERIMENT] EXPERIMENT_NAME = 'ISO-Lane Change' {mini_maneuver 'LANE_CHANGE' [LANE_CHANGE] (STEERING) ACTUATOR_TYPE = 'ROTATION' METHOD = 'MACHINE' MODE = 'ABSOLUTE' pri_end 'TIME' pri_value 8.0 abort_time 8.0 step_size} 0.01
$----------------------------------------------------------------------------------LANE_CHANGE
209
(THROTTLE) METHOD
= MACHINE
(BRAKING) ACTUATOR_TYPE = FORCE METHOD = MACHINE (GEAR) METHOD MODE CONTROL_TYPE CONTROL_VALUE (CLUTCH) METHOD MODE CONTROL_TYPE CONTROL_VALUE = = = = = = = = OPEN ABSOLUTE CONSTANT 3 OPEN ABSOLUTE CONSTANT 0 FILE iso_lane.dcd VEL_POLYNOMIAL 22.2 0 0
(MACHINE_CONTROL) STEERING_CONTROL = DCD_FILE = SPEED_CONTROL = VELOCITY = ACCELERATION = JERK =
Example DCD File Referenced by DCF file ISO-Lane Change $----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME FILE_TYPE = iso_lane.dcd = dcd
FILE_VERSION = 1.0 FILE_FORMAT = ASCII (COMMENTS) {comment_string} Example DCD file of ISO-Lane Change Path $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH FORCE ANGLE MASS TIME = = = = = meters newton deg kg sec
210
$----------------------------------------------------------------------------------CLOSED_LOOP [CLOSED_LOOP] steering_control = path speed_control = none (DATA) {X 0.0 -45.0 -52.5 -60.0 -90.0 -102.0 -115.0 -140.0 -147.0 -155.0 -162.0 -170.0 -200.0 -300.0 Y} 0.0 0.0 0.0 0.0 3.586 3.586 3.586 0.172 0.172 0.172 0.172 0.172 0.172 0.172
211
Lap Driving
This file gives an example of using human control to drive a vehicle around the Imola race course.
$----------------------------------------------------------------------------------MDI_HEADER [MDI_HEADER] FILE_NAME = lap_driving.dcf FILE_TYPE (COMMENTS) {comment_string} Example DCF file for Human-Control Lap Driving during Basic Learning $----------------------------------------------------------------------------------UNITS [UNITS] LENGTH FORCE ANGLE MASS TIME = = = = = meters newton deg kg sec = dcf FILE_VERSION = 1.0 FILE_FORMAT = ASCII
$----------------------------------------------------------------------------------LAP_DRIVING (STEERING) ACTUATOR_TYPE METHOD (THROTTLE) METHOD (BRAKING) ACTUATOR_TYPE METHOD = ROTATION = HUMAN = HUMAN = FORCE = HUMAN
(GEAR) METHOD = HUMAN(CLUTCH) METHOD = HUMAN(HUMAN_CONTROL) DRIVER_INPUT_FILE = standard_driver.din DRIVER_ROAD_FILE = Imola.drd START_DRIVER_ACTIVITIES = 0.1 LEARNING_ACTIVITIES = BASIC_DYNAMICS LEARNIG_ID = dn0 REMEMBER = NO INITIAL_VELOCITY = 22.2 INITIAL_GEAR = 3
212
Running Analyses in ADAMS/Car Index
213
Index
Symbols
._MDI_DRIVER_TESTRIG, described 10 ._MDI_SUSPENSION_TESTRIG, described 9 .dcd files, See Driver control data files .dcf files, See Driver control files
A-B C-D E-F G-H I-J K-L M-N O-P Q-R S-T U-V W-Z
A-B
Acceleration lift and squat 40 percent anti-lift 46 percent anti-squat 46 test analysis, described 91 Ackerman angle 69 Ackerman error 70 Ackerman percent 71 Ackerman, defined 68 Actuator type, specifying 113 ADAMS/Driver analyses, about 90 ADAMS/Driver, described 97 Aligning torque - steer and camber compliance 27 Analyses about 6 acceleration test 91 braking test 92 controlling output files 8 single lane-change 91 steering 92 types of 7 types of suspension 17 types of vehicle 89
214
Angle Ackerman 69 camber 29 caster 30 ideal steer 74 kingpin inclination 37 steer 78 toe 63 Assembling vehicles 87 Assumptions, in this guide 3 Braking dive 32 lift 32 percent anti-dive 43 percent anti-lift 43 Braking in a turn, example file for 196 Braking test analysis, described 92 Braking-in-turn analysis, described 94
C-D
Calculating, steer axes 22 Camber angle 29 lateral compliance 38 roll coefficient 50 Car, assembling 87 Caster angle 30 moment arm 72 roll coefficient 52 Checking, vehicle 88 Closed-loop control, using 100
215
Closed-loop data about 134 in .dcd files 138 specifying 137 Coefficient roll camber 50 roll caster 52 Command signal variables array about 182 example of 182 Compliance matrix, defined 24 Computation of suspension and steering characteristics 22 Configuration files, See Plot configuration files Constant radius cornering analysis, described 94, 96 Constant velocity cornering analysis, described 96 Control method, specifying 115 Control signal array statements about 180 example of 180 Control signal limits array about 181 example of 181 Creating driver control data files 141 plot configuration files 149 Data blocks described (.dcd) 135 described (.dcf) 110 Data-driven analysis described 93 example file for 203
216
Dataset elements about 162 examples of 178 human control specifications for 163 Dataset fragment, example of 168 Diameter, outside turn 75 Dive braking 32 Drift analysis, described 92 Driver control data files about 133 architecture of 135 creating 141 data blocks in 135 example of 135 specifications for 137 structure of 139 types of data in 134 Driver control files about 108 example of 131, 195 referencing .dcd files 203 structure of 110 Driver controller parameter arrays about 185 example of 185 Driver test rig, described 10 Driver-control-file-driven analysis, described 94
217
Driving Machine about 100 benefits of 103 data flow in 102 data flow, illustrated 102 dataset elements for 162 process 104 process, illustrated 105 uses of 103 Driving Machine analyses, described 93
E-F
Example driver control data file 135 driver control file 131, 195 experiment block 109 feedback signals steering 177 feedback signals throttle 177 input wheel-envelope file 158 ISO lane change 208 loadcase file 153 machine control 165 mini-maneuver block 109 output wheel-envelope file 160 SENSOR statement 182 step steer test 206 Experiment block about 110 example of 109 External-file analyses, types of 18 Feedback signals steering, example of 177 Feedback signals throttle, example of 177 Feedback signals variable arrays about 184 example of 184
218
Feedback signals, types of 177 Files loadcase 153 standard plot configuration 147 Forces, lateral 38 Fore-aft wheel center stiffness 34 Free control test, example file for 199 Front-view swing arm length and angle 35 Full vehicle assembling 87 checking 88 Full-vehicle analyses defined 8 process 86 subsystems required for 6 types of 90
G-H
General suspension characteristics 26 Generated paths about 166 types of 166 Geometric method, about 23 GSE statement, example of 179 Human control, feedback signals for 177
HUMAN_CONTROL, specifying 127
219
I-J
Ideal steer angle 74
IMPULSE function, use with Driving Machine 119
Impulse steer analysis, described 92 Inclination, kingpin angle 37 Input wheel-envelope file, example of 158 Instant axes method, about 23 ISO lane change, example file for 208 ISO-lane change analysis, described 94
K-L
Kingpin inclination angle 37 Lap driving, example file for 211 Lateral forces 38 Lift acceleration 40 Lift braking 32 Loadcase analysis described 18 example of file for 153 Location, roll center 53
M-N
Machine control example of 165 feedback signals for 177
MACHINE_CONTROL, specifying 124
MDI header block, about 110

mdi_full_vehicle.plt, described 147 mdi_suspension_parallel.plt, described 147
220
mdi_suspension_short.plt, described 147
Mini-maneuver block about 111 example of 109

MODE, specifying 129
Moment arm, caster 72
O-P
OPEN_CONTROL, specifying 116
Open-loop analyses, described 91 Open-loop control, using 100 Open-loop data, about 134 Opposite wheel travel analysis, described 17 Output files controlling 8 specifying 8 Output wheel-envelope file, example of 160 Outside turn diameter 75 Parallel wheel travel analysis, described 17 Parameters, setting for suspensions 15 Percent anti-dive braking 43 anti-lift acceleration 46 anti-lift braking 43 anti-squat acceleration 46 Plot configuration files creating 149 described 146 standard 147 using to view plots 148 Plots, viewing with configuration files 148 Primary end conditions, about 110
221
Q-R
Quasi-static analyses, described 95 Radius scrub 76 turn 82 Radius path data, about 167
RAMP function, use with Driving Machine 118
Ramp steer analysis, described 92 Ride rate 60 steer 49 Roles for suspension assembly 15 Roll camber coefficient 50 caster coefficient 52 center location 53 rate 61 steer 55 total rate 65
S-T
Scrub radius 76
SENSOR statement
about 182 example of 182 Side-view swing arm length and angle 58
SINE function, use with Driving Machine 120
Single lane-change analysis, described 91 Single wheel travel analysis, described 18 Specifying steps 16 Speed profiles, about 167
222
SPEED_CONTROL, specifying 125
Squat acceleration 40 Standard plot configuration files 147 Static load analysis, described 18 Steer angle 78 axis offset 79 ride 49 roll 55 Steer axes about 22 calculation methods 22 Steer axis offset, about 79 Steering analysis, described 18, 92 Steering system characteristics Ackerman 68 Ackerman angle 69 Ackerman error 70 Ackerman percent 71 caster moment arm 72 ideal steer angle 74 outside turn diameter 75 scrub radius 76 steer angle 78 turn radius 82
STEP function, use with Driving Machine 117
Step steer analysis, described 92 Step steer test, example file for 206 Steps, about specifying 16 Straight-line path data, about 166
223
Sub-blocks about 111 specifying attributes for 113 Submitting suspension analysis 16 Subroutine parameters about 186 example of 186 Suspension analyses defined 7 process for submitting 14 submitting 16 subsystems required for 6 types of 17 Suspension assembly, roles 15 Suspension characteristics aligning torque 27 camber angle 29 caster angle 30 computation of 22 dive braking 32 fore-aft wheel center stiffness 34 front-view swing arm angle 35 front-view swing arm length 35 kingpin inclination angle 37 lateral force camber compliance 38 lateral force deflection compliance 38 lateral force steer compliance 38 lift acceleration 40 lift braking 32 percent anti-dive braking 43 percent anti-lift acceleration 46 percent anti-lift braking 43 percent anti-squat acceleration 46 ride rate 60
224
ride steer 49 roll camber coefficient 50 roll caster coefficient 52 roll center location 53 roll rate 61 roll steer 55 side-view swing arm angle 58 side-view swing arm length 58 squat acceleration 40 toe angle 63 total roll rate 65 wheel rate 66 Suspension parameters, submitting 15 Suspension roll rate 61 Suspension test rig, about 9
SWEPT_SINE function, use with Driving Machine 122
Swept-sine steer analysis, described 93 Swing arm length and angle front-view 35 side-view 58 Test rigs about 9 about driver 10 about suspension 9 Toe angle 63 Total roll rate 65 Turn diameter, outside 75 radius 82
225
U-V
Units block, about 110 Vehicle assembling 87 checking 88 Viewing plots with plot configuration files 148
W-Z
Welcome to ADAMS 3 Wheel center stiffness, fore-aft 34 rate 66 Wheel travel analysis described 17 types of 17 Wheel-envelope analysis, described 19

Analysis

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Analysis

Transféré par

Droits d'auteur :

Formats disponibles

Mechanical Dynamics

Running Analyses in ADAMS/Car

Running Analyses in ADAMS/Car Copyright

Part number: 101CARANA-01

Running Analyses in ADAMS/Car About This Guide

About This Guide

What This Guide Assumes

Running Analyses in ADAMS/Car About This Guide

Introducing Analyses in ADAMS/Car

Running Analyses in ADAMS/Car Introducing Analyses in ADAMS/Car

About ADAMS/Car Analyses

Running Analyses in ADAMS/Car Introducing Analyses in ADAMS/Car

About Suspension Analyses, 7 About Full-Vehicle Analyses, 8

About Suspension Analyses

For a suspension analysis, you can specify inputs to:

Running Analyses in ADAMS/Car Introducing Analyses in ADAMS/Car

About Full-Vehicle Analyses

Controlling Analysis Output Files

Running Analyses in ADAMS/Car Introducing Analyses in ADAMS/Car

About Test Rigs

About the Suspension Test Rig

Running Analyses in ADAMS/Car Introducing Analyses in ADAMS/Car

About the Driver Test Rig

Steering Throttle Brake Clutch Transmission

About the Driving Machine Test Rig

Section I - Running Suspension Analyses

Performing Suspension Analyses, 13 Understanding Suspension Characteristic Calculations, 21

Running Analyses in ADAMS/Car Section I - Running Suspension Analyses

Performing Suspension Analyses

Running Analyses in ADAMS/Car Performing Suspension Analyses

Suspension Analysis Process

1, 3.00, 65%, 35%

A suspension analysis in ADAMS/Car is a quasi-static equilibrium analysis.

Running Analyses in ADAMS/Car Performing Suspension Analyses

Suspension Assembly Roles

Setting Suspension Parameters

Running Analyses in ADAMS/Car Performing Suspension Analyses

Submitting Suspension Analyses

Specifying Number of Steps, 16 Types of Suspension Analyses, 17

Specifying Number of Steps

Running Analyses in ADAMS/Car Performing Suspension Analyses

Types of Suspension Analyses

Wheel Travel Analyses, 17 Steering Analysis, 18 Steering Analysis, 18 External-File Analyses, 18

Wheel Travel Analyses

Parallel Wheel Travel Analysis

Running Analyses in ADAMS/Car Performing Suspension Analyses

Single Wheel Travel Analysis

There are two types of external-file analyses:

Loadcase Analysis, 18 Wheel-Envelope Analysis, 19

Running Analyses in ADAMS/Car Performing Suspension Analyses

Running Analyses in ADAMS/Car Performing Suspension Analyses

Understanding Suspension Characteristic Calculations

Running Analyses in ADAMS/Car Understanding Suspension Characteristic Calculations

Computing Suspension and Steering Characteristics

Calculating Steer Axes

Running Analyses in ADAMS/Car Understanding Suspension Characteristic Calculations

Geometric Method, 23 Instant Axes Method, 23

Instant Axes Method

Running Analyses in ADAMS/Car Understanding Suspension Characteristic Calculations

Definition of Compliance Matrix

Running Analyses in ADAMS/Car Understanding Suspension Characteristic Calculations

X left wheel Y Z AX AY AZ X right wheel Y Z AX AY AZ

C ( 2, 1 ) , C ( 2, 2 ) C ( 2, 12 ) C ( 3, 1 ) , C ( 3, 2 ) C ( 3, 12 ) C ( 7, 1 ) C ( 1, 8 ) C ( 9, 1 ) , C ( 9, 2 ) C ( 12, 1 ) , C ( 12, 2 ) C ( 12, 12 )