Adams Driveline Mdr3 Help
Adams Driveline Mdr3 Help
Adams Driveline Mdr3 Help
2 Adams/Driveline
About Adams/Driveline
You can use Adams/Driveline, part of the MD Adam R3 suite of software, stand alone or as a plugin
for Adams/Car. You use Adams/Driveline to model drivelines: to create virtual prototypes of driveline
subsystems and analyze the virtual prototypes much like you would analyze the physical prototypes.
Using Adams/Driveline, you can quickly create assemblies of suspensions and full vehicles, including
driveline components, and then analyze them to understand their performance and behavior.
You create assemblies by defining vehicle subsystems, such as front and rearsuspensions, steering gears,
anti-roll bars, and bodies. You base these subsystems on their corresponding Adams/Driveline templates.
For example, Adams/Driveline includes templates for engine, gearbox, prop shafts, and differentials.
If you have expert-user access, you can also base your subsystems on custom templates that you create
using the Adams/Driveline Template Builder.
When you analyze an assembly, Adams/Driveline applies the analysis inputs that you specify. For
example, for a full-vehicle analysis you can specify inputs to:
Apply a specific torque to your driveline model (impulse, step, ramp, loadcase, and so on).
Define a different friction coefficient for different wheels in your model.
Define a slope of your road to study the performance of your driveline model.
Based on the analysis results, you can quickly alter the driveline geometry andanalyze the driveline again
to evaluate the effects of the alterations.
Once you complete the analysis of your model, you can share your work with others. You can also print
plots of the vehicle dynamic responses. In addition, you can access other users models without
overwriting their data.
Benefits of Adams/Driveline
Adams/Driveline enables you to work faster and smarter, letting you have more time to study and
understand how design changes affect vehicle performance.
Using Adams/Driveline you can:
Explore the performance of your design and refine your design before building and testing a
physical prototype.
Analyze design changes much faster and at a lower cost than physical prototype testing would
require. For example, you can change springs with a few mouse clicks instead of waiting for a
mechanic to install new ones in your physical prototype before re-evaluating your design.
Vary the kinds of analyses faster and more easily than if you had to modify instrumentation, test
Work in a more secure environment without the fear of losing data from instrument failure or
Run analyses and what-if scenarios without the dangers associated with physical testing.
6 Adams/Driveline
Starting Adams/Driveline
In the Windows environment, you start Adams/Driveline from the Start button. In the UNIX environment, you
start Adams/Driveline from the Adams Toolbar.
This topic describes how you start the two Adams/Driveline interface modes, standard interface or template
builder.
If the Welcome dialog box does not contain any options, then Adams/Driveline is already
If the Welcome dialog box does not contain any options, then Adams/Driveline is already
8 Adams/Car
Interface Modes
Adams/Car has two interface modes:
Standard Interface - You use it when working with existing templates to create and analyze
assemblies of suspensions and full vehicles. Users with standard and expert access can use the
Standard Interface.
Template Builder - If you have expert-user access, you use the Template Builder to create new
When you create a new component in the Template Builder, your product automatically adds a
prefix based on the entity type and the symmetry. Your product uses a naming convention to let
you easily determine an entitys type from the entitys name. Learn about the naming convention
and see a table that lists the prefixes of various entities. If you have expert-user access, you use
the Template Builder to create new templates for use in the Standard Interface.
Using the Template Builder, you can assemble standard components, such as springs, parts, and
bushings, to define the topology of your system, such as a suspension or a single valvetrain in an
engine.
To switch between modes:
Do one of the following:
From the Tools menu, select [Product Name] Standard Interface or select [Product Name]
Template Builder.
Press F9.
Interface. Therefore, the standard user cannot make topological modifications to templates, but
can operate on subsystems, varying design parametrics and analysis inputs.
Expert user - Expert users have access to modeling capabilities available in theTemplate
Builder. Therefore, expert users can open templates and modify their topological information, as
well as create new templates.
If you are an expert user, when you launch your Adams product, it prompts you to select either
Standard Interface or Template Builder.
The private configuration file is not located in the installation directory. Never change the
acar.cfg file located in the installation
access the Template Builder and other development tools that are located under the Tools menu.
Expert users can use the MDI_ACAR_PLUS_AVIEW keyword in the private configuration file
to access Adams/View. Learn about accessing Adams/View.
To change the value of this keyword, you must edit the private configuration file (.acar.cfg) using a text
editor and modify the corresponding string. The following gives you expert access:
! Desired user mode (standard/expert)
ENVIRONMENT MDI_ACAR_USERMODE EXPERT
When you start a new session, your template-based product reflects the changes to the private
configuration file.
10 Adams/Car
Viewing Objects
Showing, Hiding, and Selecting Objects in the Database Navigator
Managing the Select List
Filtering Objects in the Database Navigator
Sorting Objects in the Database Navigator
Setting Highlighting in the Database Navigator
Changing Objects
Setting Appearance of Objects Through the Database Navigator
Renaming Objects Through the Database Navigator
Adding Comments Through the Database Navigator
model_1 . These objects do not have parents. Double-click the name of a model, in this case model_1,
to find all the objects belonging to that model.
selected.
Request to view information about an object using the Info command on the Edit pop-up menu.
Browse for the name of an object to enter in a dialog box using the Browse command.
11
12 Adams/Car
13
14 Adams/Car
Size of the screen icons that represent the object in your model. Note that these changes take
precedence over the size you specify globally for the modeling database.
Tip:
For transparency, the higher the value, the more transparent the object is, allowing
other objects to show through. The lower the value, the more opaque the object is,
covering other objects. However, setting the transparency of objects can have a
negative impact on graphical performance if you are using a graphics card without
hardware acceleration for OpenGL. Instead of setting an objects transparency,
consider setting the objects render mode to wireframe.
3. To set the scope of the appearance changes, you can select either:
Object - Only apply to the selected object.
Siblings - Apply changes to all objects of the same type that are children of the parent of the
selected object.
All - Apply changes to objects matching the filter you set in the Filter text box.
4. Select Apply.
15
16 Adams/Car
By connections - Displays each constraint and force with the parts they connect and act on. Also
Graphically - Displays a representation of the selected part and shows its connections to other
parts.
By connections - Displays each constraint and force with the parts they connect and act on. Also
17
18 Adams/Car
Displaying Information
Displaying Object Information and Accessing the Information Window
Displaying Parent and Children Information
Displaying an Object's Modify Dialog Box
Managing Information
Clearing the Information Window
Saving Information in the Information Window
Displaying a Text File in the Information Window
Copying Text in the Information Window
Setting the Information Mode
19
20 Adams/Car
Tip:
You may want to zoom in on theobject on the screen to more easily place thecursor
over just that object.
21
22 Adams/Car
3. Select OK.
The Information window appears with the text of the file as its content.
Using Wildcards
You can use wildcards to narrow any search, set the type of information displayed in a window, such as
the Database Navigator or the log file, or specify a name of an object in a dialog box.
This Character:
* (asterisk)
[ab]
[^AB]
Any character other thanthe characters following the caret symbol (^) in the
brackets
[a-c]
{AB, bc}
23
24 Adams/Car
Setting Preferences
Setting Screen and Printer Fonts
You can change the font your template-based product uses to display text in a view, such as the name of
a part or a note on the screen, or to print text to a printer. The fonts available for displaying text in a view
are those available with your operating system. The fonts available for printing text are a fixed set of 12
fonts. Note that your printer may not support all of these printer fonts.
To select a screen or printer font:
1. On the Settings menu, select Fonts.
The Fonts dialog box appears.
2. In the Screen Font text box, enter the name of the font you want your template-based product to
use to display text in a view. To browse for a font, right-click the text box, select Browse, and
then select a font.
3. Set Postscript Font to the font you want to use to print text.
4. Select OK.
Do the following:
Unit for a specific Select the individual unit from the pull-down menu associated with the dimension.
dimensions
Predefined unit
system
Select one of the following buttons. In all the unit systems, time is in seconds and
angle is in degrees. When you select a predefined unit system, the units selected
appear in the upper portion of the dialog box.
MMKS - Sets length to millimeters, mass to kilograms, and force to
Newtons.
25
26 Adams/Car
In addition, you can set the size of the icons either in current units or as a factor of their current size.
Learn more about how to set the display of screen icons by database and object type.
Setting Screen Icon Display by Database
Setting Screen Icon Display by Object Type
For information on quickly toggling the display of all screen icons, see Displaying View Accessories. For
information on setting the display of icons for individual objects, see Setting Object Appearance through
Edit -> Appearance Command.
types of objects.
Off - Turns off all icons regardless of how you set the icon display for individual objects or
types of objects.
3. In the New Size text box, enter the size you want for the screen icons. Note that any changes you
make to the size of icons for individual objects or types of objects take precedence over this size
setting.
4. To save the settings for each new database in your template-based product settings file
(*BS.cmd), select Save new size as default.
5. Select OK.
Points
Data elements
Equations (system elements)
however, that turning on the display of screen icons for the entire database overrides this
setting.
Inherit - Lets the object type simply inherit the display settings from its parent. For example,
No Change - Does not change the current settings. Lets you make changes to other display
4. Enter the size you want for the icons or select the amount by which you want to scale the icons.
The scale factor is relative to thecurrent size set. A scale factor of 1 keeps the icons the same size.
A scale factor less than 1.0 reduces the size of the icons and a scale factor greater than 1.0
increases the size of the icons. Note that these changes take precedence over the size you specify
globally for the modeling database.
5. Enter the color you want to use for the icons.
27
28 Adams/Car
6. To browse for or create a color, right-click the Color text box, and then select Browse or Create.
7. Set Name Visibility Option to whether or not you want the names of objects of the selected type
displayed in the view. Refer to Step 3 for an explanation of the choices.
8. Select OK.
Working grid
Screen icons
View triad
View title
To use a dialog box to toggle on and off the display of view accessories:
1. Click the main window.
2. On the View menu, select View Accessories, and then select the accessories that you want toturn
on or off from the View Accessories dialog box that appears.
3. Enter the title you want displayed in the main window, and then press Enter.
4. On the Window menu in the View Accessories dialog box, select Exit.
29
30 Adams/Car
Tip:
Type a lowercase g while the cursor is in the main window to toggle on and
31
32 Adams/Car
Command Navigator
Enables you to enter Adams/View commands without having to know the entire syntax of the
commands.
The Command Navigator displays a list of all Adams/View command keyword. A plus (+) in front of a
keyword indicates that the command has more keywords below it but they are hidden. A minus (-)
indicates that all keywords below the keyword are displayed. No indicator in front of a keyword indicates
that there are no more keywords below the object. When you select an object with no indicator, a dialog
box appears in which you enter parameters for executing the command.
Message Window
Provides you with messages on the status of Adams/View and displays helpful information while you
are using Adams.
Adams/View displays messages about the execution of a command in the message window. By default,
the message window only displays messages about commands you execute from the user interface. You
can also set it to display messages about commands that you execute from the command window,
command Navigator, and command files.
33
34 Adams/Car
Information Window
Adams/View uses the Information window to display many different types of information about your
model, simulation, or motion data. In addition to just viewing information about your model, you can
perform a variety of operations in the Information window.
The information includes:
Topology on the different objects in your model
Object information, such as information about a part or a view
Model verification results
Measurements from one coordinate system marker to another
Result set component information
View attributes
Results from a system command you run using the Tools -> System Command
The Option:
Apply
Executes the command but leaves the dialog box open so you can execute the
command again.
Parent
Children
Modify
Select to display the modify dialog box for the object displayed in the text box
at the top of the Information window.
Verbose
Select if you want to display more information about the object such as
children of the object, its geometry, whether or not commands are associated
with it, and its attributes like color and visibility.
Clear
Save to File
Database Navigator
Displays the types of objects appropriate for the command you are executing and shows objects in their
database hierarchy. You can browse for objects or set it to rename objects, view information about the
objects and view dependencies. You can also set a filter for the types of objects displayed in the Database
Navigator.
Do the following:
Use the pull-down menu to choose a mode option. Select one:
Browse (the default; the options on this page describe Browse)
Display Attribute
Rename
Comments
Information
Topology by Parts
Topology by Connections
Graphical Topology
Associativity
Select List
Filter
Select if you want to filter the types and names that you want displayed in the
Database Navigator. Then, enter the name of the objects you want to display in
the text box and use the pull-down menu to the right to select the type of
object(s) you want to display. You can also use the pull-down menu below the
Filter text box to only display those objects that are active or inactive.
Sort by
Use the pull-down menu to choose how you want the objects sorted. You can
also select to not sort the objects so they appear in the order they are stored in
the modeling database.
Highlight
Off by default. Select if you want an object to appear selected in the main
window and the reverse.
Use the plus sign (+) or the minus (-) (--) signs to display or hide all of the
children hidden/shown in the tree view.
35
36 Adams/Car
If you select to display the results in the log file, you can keep the command results with the other
commands that you execute so that you can cut and paste the information together into a new file.
To execute a system command within your template-based product:
1. On the Tools menu, select System Command.
The Execute Systems Command dialog box appears.
2. In the Command Text text box, enter the operating system command that you want to execute.
See your operating system documentation for more information.
3. Select whether or not you want the output of the command to be displayed in the Information
window or the log file.
4. Select OK.
Note:
You can change the name of the log file through the initialization file .mdi_init.
you entered.
Error - Displays fatal messages that your template-based product did not understand and,
Fatal - Displays messages that indicated that your model would not simulate.
37
38 Adams/Car
2. If desired, select Show only lines containing and enter the text that the line must contain in the
text box. You can also enter wildcards.
3. Select Apply.
To remove duplicate lines:
From the Display Log File dialog box, select Suppress duplicate lines.
39
40 Adams/Car
Building Models
40 Adams/Car
Subsystems
You only use subsystems in the Standard Interface. You can either create new subsystems or read in
existing ones. When you create a new subsystem, you must reference an existing template. When you use
an existing subsystem, the template associated with it is automatically read in.
Subsystems are based on templates and allow standard users to change the parametric data of the template
as well as the definition of some of the components. For example, you can change the location of
hardpoints and modify parameter variables.
The template-based products organize the basic components that make up a full assembly or subassembly
into subsystems. For example, subsystems can include suspensions, wheels, drivelines, chassis, and so
on.
Subsystems contain descriptions of the component that they model. These descriptions consist of:
Design data, such as wheel radii, toe angles, and locations of various points in the subsystems,
References to property files that contain design data for bushings, bumpstops, dampers, engines,
springs, and tires. A bushing property file, for example, contains a description of the bushing's
stiffness and damping characteristics.
Reference to a template that defines the subsystem's construction, including the kinds of parts
and how the parts interact and attach to one another. For example, a template that defines a rack
and pinion steering system defines a rack part, a pinion part, and a housing part. It also defines
that the rack slides in the housing, that the pinion rotates in the housing, and that the rack and
pinion are geared together. Since the construction of all rack and pinion steering systems is
similar, all subsystems describing a rack and pinion steering system can reference the same
template.
Building Models
Minor Roles
Publishing Subsystems
Opening Subsystems
When you open a subsystem that specifies a flexible representation of a rigid part, your template-based
product replaces the equivalent rigid body from the template with the flexible body. Learn about flexible
bodies.
To open an existing subsystem:
1. In Standard Interface, from the File menu, point to Open and then select Subsystem.
2. Press F1 and then follow the instructions in the dialog box help for Open Subsystem.
3. Select OK.
Notice that once the subsystem is open, the Edit and Adjust menus become active. We
recommend that you familiarize yourself with each menu item.
Creating Subsystems
You create subsystems by selecting a template that defines the topology and default data for your
subsystem. Using the Standard Interface, you can modify the default data to match your design. We
supply several templates with each product. For example, for Adams/Carusers, we supply templates that
represent MacPherson strut and double-wishbone suspension subsystems. Using the Template Builder
you can create templates for your company-specific topologies.
When creating a new subsystem, you can reference the property files that the template references, or
reference other property files held either in a different database or with a different file name, as indicated
by the dashed lines in the example model architecture.A collection of subsystems merged together forms
an assembly.
To create a subsystem:
1. In the Standard Interface, from the File menu, point to New, and then select Subsystem.
41
42 Adams/Car
2. Press F1 and then follow the instructions in the dialog box help for New Subsystem.
3. Select OK.
Updating Subsystems
Resets the values of a subsystem to those stored in a subsystem file. You can update a subsystem using
any subsystem file that is based on the same template as the subsystem in session.
When you update a subsystem, your template-based product does not reload the template.
Note:
To update a subsystem:
1. In the Standard Interface, from the File menu, point to Manage Subsystems, and then select
Update.
2. Press F1 and then follow the instructions in the dialog box help for Update Subsystem.
3. Select OK.
Synchronizing Subsystems
When you synchronize a subsystem, you apply the values of the selected master subsystem to one or
more subsystem instances using the automated subsystem update feature. You can synchronize the
subsystems in session that are based on the same subsystem file. The subsystem mode flags (kinematic
or compliant) of the target subsystems will be retained.
For example, you may have several instances of one subsystem open in your session under several
assemblies. If you modify one subsystem and want to propagate those changes to every instance of the
subsystem, you can use the synchronize subsystems functionality.
To synchronize subsystems:
1. In the Standard Interface, from the File menu, point to Manage Subsystems, and then select
Synchronize.
2. Press F1 and then follow the instructions in the dialog box help for Synchronize Subsystem.
3. Select OK.
Adding Subsystems
When you add a subsystem into an assembly, your template-based product disassembles the assembled
model, opens the subsystem, and then reassembles the model to include the new subsystem.
Building Models
To add a subsystem:
1. From the File menu, point to Manage Assemblies, and then select Add Subsystem.
2. Press F1 and then follow the instructions in the dialog box help for Add Subsystem.
3. Select OK.
Your template-based product does the following:
Disassembles the assembly, which includes 'unassigning' communicators.
Opens the new subsystem under the existing assembly.
Reassembles the assembly, which includes re-assigning the communicators.
Replacing Subsystems
When you replace a subsystem in an assembly with a new subsystem, your template-based product
disassembles the assembled model, deletes the subsystem, opens the new subsystem, and then
reassembles the model to include the new subsystem.
To replace a subsystem:
1. From the File menu, point to Manage Assemblies, and then select Replace Subsystem.
2. Press F1 and then follow the instructions in the dialog box help for Replace Subsystem.
Select OK.
Your template-based product does the following:
Disassembles the assembly, which includes 'unassigning' communicators.
Deletes the subsystem from the existing assembly.
Opens the new subsystem underneath the existing assembly.
Reassembles the assembly, which includes re-assigning the communicators.
Removing Subsystems
When you remove a subsystem from the assembly to which it belongs, your template-based product
disassembles the assembled model, deletes the subsystem, and then reassembles the model.
To remove a subsystem:
1. From the File menu, point to Manage Assemblies, and then select Remove Subsystem.
2. Press F1 and then follow the instructions in the dialog box help for Remove Subsystem.
3. Select OK.
Your template-based product does the following:
Disassembles the assembly, which includes 'unassigning' communicators.
Deletes the subsystem from the assembly.
43
44 Adams/Car
assembly.
Reassembles the assembly (with the activated subsystem now taking part), which includes re-
simply ignored.
Reassembles the assembly (with the deactivated subsystem not considered), which includes
Saving Subsystems
You save subsystems in ASCII format, and you can publish subsystems to databases so other users can
share them. We support two formats: TeimOrbit and XML.
If your subsystem contains a flexible part, your template-based product saves information about the part,
as well as the marker-node association, in the PART_ASSEMBLY block of the subsystem file. Your
template-based product writes one block for a single flexible part or two for paired parts, of which one is
flexible.
Building Models
To save a subsystem:
While viewing a subsystem, from the File menu, do one of the following:
Select Save (or use the keyboard shortcut, Ctrl + s) - Your template-based product saves the
TeimOrbit version of the subsystem to the default writable database and prompts you if a
subsystem already exists. For save options, select Save As.
Point to Save As, and then select Subsystem - Press F1 and then follow the instructions in the
dialog box help for Save Subsystem. Select OK.
TeimOrbit version of the subsystem to the default writable database and prompts you if a
subsystem already exists. For save options, select Save As.
Point to Save As, and then select Subsystem - Press F1 and then follow the instructions in the
dialog box help for Save Subsystem. Select OK.
Closing Subsystems
You can close a subsystem without first saving it to a database.
To close a subsystem:
1. In the Standard Interface, from the File menu, point to Close, and then select Subsystem.
2. Press F1 and then follow the instructions in the dialog box help for Close Subsystem.
3. Select OK.
Subsystem Modes
A subsystem exists in one of two modes - kinematic or compliant. When you toggle a subsystem between
these two modes, certain elements such as joints and bushings may be enabled or disabled. When you
create a joint, you define it to be active always or only in kinematic mode. Conversely, when you create
a bushing, you define it to never be inactive or be inactive only in the kinematic mode. This allows you
to use the same subsystem for both dynamic and kinematic analyses.
45
46 Adams/Car
Minor Roles
You assign a minor role, or function, to every subsystem. The minor role of a subsystem is stored in a
variable as a string. This string will also be written to the subsystem file. You select a minor role to
identify how your product should use the subsystem when creating an assembly of subsystems for
analysis.
A minor role defines the subsystem's location.
Adams/Car - A minor role can be front or rear. The following are the minor roles for
If you create a new subsystem with the minor role front based on a steering template, during
assembly Adams/Car connects your front steering subsystem to a front suspension subsystem,
but not a rear suspension subsystem.
If you create a new subsystem with the minor role any, during assembly Adams/Car connects
your new subsystem to any other active subsystem having matching communicators.
Publishing Subsystems
When you publish a subsystem, you copy the subsystem file and all its associated property files to the
target database, which is the database where your template-based product saves all files. You can also
select to publish the subsystem's template file. As you publish the subsystem, you can choose to write
over existing files or create backups of the files.
You can also select to update the in-session subsystem data to point to the target database or to have the
subsystem retain the existing references.
The subsystem you are publishing must be currently opened in the standard interface, and the target
database must be writable. Learn about setting the writable database.
You can also publish an entire assembly. Learn about publishing an assembly.
To publish a subsystem:
1. From the Tools menu, point to Database Management, and then select Publish Subsystem.
2. Press F1 and then follow the instructions in the dialog box help for Publish an Open Subsystem.
3. Select OK.
Building Models
Assemblies
Assemblies represent a collection of subsystems, along with a test rig, which when assembled form a
system that you can analyze using Adams/Solver.
In Adams/Car for example, a steering subsystem and a front-suspension subsystem, plus a suspension
test rig, form the basis of a suspension assembly that you can analyze for kinematic behavior.
In the Standard Interface, you can create, open, save, and analyze assemblies. You can also publish
assemblies to databases so other users can share them. Learn about publishing assemblies.
Learn more about assemblies:
Opening Assemblies
Getting Assembly Information
Creating Generic Assemblies
Updating Assemblies
Saving Assemblies
Closing Assemblies
Publishing Assemblies
Opening Assemblies
To open an existing assembly:
1. In Standard Interface, from the File menu, point to Open and then select Assembly.
2. Press F1 and then follow the instructions in the dialog box help for Open Assembly.
3. Select OK.
Notice that once the subsystem is open, the Edit, Adjust, and Simulate menus become active. We
recommend that you familiarize yourself with each menu item.
47
48 Adams/Car
Updating Assemblies
You can re-read an assembly file, in case you modified the file by an alternative process. For example, if
you edit in a text editor an assembly file stored in the shared database, you can reflect this change in your
template-based product by using the update assembly functionality.
To update an assembly:
1. In the Standard Interface, from the File menu, point to Manage Assemblies, and then select
Update.
2. Press F1 and then follow the instructions in the dialog box help for Update Assembly.
3. Select OK.
Saving Assemblies
You save assemblies in ASCII or binary format:
ASCII Assemblies - An ASCII assembly file references subsystems, but does not contain
subsystem data. If you want your assembly to be updated with the current template/subsystem
files, you should save your assemblies in ASCII format. When you open an ASCII-format
assembly, your template-based product opens each individual subsystem, which in turn accesses
the current version of each corresponding template.
Binary Assemblies - A binary assembly is a static snapshot of what's currently in your session.
That is, when you reopen a binary assembly, you will return to the exact state at which you left.
Adams/Car ignores any subsequent modifications made to templates and/or subsystems, which
were originally used to create the assembly, when you open the binary assembly. Therefore, if
you want your assembly to be updated with the current template/subsystem files, you should
save your assemblies in ASCII format.
Binary assemblies can be very useful, however, if you are working on a project where the
templates will not change, and a static snapshot of the assembly is sufficient.
Note that saving an assembly as a binary will not save the plots, nor the setting for simulation
(hold_solver_license). It will, however, save the analyses associated with the assembly, and you
could re-create plots using a plot configuration file. Learn about plot configuration files.
Building Models
To save an assembly:
1. From the File menu, select Save or Save As.
2. If you selected:
Save - Your template-based product saves the ASCII version of the assembly to the default
writable database. Your template-based product prompts you if it detects subsystem changes.
It also prompts you if the assembly already exists in the database. For save options, select
Save As.
Save As - Press F1 and then follow the instructions in the dialog box help for Save Assembly.
Select OK.
Closing Assemblies
To close an assembly:
1. In the Standard Interface, from the File menu, point to Close, and then select Assembly.
2. Press F1 and then follow the instructions in the dialog box help for Close Assembly.
3. Select OK.
Publishing Assemblies
When you publish an assembly, you copy each subsystem file included in the assembly definition,
including the associated property files for each subsystem, to the target database, which is the database
where your template-based product saves all files. You can also select to publish each subsystem's
template file. As you publish the assembly, you can select to write over existing files or create backups
of the files.
You can also select to update the in-session assembly data to point to the target database or to have the
assembly retain the existing references.
The assembly you are publishing must be currently opened in the standard interface, and the target
database must be writable. Learn about setting the writable database.
You can choose to publish only a subsystem, not an entire assembly. Learn about publishing a subsystem.
To publish an assembly:
1. From the Tools menu, point to Database Management, and then select Publish Assembly.
2. Press F1 and then follow the instructions in the dialog box help for Publish an Open Assembly.
3. Select OK.
49
50 Adams/Car
Property Files
Property files are ASCII-based files that contain data for modeling components, such as valve spring,
cams, and bushings. Because property files are flat text files, you can use any text editor to create or
modify them.
You use property files to:
Apply the same characteristics or parameters to many components within a template or
subsystem. In Adams/Car for example, a suspension might contain many bushings with the same
properties. In this case, all the bushings could reference the same property file.
You can reference property files in different subsystems and templates, as shown in the example model
architecture.
All property file types are specifiedin the configuration file (acar.cfg). When you edit property files, you
can save them either with the existingfile name or with a new file name. Learn about managing property
files through configuration files.
Property files are grouped in classes and stored in databases. Every class (such as bushings and dampers)
is filed in the corresponding database table (in this case, bushings.tbl and dampers.tbl).
A subset of property files define force-displacement or force-velocity characteristics for springs,
dampers, bumpstops, reboundstops, and bushings. For those components, you use the Curve Manager or
Property File Editor to create, edit, and view property files. You can access the Curve Manager from the
Tools menu. From within dialog boxes, you can edit property files using the Curve Manager/Property
File Editor tool
Building Models
Templates
Templates are parametric models, built by expert users within the Template Builder. Templates define
the default geometric data and topology of models, such as a double-wishbone suspension, an engine
cranktrain, or an aircraft landing gear. The components within a template are parametrically defined such
that you can use a single template within numerous subsystems.
Templates are intended to be a generic representation of a mechanical system, such that a template that
is common to a number of different vehicles can be reused in each of those vehicles. For example,
assume that you have two cars, a small car and a large car and that each of the two cars have a doublewishbone front suspension. You could use a double-wishbone template in each of the two vehicles. The
only difference is that the large car requires stiffer springs, larger A arms, different dampers, and so on.
The basic topology is the same: it is the components/properties that are changed. It is the subsystem file
that references the topology of the template but changes the characteristics of the suspension by
referencing different springs, parts, dampers, and so on.
Templates provide a quick way to experiment with different subsystems and still retain the basic design
components that are required.
A template in its most fundamental form cannot be used in the Standard Interface without first being
referenced by a subsystem file.
You can modify the data of a template by changing the values of design parameters. Hardpoints,
parameter variables, and property files are the design parameters of templates, where:
Hardpoints define locations for geometry, attachments, and construction frames.
Parameter variables contain strings, integers, and real values that you can modify in the Standard
Templates contain communicators to enable the exchange of information with other templates.
Learn more about templates:
Opening Templates
Creating Templates
Saving Templates
Closing Templates
Major Roles
Location of Templates
Opening Templates
When using the Template Builder for the first time, we recommend that you first open some of the
example templates we provide and familiarize yourself with them.
51
52 Adams/Car
Notice that once the template is open, the Edit and Build menus become active. We
recommend that you familiarize yourself with each menu item.
Creating Templates
To ensure that an analysis will work with your new template, when you create a template you must make
sure that the template is compatible with other templates and with the test rigs. The template must contain
the proper output communicators.
To create a template:
1. From the File menu, select New.
2. Press F1 and then follow the instructions in the dialog box help for New Template.
3. Select OK.
Note:
Notice that once the template is open, the Edit and Build menus become active. We
recommend that you familiarize yourself with each menu item.
Saving Templates
Using the Template Builder, you can save your files in ASCII or binary format. Saving your files in
ASCII format provides the benefit of small file sizes and being human readable. On the other hand,
saving your files in binary format ensures faster processing, but does not have the benefits associated
with ASCII format.
When saving a template that includes a flexible part, your template-based product saves the part as rigid.
To save a template:
1. From the File menu, select Save or Save As.
2. If you selected:
Save - Your template-based product saves the binary version of the template to the default
writable database and prompts you if the template already exists. For save options,select Save
As.
Save As - Press F1 and then follow the instructions in the dialog box help for Save Template.
Select OK.
Building Models
Closing Templates
You can close a template without first saving it to a database.
To close a template:
1. From the File menu, select Close.
2. Press F1 and then follow the instructions in the dialog box help for Close Template.
3. Select OK.
Major Roles
You assign a major role, or function, to every template. The choices in the Major Role option menu
correspond to the available major roles for a template.
A major role is a property of a template. A subsystem inherits the major role of the type on which it is
based.
In Adams/Car, examples of major roles are: suspension, steering, and body. Note that for each major role
(for example, suspension, steering, and so on) Adams/Car allows only one active subsystem with the
minor role any. The choices in the Minor Role option menu correspond to the available minor roles for
an Adams/Car subsystem.
Location of Templates
The templates are located in the templates.tbl table, or directory, of your template-based product's shared
database. The shared database is usually located in your product's installation directory. For location
details, see your system administrator.
53
54 Adams/Car
Test-Rig Templates
You can extend the functionality of your templates by converting them into test-rig templates, also
referred to as test rigs.
In the template-based products, test rigs are almost completely comparable to regular templates. The
basic topological difference between test rigs and regular templates is that besides containing parts that
are attached using attachments and forces, test rigs also contain actuator elements, such as motions and
forces, to excite the assembly. Just like regular templates, test rigs also contain communicators to enable
the exchange of information with other templates.
You use test rigs when creating assemblies. A collection of subsystems and a test rig form an assembly.
Note that the name of a test rig is always preceded by a period and two underscores, that is .__. For
example, .__MY_TESTRIG. This is a convention used by all template-based products to differentiate
between templates (period and one underscore, ._), subsystems (period, .), and test rigs (period and two
underscores, .__).
Learn about test rigs:
Process Overview
Creating Test-Rig Templates
Saving Test-Rig Templates
Converting Templates into Test Rigs
Adding Test Rigs to Binaries
Process Overview
The process of working with test-rig templates involves the following steps:
For Adams/Car:
1. Creating a template and saving it in ASCII format as explained in Creating Test-Rig Templates
and Saving Test-Rig Templates.
2. Modifying the ASCII template file to become an ASCII command file, which is now the test rig,
as explained in Converting Templates into Test Rigs.
3. Saving the ASCII command file into a binary file as described in Adding Test Rigs to Binaries.
Building Models
3. Select OK.
Note:
You must specifically set the minor roles of communicators in test-rig templates to any. Do
not set them to inherit. You set the minor roles to any because generally a template test rig
should be capable of connecting with any subsystem.
writable database and prompts you if thetemplate already exists. For save options, select Save
As.
Save As - Press F1 and then follow the instructions in the dialog box help for Save Template.
Select OK.
55
56 Adams/Car
(COMMENTS)
{comment_string}
'Simple Double Wishbone Suspension'
$--------------------------------------------TEMPLATE_HEADER
[TEMPLATE_HEADER]
MAJOR_ROLE = 'suspension'
TIMESTAMP = '1999/07/15,17:21:32'
HEADER_SIZE = 5
You should remove all the lines from the beginning of the file up to, and including, the line containing
the HEADER_SIZE attribute.
Modifying Adams/View Variables
Templates and test rigs in template-based products have information that is stored in Adams/View
variables to determine how the template is used. All templates, including test rigs, have three required
variables: major role, minor role, and model class. Test rigs, however, have an additional required
Adams/View variable called test rig class.
When you create the test-rig template, your template-based product automatically creates the first three
variables. You must, however, manually create the last variable, the test rig class variable.
The following sections introduce the variables:
Major Role
Minor Role
Model Class
Test-Rig Class
Major Role
The major role of templates and test rigs is stored in an Adams/View variable called role. The major role
of a test rig is always analysis.
When creating a test rig, make sure that you set the major role as shown next:
variable create &
variable_name = .__acme_4PostRig.role &
string_value = "analysis" &
comments = "Memory for Adams/Car major role"
Minor Role
The minor role of templates and test rigs is stored in an Adams/View variable called minor_role. The
minor role of a test rig is typically any. Setting the minor role to any is veryimportant if you are designing
a test rig that is supposed to work with other subsystems that can have different minor roles.
In Adams/Car for example, a suspension test rig should work with either front, rear, or trailer-type
suspensions. If the minor role of the test rig were defined as front, the test rig would hook up only to front
suspensions.
Building Models
57
58 Adams/Car
When you add this command to the acar_build.cmd file, Adams/Car reads in and stores the test rig in the
private or site binary, making the test rig available for use whenever you start an Adams/Car private or
site session.
As as additional option, you can rename your test rig file from the .tpl extension to a .cmd extension to
reflect the fact the test rig is now a command file.
Building Models
Communicators
Communicators are the key elements in template-based products that enable the exchange of information
between subsystems, templates, and the test rig in your assembly.
An assembly requires two directions of data transfer between its subsystems. To provide for these two
directions of data transfer, the template-based products have two types of communicators:
Input communicators - Request information from other subsystems or test rigs.
Output communicators - Provide information to other subsystems or test rigs.
In Adams/Car for example, a mount communicator in the rack and pinion steering templates outputs the
rack part name so that tie rods of suspension templates can attach to the rack. In addition, a mount
communicator in the steering template inputs a part name. The steering template uses the part name to
determine where to attach the steering column.
Learn more about communicators:
Creating/Modifying Input Communicators
Creating/Modifying Output Communicators
Communicator Entity Class
Communicator Roles
Communicator Naming
Matching Communicators During Assembly
Displaying Communicator Information
Testing Communicators
59
60 Adams/Car
Exchanges:
The following entity classes do not have symmetry and, therefore, are always single, by default:
Array
Spline Splin
Solver variable
ion name.
Parameter variable name.
e name.
Adams/Solver variable name. You must use an Adams/Solver variable, not an
Adams/View variable. Unlike an Adams/View variable, an Adams/Solver
variable's computation occurs during analysis. Your template-based product
generates Adams/Solver variables as state variables.
Marker
Joint Join
t name.
Joint-for-motion Join
t name.
Building Models
The class:
Exchanges:
Bushing Bus
Location
Part Par
hing name.
The location of the named hardpoint or construction frame. If the hardpoint is
part of a symmetrical pair, the template-based products create two input
communicators, one for each hardpoint in the pair.
t name.
Orientation The
Real parameter
Integer parameter
You can define a communicator's minor role when you create it. For example, if you want to provide
input to or output from subsystems of specific roles, then you set the minor role for communicators when
you create them. We recommend, however, that you do not set a communicator's minor role. Instead, let
the subsystem determine the minor role by setting it to inherit, in which case the communicator inherits
the minor role from the subsystem in which it is embedded. For example, in Adams/Car a suspension
template might be used to define either a front or rear suspension subsystem. By letting the subsystem
determine the minor role, the assembly process attaches a steering systemto the front suspension and not
to the rear.
Communicator Naming
After you create a communicator, your template-based product assigns a prefix to the name. For
example, it creates a prefix, cil_ where:
ci indicates it is an input communicator. If it were an output communicator, the template-based
61
62 Adams/Car
l indicates it is for the left side of a symmetrical pair. If it were for the right side, the template-
based product would use an r. If it were a single communicator, it would have an s (cis).
If you create a mount part, your template-based product automatically creates an input communicator of
the class mount. It uses the name of the mount part as the name of the communicator and appends the
prefix ci[lrs]_ to it, depending on whether or not it is a left, right, or single communicator. For example,
if you create a mount part of mtl_rack_mount, your template-based product creates an input
communicator with the name cil_rack_mount, where the l indicates it is for the left side.
As you name communicators, you should ensure that any input and output communicators that exchange
information have identical matching names. In Adams/Car for example, the name you give to
communicators that exchange a part name during assembly might be ci_strut_mount and
co_strut_mount, each of which has a matching name of strut_mount. In addition, if you are working with
MSC.Software templates, you must ensure that you use the same naming conventions as the
MSC.Software templates. Learn about matching communicators.
cil_strut_mount m
ount
col_strut_mount m
ount
cil_strut_mount m
ount
To minor role:
front
front
any
Building Models
The pair:
col_strut_mount m
ount
cil_strut_mount m
ount
col_strut_mount m
ount
To minor role:
front
front
any
You can match an input communicator with only one output communicator. You can, however, match an
output communicator with any number of input communicators.
You should always check the warning messages during the assembly, especially if the warning refers to
an input communicator of class mount that does not get assigned and is, therefore, attached to ground.
Testing Communicators
You can perform a test to verify that you have correctly specified input and output communicators in your
template. You can use this test to determine whether or not you need to add or modify communicators to
correctly create an assembly.
When you perform the test, you specify the model names of one or more existing templates or test rigs.
Although you can specify a single template, you should specify all the templates containing
communicators that transfer information between the selected template. You must specify a minor role
for each template, subsystem, or test rig you chose to test.
After you perform the test, your template-based product lists the matching input and output
communicators, the unmatched input communicators, and the unmatched output communicators for the
templates, subsystems, and test rigs you selected. You can save the test information to a file.
To test communicators:
1. From the Build menu, point to Communicator, and then select Test.
63
64 Adams/Car
2. Press F1 and then follow the instructions in the dialog box help for Test Communicators.
3. Select OK.
The Information window appears. It contains a list of the communicators that match other
communicators and a list of those that do not. It shows the matched communicators followed by
the unmatched communicators. The lists include the names of the input and output
communicators and the names of the templates to which they belong. Often, you'll see many
communicators that are unmatched. Many of these communicators are related to subsystems or
test rigs that you do not currently have open.
If you want to fully test the communicators in your template, you should open the other templates
with which you want the template to communicate. In Adams/Car for example, if you are creating
a suspenion template, the template must be able to communicate with a steering template and the
suspension test rig.
66 Adams/Car
Creating Components
You can create components only in the Template Builder. The Template Builder design leads you through
a step-by-step process for creating components: the Build menu is organized such that you can start at
the top of the menu, building basic components, and work your way down, attaching these basic
components together and building increasingly complex components.
For information about a certain component, see the topic for that component.
The following example shows how you can create arm geometry. You follow the same basic steps to
create any other component listed under the Build menu.
To create arm geometry:
1. From the Build menu, point to Geometry, point to Arm, and then select New.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Arm Geometry.
3. Select one of the following:
OK if you want to execute the command and close the dialog box.
Apply if you want to execute the command butkeep the dialog box open so you can continue
to work in it.
Cancel if you decide not to execute the command and close the dialog box.
Modifying Components
Depending on the component you want to modify, one or more of the following methods will be
available:
Modifying Component Parameters
Modifying Component Property File
Replacing Instance Definition
In the Standard Interface - The standard user can reference an existing template by either
opening or creating a subsystem file. The standard user can modify only selected parameters in
the Standard Interface.
The following examples show how you can modify component parameters in either interface. You use
the same basic steps to modify any components parameters.
In Standard Interface, to modify arm geometry:
1. Right-click an arm geometry, and then select Modify.
2. Press F1 and then follow the instructions in the dialog box help for Modify Arm.
3. Select OK.
67
68 Adams/Car
Note:
You can only change a limited number of parameters in the Standard Interface.
editor, such as vi on UNIX and Notepad on NT, display the property file referenced by the
component you want to change, modify any of the parameters as needed, and then save your
changes.
The Curve Manager - You can modify some property files as explained in Modifying Property
Files Using the Curve Manager.
The following example shows how you can change a component's definition. You follow the same basic
steps to change the definition of other components.
Components currently supported include: air spring, bushing, damper, and spring, as well as applicationspecific components.
Note:
In Adams/Car you can change the component definition only in the Standard Interface.
Deleting Components
You can delete components only in the Template Builder. If you try to delete a component that is
dependent on other components, your template-based product informs you that the component is
dependent on others, and if you delete it, the dependents also are deleted.
Because not all the components you can create and delete in the Template Builder have a graphical
representation, you cannot delete some components by right-clicking on them. The following procedures
explain how you can delete both types of components: those that have a graphical representation as well
as those that dont.
To delete components that do not have graphical representation:
1. From the Build menu, point to the component you want to delete, and then select Delete.
The appropriate Delete dialog box appears.
2. Fill in the dialog box as appropriate, and then select either of the following:
OK if you want to execute the command and close the dialog box.
Apply if you want to execute the command butkeep the dialog box open so you can continue
to work in it.
69
70 Adams/Car
Entity type:
bg[lrs]_
bk[lrs]_
bu[lrs]_
cf[lrs]_ Constr
ci[lrs]_ Input
co[lrs]_ Output
css_ Condition
da[lrs]_
fb[lrs]_ F
ff[lrs]_ User
uction frame
communicator
communicator
sensor
Damper (Adams/Car only)
lexible body
-function feedback channel
Prefix:
ge[lrs]_ G
gk[lrs]dif_ Gear
Entity type:
eneral part
differential (kinematically active)
gk[lrs]red_ G
gp[lrs]_ G
eneral parameter
gr[lrs]dif_ Gear
gr[lrs]red_ Gear
graarm Arm
geometry
gracyl_ C
graell_ Ellipse
ylinder geometry
geometry
gralin_ Li
nk geometry
graout_ O
utline geometry
gs[lrs]_ Gener
al spline
gv[lrs]_ G
eneral variable
hp[lrs]_ H
ardpoint
ip[lrs]_ Interface
jf[lrs]_
jk[lrs]_ Jo
part
Joint force actuator
int (kinematically active)
jm[lrs]_
jo[lrs]_
mt[lrs]_ M
nr[lrs]_ Nonlinear
ount part
rod
ns[lrs]_ Spring
ph[lrs]_ H
pt[lrs]_ P
pv[lrs]_ P
arameter variable
re[lrs]_
sw[lrs]_ Switch
ti[lrs]_
ue[lrs]_ U
wh[lrs]_
71
72 Adams/Car
Hardpoints
Hardpoints contain location information and are the basic building blocks for most other components.
Hardpoints have no orientation. If you need components that hold both location and orientation
information, use construction frames.
Hardpoints and construction frames are also referred to as coordinate references.
You use the Template Builders Build menu to create, modify, and delete hardpoints. When you create
hardpoints, you can define them symmetrically or as a single point in space. When defining hardpoints
symmetrically, you could, for example, define a left hardpoint and the right hardpoint is automatically
generated as a parametric point.
Creating a Hardpoint
To create a hardpoint:
1. From the Build menu, point to Hardpoint, and then select New.
2. Press F1 and then follow the instructions in the dialog box help for Create Hardpoint.
3. Select OK.
Modifying a Hardpoint
In Standard Interface, to modify a hardpoint:
1. From the Adjust menu, point to Hardpoint, and then select Modify.
2. Press F1 and then follow the instructions in the dialog box help for Modify Hardpoint Location.
3. Select OK.
In Template Builder, to modify a hardpoint:
1. From the Build menu, point to Hardpoint, and then select Modify.
2. Press F1 and then follow the instructions in the dialog box help for Modify Hardpoint Location.
3. Select OK.
Modifying Several Hardpoints at a Time
If you want to modify several existing hardpoints at a time, you can use a table editor to do so.
In Standard Interface, to modify several hardpoints at a time:
1. From the Adjust menu, point to Hardpoint, and then select Table.
2. Press F1 and then follow the instructions in the dialog box help for Hardpoint Modification Table.
3. Select Apply.
In Template Builder, to modify several hardpoints at a time:
1. From the Build menu, point to Hardpoint, and then select Table.
2. Press F1 and then follow the instructions in the dialog box help for Hardpoint Modification Table.
3. Select Apply.
73
74 Adams/Car
Construction Frames
Construction frames contain both location and orientation information, and are the basic building blocks
for many other components. When you need only location and no orientation information, hardpoints are
the correct components to use.
Hardpoints and construction frames are also referred to as coordinate references.
You can define construction frames symmetrically. To easily locate and orient construction frames
without having to worry about complex rotations and translations, you can use various options:
Summary of Location Dependency Options
Summary of Orientation Dependency Options
Parts
You can build the following types of parts in Template Builder:
General Parts
Interface Parts
Flexible Bodies
Nonlinear Beams
Mount Parts
Switch Parts
General Parts
A general part is arigid part that is defined by its location, orientation, mass, inertia, and center ofgravity.
Note that the computed mass properties are not parametric. Your template-based product does not update
the mass properties when the geometry changes, if hardpoints have changed position, for example. If you
want to have the part mass re-computed based upon a parts geometry, you must explicitly have your
template-based product compute the mass properties based on the changed geometry by calculating the
mass for the general part, using the Build or Adjust menus. Alternatively, you can change the mass
properties to user-defined values by modifying the general part using the Build or Adjust menus.
In the Standard Interface, general parts are enhanced to be either rigid or flexible. Learn about flexible
parts.
75
76 Adams/Car
Interface Parts
Interface parts let you connect flexible bodies to the rest of your template. You cannot use joints or
bushings to connect general parts and flexible bodies: you must use interface parts.
To create or modify interface parts:
1. From the Build menu, point to Parts, point to Flexible Body, point to Interface Part, and then
select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Interface Part.
3. Select OK.
Flexible Bodies
Template-based products use descriptions of flexible bodies, named modal neutral files (MNF), from a
finite element (FEM) program. The MNF is a binary, platform-independent file that combines compact
storage and efficiency of data access.
The information in an MNF includes:
Geometry (locations of nodes and node connectivity)
Nodal mass and inertia
Mode shapes
Generalized mass and stiffness for mode shapes
The Template Builder uses a method of modeling flexible bodies named modal flexibility. Modal
flexibility assigns a set of mode shapes (eigenvectors) to a flexible body. The principle of linear
superposition is then used to combine the mode shapes at each time step to reproduce the total
deformation of the flexible body. This method can be very useful in problems that are characterized by
high elasticity and moderate deflections.
In Standard Interface, to modify a flexible body:
1. If the displayed subsystem or assembly has a flexible part, from the Adjust menu, point to
Flexible Body, and then select Modify.
2. Press F1 and then follow the instructions in the dialog box help for Modify Flexible Body.
3. Select OK.
In Template Builder, to create or modify a flexible body:
1. From the Build menu, point to Parts, point to Flexible Body, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Flexible Body.
3. Select OK.
Nonlinear Beams
A nonlinear beam consists of one cylindrical/rectangular segment or several segments connected to each
other at coordinate references. The cylindrical/rectangular elements can have hollow cross sections to
represent pipes. The segments form a shaft with a stiffness appropriate to the cross-sectional area and
material stiffness.
Using a nonlinear beam offers you a quick and easy way to deliver flexibility during early design stages.
The mass and inertia properties of a nonlinear beam are determined according to the outer radius, inner
radius, and material type, with the cylinder wall thickness = (outer radius - inner radius).
Nonlinear beams can be:
Rigid - A rigid nonlinear beam is a sequence of cylinders that belongs to one part. You can use
rigid nonlinear beams to model links that do not have a simple straight-line shape.
Flexible - For a flexible nonlinear beam, your template-based product creates a separate part for
each hardpoint you specify. Your template-based product cuts into two pieces the cylinder
between two hardpoints, with each belonging to one of the two parts associated with the
hardpoints. The two halves are then connected elastically by a beam element. You can use
flexible nonlinear beam to model components such as anti-roll bars.
77
78 Adams/Car
Mount Parts
A mount part is a massless part that acts as an alias for another part in a separate template. You can use
this alias part as you would use the real part when creating joints, springs, contacts, and so on. A mount
part is fixed to ground by default. If there are matching communicators of type mount found during the
assembly process, the template-based product fixes the mount part to the part specified as the value of
the corresponding output communicator.
To create or modify a mount part:
1. From the Build menu, point to Parts, point to Mount, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Mount Part.
3. Select OK.
Switch Parts
A switch part is a massless part that enables flexible topology. You can use this switch part as you would
use any real part when creating joints, springs, bushings, and so on. Your template-based product has a
list of real parts related to each switch part. At any time, the switch part is fixed to one and only one of
the parts on the part list.
A switch part lets you explore two different topological solutions. For example, a suspension may
connect either directly to a chassis or to a subframe, depending on the subsystems active during assembly.
The switch part makes these topological solutions possible. Following assembly, switch parts are
automatically deleted.
When you choose a new part in the Switch to Part pull-down menu, the switch part changes the part it is
fixed to, and all the joints and forces acting on the switch part will act on the new part. The switch part
concept allows you to model and investigate different topologies.
Creating or Modifying Switch Parts
In Standard Interface, to modify a switch part:
1. From the Adjust menu, select Switch Part.
2. Press F1 and then follow the instructions in the dialog box help for Modify Switch Part.
3. Select OK.
In Template Builder, to create or modify a switch part:
1. From the Build menu, point to Parts, point to Switch, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Switch Part.
3. Select OK.
79
80 Adams/Car
Markers
A marker defines a local coordinate system on any part in your model or on ground. A marker has a
location (the origin of the coordinate system) and an orientation.
To create or modify a marker:
1. From the Build menu, point to Marker, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Marker.
3. Select OK.
Geometry
Geometry components in the template-based products allow you to easily build parametric
representations of standard parts. If mass and inertia information is unavailable, you can automatically
calculate the mass of the general part based on the size of the geometry.
You can build the following geometry components:
Arm Geometry
Link and Cylinder Geometry
Ellipsoid Geometry
Outline Geometry
Note that the computed mass properties, based on geometry, are not parametric. Your template-based
product does not update the mass properties when the geometry changes, if hardpoints have changed
position, for example. If you want to have the part mass re-computed, based upon a parts geometry, you
must explicitly have your template-based product compute the mass properties based on the changed
geometry, by Calculating Mass for the General Part, using the Build or Adjust menus. Alternatively, you
can change the mass properties to user-defined values by modifying the General Part, using the Build or
Adjust menus.
Arm Geometry
An arm part is a solid triangular plate defined by three coordinate references and a thickness. If
necessary, you can automatically update the mass and inertia properties of the general part.
In Adams/Car, you could use the arm geometry to view the control arm of a MacPherson suspension.
In Standard Interface, to modify arm geometry:
1. Right-click an arm geometry, and then select Modify.
2. Press F1 and then follow the instructions in the dialog box help for Modify Arm.
3. Select OK.
In Template Builder, to create or modify arm geometry:
1. From the Build menu, point to Geometry, point to Arm, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Arm Geometry.
3. Select OK.
81
82 Adams/Car
The link geometry consists of a cylinder whose ends you define using two hardpoint locations
and a radius. You can use links to view the tie rods of certain suspensions.
You define the cylinder using a construction frame, rather than two hardpoints. The centerline of
the cylinder follows the z-axis of the construction frame. You can define the cylinder so that it
has length in both the positive and negative z-axis. You can use cylinders to view the strut rods
of certain suspensions.
If necessary, you can automatically update the mass and inertia properties of the general part.
Creating or Modifying Link Geometry
In Standard Interface, to modify link geometry:
1. Right-click a link, and then select Modify.
2. Press F1 and then follow the instructions in the dialog box help for Modify Link.
3. Select OK.
In Template Builder, to create or modify link geometry:
1. From the Build menu, point to Geometry, point to Link, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Link Geometry.
3. Select OK.
Creating or Modifying Cylinder Geometry
To create or modify link geometry:
1. From the Build menu, point to Geometry, point to Cylinder, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Cylinder
Geometry.
3. Select OK.
Ellipsoid Geometry
An ellipsoid geometry is defined by a coordinate reference and a user-specification of x, y, and z
dimensions. You can use ellipsoids to represent spherical elements of your template. A sphere is an
ellipsoid whose x, y, and z radii have the same values.
You can use two different methods of defining an ellipsoid:
Use a link to define the radius and then specify a scaling factor in each of the orthogonal axes
Define a measurement in each axis
If necessary, you can automatically update the mass and inertia properties of the general part.
Outline Geometry
You can use the outline to draw a line between different hardpoint locations. You can choose to define
either an open or a closed outline. In general, you would use outlines to visualize the general form of
parts. For example, you would add outline geometry to represent the subframe of a vehicle.
Because the geometry entity has no thickness, you cannot update the mass and inertia properties of an
outline.
To create or modify outline geometry:
1. From the Build menu, point to Geometry, point to Outline, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Outline
Geometry.
3. Select OK.
83
84 Adams/Car
Attachments
When working with template-based products, you can use two types of attachments:
Joints
Bushings
Joints
Joints define a rigid connection between two parts and help define the motion of the parts. The following
table lists the joints the template-based products support, along with information about their degrees of
freedom (DOF):
Joint name:
Number of DOF:
Translational
Revolute
Cylindrical
Spherical
Planar
Fixed
Inline
Inplane
Orientation
Parallel_axes
Perpendicular
Convel
Hooke
You can use different parametric orientation options to define the location and direction of the joint.
To create or modify a joint:
1. From the Build menu, point to Attachments, point to Joint, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Joint
Attachment.
3. Select OK.
85
86 Adams/Car
the parameters for a specific bushing, you must specify the bushing you want to modify.
Right-click a bushing, point to its name, and then select Modify. The dialog box has the bushing
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Bushing
Attachment.
3. Select OK.
To modify a nonlinear bushing in the Standard Interface:
1. In Standard Interface, right-click a bushing, point to its name, and then select Modify. The dialog
box has the bushing parameters already loaded.
2. Press F1 and then follow the instructions in the dialog box help for Modify Bushing.
3. Select OK.
Linear Bushings
To modify a linear bushing in the Standard Interface:
1. Right-click a bushing, point to its name, and then select Modify. The dialog box has the bushing
parameters already loaded.
2. Press F1 and then follow the instructions in the dialog box help for Modify Linear Bushing.
3. Select OK.
Stiffness Forces Computation
In the expressions that follow:
i, j k, l are indices whose integer values of 1 to 3 indicate application to the x, y, and z coordinate
directions, respectively
qk = rk
( k D ) , q is given by:
q k = m sgn ( r k )
D
with
m =
rl
l=1
and
rk = Hk xk Qk
xk
rk
qk
Hk
Qk
- Horizontal (displacement) scaling for the kth direction (disp_scale); can be used to perform unit
conversions
- Displacement offset for the kth direction (disp_offset);can be used to specify an offset between
the modeled bushing and the physical bushing (perhaps caused by the rotational preload
introduced by the assembly process)
This formulation allows the elements of the displacement vector, x, to be scaled up by a user-specified
factor, H, and/or offset by a user-specified displacement offset, Qk, to determine the transformed
displacement vector, qk, which becomes the lookup point in the selected stiffness force characteristic (see
next).
The Stiffness Force, f
For uncoupled directions
87
88 Adams/Car
f k = G k V k y k ( q k' v k )
(k D)
, f, is given by:
f k = G k V k w k y k ( q k' v k )
with .
rk
w k = ------m
fk
- Stiffness component of the force in the kth direction, determined by accounting for preload,
scaling factors, and inter-axial coupling
yk
wk
- Weighting of the returned force for the kth direction (0 to 1, for coupled directions only)
Gk
Vk
See the following sections for the precise mathematical descriptions of the two alternative coupling
formulations.
Note about the scaling factors, V and H:
Note:
Results in a nonlinear change of the restoring force for bushings whose force-
y i ( q i', v i ) = y i ( q i ) = ( k i q i )
Piecewise Linear
The piecewise linear characteristic is defined as:
y ( q, v ) = y ( q ) = k 1 q +
m1
l=1
( k l + 1 k l ) ( q b l ), q > b l
where:
qi -
ki
l
bi
m
Note that
l1
and
bi
> bi
ki
89
90 Adams/Car
Figure 1
dy spw
-------------- = k 1 +
dq
with:
2
( kl + 1 kl ) l ( 3 2l )
l=1
1
m1
l 0
0 < l < 1
l 1
e
q b l ---
2
l = ---------------------------e
where (noting that for clarity, the subscript i, indicating direction, has been dropped):
kl
bl
l1
ki
and
ki
e
This gradient is integrated analytically from zero displacement q, to find the force-displacement curve.
The constant of integration is set such that if there were no smoothing, the curve would pass through the
origin. As smoothing is introduced, this constant of integration (the vertical offset of the forcedisplacement curve) is adjusted such that the smoothed curve continues to overlay the unsmoothed curve
in regions where there is no smoothing (such as those for high values of displacement). Note that this
means that if the origin is contained within a smoothing interval, then the smoothed force-displacement
curve may not pass exactly through the origin, but that you can safely vary the smoothing interval,
knowing that as the displacement moves from a smoothed into an unsmoothed region, the behavior will
converge to that of the unsmoothed piecewise curve.
Note that as with the piecewise formulation,
l+1
bi
> bi
91
92 Adams/Car
Figure 2
AKIMA Spline
The nonlinear, AKIMA spline characteristic is defined using a single Adams AKIMA spline. The
restoring force is than determined directly from this spline:
y i ( q i', v i ) = y i ( q i ) = AKISPL ( q i, 0, ID i )
Hysteretic (Dual-Spline)
The hysteretic definition of the stiffness characteristic also incorporates some damping (velocitydependence) of the force, according to the following:
y i ( q i', v i ) = AKISPL ( q i, v i, ID i )
where:
v i = STEP ( p i, P, 1, P, 1 )
with:
p i = A i x i E i
where:
Ai
Ei
Pi
- Velocity saturation point (m/s) for the i direction (for hysteretic bushings only)
pi
vi
x i
x i
Such that, for v < -v, the force_neg_vel_values only are used, and for v > vel_threshold, only the
force_pos_vel_values are used. When v is between these values, the two force characteristics are
interpolated according to the STEP function described above.
Note that for very large values of P, the hysteresis disappears, and the characteristic approaches a simple
displacement-dependent AKIMA spline:
93
94 Adams/Car
y i ( q i', v i ) y i ( q i ) = AKISPL ( q i, 0, ID i )
The following is an example of the typical behavior of a hysteretic bushing, excited to increasing
amplitude:
Figure 3
Displacement
Figure 4
Force
- Scaled and offset bushing velocity (the point in the force lookup)
95
96 Adams/Car
Ai
Ei
, to be scaled up by a user-specified
Linear
The linear characteristic is straightforward, and is defined using a damping constant, c:
For a linear characteristic, the parameter damping_value should be set equal to the required stiffness, c.
AKIMA Spline
The nonlinear, AKIMA spline characteristic is defined using a single Adams AKIMA spline. The
damping-force characteristic is then determined directly from this spline:
Piecewise Linear
The piecewise linear characteristic is defined as:
where:
qi
Note that
and
A typical characteristic from this formulation will look similar to the following:
97
98 Adams/Car
Figure 5
For an uncoupled linear bushing (D = 0 or 1, stiffness_type = 1), this reduces to a constant damping
coefficient and a typical viscous damping characteristic.
Learn how the stiffness damping characteristics are expressed in the .adm file.
Bushings are implemented using a FIE(ld)SUB. This FIESUB reads the bushing specifications directly
from the .adm deck, and returns the total (stiffness plus damping) force, fi + ci, for any six-element
bushing displacement and six-element bushing velocity vector.
Coupling Specification
The value of D for the bushing is specified directly as shape in the FIELD statement for the bushing:
FIELD/id, I=idi, J=idj, FUNCTION=USER(branch, shape, txa, tya, tza, rxa, rya, rza)
- Rectangular (no coupling). The force in each direction is dependent only on the
displacement in that direction.
- Cylindrical (that is, x-y coupling). The forces in the x and y directions are each dependent
on the displacement of the bushing in both the x and y directions. The force in the z
direction is independent (that is, it depends only on the displacement in z).
- Spherical (that is, x-y-z coupling). The force in each direction depends on the
displacements in all translational directions, and the torque in each direction depends on
the angular displacements in all rotational directions.
Note that the selected shape factor (coupling) always applies to both the translational and rotational
behavior of the bushing.
The next six parameters in the FIELD statement, all of which are required, should contain the Adams
array IDs of the arrays containing the data, which expresses the stiffness and damping characteristic for
the direction:
FIELD/id, I=idi, J=idj, FUNCTION=USER(branch, shape, txa, tya, tza, rxa, rya, rza)
Each of the referenced arrays must be included in the .adm file, and should be in the following form:
ARRAY/id, NUM=
All of those parameters are required, and are described in detail in the following sections.
Stiffness Force Characteristic
You can use a number of formulations to express the stiffness force characteristic of the bushing, by
appropriately setting the integer value of stiffness_type (see above), and providing the necessary data in
the .adm file.
99
100 Adams/Car
Linear (stiffness_type = 1)
For a linear characteristic, the parameter stiffness_value should be set equal to the required stiffness, k.
Piecewise Linear (stiffness_type = 4)
When you select this stiffness type, you must provide an additional array in the .adm file, and you must
set the value of stiffness_value (see above) equal to the integer Adams ID of that additional array. That
additional array must be of the form:
ARRAY/id, NUMBERS = n, k(0), b(1), k(1), ... , b(n), k(n)
where:
- The number of slopes that define the stiffness characteristic. This number must be
an integer and greater than 1 (note that for bushings with a single slope defining the
stiffness characteristic, the linear stiffness type, stiffness_type = 1, should be used)
b(m)
- The breakpoint where the slope (stiffness) changes from k(m-1), for displacements
lower than b(m), and to k(m) for displacements greater than b(m).
- The slopes, all of which must be real and positive for a physical, passive bushing.
Their units are stiffness (force/displacement) or angular stiffness (torque/angular
displacement). Note that k(0) extends to minus infinity and k(n) to plus infinity.
Note that the set k(0), b(1), k(1), ... , b(n), k(n) must contain precisely 2n-1 values, so that the total number
of elements in the array must be 2n.
Smoothed Piecewise Linear (stiffness_type = 5)
When you select this stiffness type, you must provide an additional array in the .adm file, and you must
set the value of stiffness_value (see above) equal to the integer Adams ID of this new array. For the
smoother piecewise characteristic, the new array must be of the form:
ARRAY/ID, NUMBERS = s, n, k(0), b(1), k(1), ... , b(n), k(n)
where:
- The interval over which changes of slope are smoothed. This number must be a real
value greater than zero, in units of displacement.
- The number of slopes that define the stiffness characteristic. This number must be
an integer and greater than 1 (note that for bushings with a single slope defining the
stiffness characteristic, the linear stiffness type, stiffness_type = 1, should be used).
b(m)
- The breakpoint where the slope (stiffness) changes from k(m-1), for displacements
lower than b(m), and to k(m) for displacements greater than b(m).
- The slopes, all of which must be real and positive for a physical, passive bushing.
Their units are stiffness (force/displacement) or angular stiffness (torque/angular
displacement). Note that k(0) extends to minus infinity and k(n) to plus infinity.
Note that the set k(0), b(1), k(1), ... , b(n), k(n) must contain precisely 2n-1 values, so that the total
number of elements in the array must be 2n+1.
AKIMA Spline (stiffness_type = 2)
The nonlinear, AKIMA spline characteristic is defined using a single Adams AKIMA spline, specified
by setting stiffness_value equal to the Adams ID of the spline. That spline must be supplied in the dataset,
but can be shared among several directions and/or bushings.
Hysteretic Dual-Spline (stiffness_type = 3)
To specify this stiffness characteristic, the .adm file must include both a two-element array (whose
integer ID is placed in stiffness_value), of the form:
ARRAY/id, NUM = sid, P
where the terms are defined as:
sid
- The (positive) velocity threshold above which the bushing characteristic becomes
independent of the velocity
101
102 Adams/Car
Note the sign convention here. Within the spline definition, an increase inx (transformed velocity) should
generally yield an increase in the y value (damping force).
The same Adams AKIMA spline can be used for more than one direction of the same bushing (optionally,
with different scaling), and/or for more than one instance of a bushing within the same model.
Piecewise Linear (damping_type = 3)
When you select this damping type, exactly as with the equivalent stiffness type, you must provide an
additional array in the .adm file, and you must set the value of damping_value (see above) equal to the
integer Adams ID of that additional array. That array must be of the form:
ARRAY/id, NUMBERS = n, k(0), b(1), k(1), ... , b(n), k(n)
where:
- The number of slopes that define the damping characteristic. This number must be
an integer, and greater than 1 (note that for bushings with a single slope defining the
damping characteristic, the linear damping type, damping_type = 1, should be used).
- The breakpoints. The values of velocity, or of angular velocity, at which the slope of
the damping characteristic changes. These values must be real and in ascending order,
but may be negative.
b(m)
- The breakpoint where the slope (damping coefficient) changes from c(m-1), for
velocities lower than b(m), to c(m) for velocities greater than b(m)
- The slopes, all of which must be real and positive for a physical, passive bushing.
Their units are those of damping (that is, force/velocity) or rotational daming (that is,
torque/angular velocity). Note that c(0) extends to minus infinity and c(n) to plus
infinity.
Note that the set c(0), b(1), c(1), ... , b(n), c(n) must contain precisely 2n-1 values, so that the total number
of elements in the array must be 2n.
Stiffness Fraction ("k-fraction") (damping_type = 4)
For the stiffness-fraction damping characteristic, the parameter damping_value should be set equal to the
required stiffness fraction, k.
103
104 Adams/Car
Forces
You can build the following types of forces in Template Builder:
Springs
Dampers
Bumpstops
Reboundstops
Your template-based product models air springs as simple action-reaction forces between two parts. Each
air spring references an air-spring property file that tabulates spring force against trim load and deflection
from trim length. Trim load is the nominal load in the spring for a given trim length and internal pressure.
Before analysis, your template-based product reads the data from the referenced property file and stores
it in a three-dimensional SPLINE. During analysis, Adams/Solver computes the air-spring force by
interpolating the SPLINE data using the Akima method.
Air springs include an auto-trim feature, where you can specify a desired trim height of the suspension
and the air spring's trim load is automatically adjusted during static equilibrium analysis to achieve the
trim height.
To use an air spring in a subsystem, select a coil spring and use thereplace option from the shortcut menu
to replace the coil spring with an air spring.
Learn about air springs:
Modifying Air Springs
Auto Trim Load
Calculation of Air-Spring Force
parameters for a specific spring, you must specify the spring you want to modify.
Right-click a spring, point to its name, and then select Modify. The dialog box has the spring
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Spring.
3. Select OK.
To modify a nonlinear spring in the Standard Interface:
1. In Standard Interface, right-click a spring, point to its name, and then select Modify. The dialog
box has the spring parameters already loaded.
2. Press F1 and then follow the instructions in the dialog box help for Modify Spring.
3. Select OK.
Linear Springs
To modify a linear spring in the Standard Interface:
1. Right-click a spring, point to its name, and then select Modify. The dialog box has the spring
parameters already loaded.
2. Press F1 and then follow the instructions in the dialog box help for Modify Linear Spring.
3. Select OK.
About Linear Springs
Your template-based product (using the Adams/Solver SPRINGDAMPER) calculates the spring force
as follows:
Spring Force = - K*(DM(I,J) - OffsetCalc)
where:
105
106 Adams/Car
install methods.
coordinate references.
Use Hardpoints - The installed length of the spring equals the distance between the I and J
coordinate references.
When you submit the model to Adams/Solver, the spring-damper statement that your template-based
product creates, has the form:
SPRINGDAMPER/id, I=I_id, J=J_id
, K=K
, C=0
, LENGTH=OffsetCalc
, FORCE=0
, TRANSLATIONAL
About Nonlinear Springs
Your template-based product (using the Adams/Solver SFORCE) interpolates a force versus spring
length or spring deflection table using Akima's method.
If you are using a force versus length table, the force is calculated as follows:
Spring Force = AKISPL(OffsetCalc + DM(I, J), 0, Spline)
If you are using a force versus deflection table, the force is calculated as follows:
Spring Force = AKISPL(OffsetCalc - DM(I, J), 0, Spline)
where:
AKISPL - Adams/Solver function that interpolates data stored in a SPLINE.
OffsetCalc - Depends on the free length defined in the spring property file and in the spring install
methods.
Preload - The desired spring load at the current position of the I and J coordinate references.
Installed Length - The installed length of the spring at the current position of the I and J
coordinate references.
Use Hardpoints - The installed length of the spring equals the distance between the I and J
coordinate references.
When you submit the model to Adams/Solver, the SFORCE statement that your template-based product
creates, has the form:
SFORCE/id, I=I_id, J=J_id
, FUNCTION=AKISPL(OffsetCalc + DM(I_id, J_id), 0, Spline)\
, TRANSLATIONAL
About Spring Property Files
The spring component supports the following types of Property Files:
TeimOrbit linear-spring property files (extension .lsf).
TeimOrbit nonlinear-spring property files (extension .spr). Standard TeimOrbit nonlinear-spring
XML spring property file. The XML spring property file supports linear and nonlinear force
characteristics and allows you to choose between specifying force versus spring deflection or
spring length, as described in About Nonlinear Springs. You work with XML files in the Property
File Editor.
107
108 Adams/Car
trim height. trimLength is a positive real value read from the air-spring property file.
DM(marker I, marker J) - Is the distance between the upper and lower spring seats.
TrimLoad is the load in the spring when the suspension is at trim height. The load corresponds to
the trim load you specified, or, if you select auto trim load, it corresponds to a differential
equation.
From the Build menu, point to Forces, point to Damper, and then select Modify. To load the
parameters for a specific damper, you must specify the damper you want to modify.
Right-click a damper, point to its name, and then select Modify. The dialog box has the
Press F1 and then follow the instructions in the dialog box help for Create/Modify Damper.
Select OK.
109
110 Adams/Car
damping).
the parameters for a specific bumpstop, you must specify the bumpstop you want to modify.
Right-click a bumpstop, point to its name, and then select Modify. The dialog box has the
Press F1 and then follow the instructions in the dialog box help for Create/Modify Bumpstop.
Select OK.
Press F1 and then follow the instructions in the dialog box help for Modify Bumpstop.
Select OK.
The elastic force becomes active only when the instantaneous distance between the markers on the two
parts is less than the impact length. The impact length term depends on the distance type. If you select
Clearance, the impact length becomes:
dmCalc - Clearance
where:
Clearance - Value you specify
dmCalc - Initial displacement computed between the I and J markers
111
112 Adams/Car
In an XML bumpstop property file, you can also enable a damping characteristic. If you enable the
damping characteristic, the force is dependent on the deflection and velocity of the I and J markers.
Damping (viscous) forces can be:
linear - If you include in the property file a linear damping value other than zero, then the total
force exerted between the I and J parts is equal to the sum of the elastic force specified above and
the following damping force:
files correspond to nonlinear elastic forces with linear damping equal to 0 formulation.
XML bumpstop property file. The XML bumpstop property file enables data sharing with other
MSC.Software applications, such as Adams/Chassis, and allows greater flexibility and a wider
range of bumpstop formulation choices. In particular, the new XML bumpstop property file
supports various methods and options for the calculation of force characteristics, as explained in
Calculation of Force Characteristics. You work with XML files in the Property File Editor.
damping.)
113
114 Adams/Car
From the Build menu, point to Forces, point to Reboundstop, and then select Modify. To
load the parameters for a specific reboundstop, you must specify the reboundstop you want to
modify.
Right-click a reboundstop, point to its name, and then select Modify. The dialog box has the
Press F1 and then follow the instructions in the dialog box help for Create/Modify Reboundstop.
Select OK.
Force Calculation
The force in a rebound stop always acts to keep two parts from moving farther apart. The force is active
only when the distance between the parts as computed by dm(i,j) exceeds the impact length. You specify
the impact length directly or indirectly as the initial clearance in the rebound stop. When you specify a
clearance, the impact length is calculated from the clearance as follows:
dmCalc + Clearance
where:
Clearance is the value you specify
dmCalc is the initial displacement computed between the i and j markers
Further, the force in a rebound stop is the sum of an elastic force and a damping force. The XML property
file supports various options for calculating either force. The options available for calculating elastic
force (F elastic) are:
polynomial - The for calculated using a third-order polynomial. The Adams/Solver function
expression is:
deflection data.
The damping force always acts in opposition to the velocity. In an XML reboundstop property file, the
options for calculating damping force are:
linear - You specify the dampingRate, and the damping force is the product of dampingRate,
velocity, and a STEP function. The STEP function depends on the displacement in the rebound
stop and ensures the damping force is continous with displacement.
table of force vs. velocity. Again, a STEP function dependent on the displacement in the
rebound stop ensure that the damping force is continous with displacement.
property files correspond to nonlinear elastic forces with linear damping equal to 0 formulation.
115
116 Adams/Car
XML reboundstop property file - The XML reboundstop property file enables data sharing with
other MSC.Software applications, such as Adams/Chassis, and allows greater flexibility and a
wider range of reboundstop formulation choices. In particular, the new XML reboundstop
property file supports various methods and options for the calculation of force characteristics, as
explained in Calculation of Force Characteristics. You work with XML files in the Property File
Editor.
Adjustable Forces
An adjustable force is a special Template Builder user-defined element (UDE). You can use adjustable
forces for a variety of conditions, to satisfy static parameters in your model. For example, if you want to
set the length of a rod to be a specific length during static analysis, the adjustable force will vary until
the desired end condition is satisfied.
In Adams/Car for example, atypical application is to use an adjustable force to set toe and camber values
during a static suspension analysis. You might use two parts to define the tie rod and attach them by a
translational joint. You would then apply an adjustable force between the two parts to set toe and camber
values.
When the vehicle reaches static equilibrium without the use of adjustable forces, the toe and camber
alignments might not be the ones that you want. You use adjustable forces to define toe and camber
angles at static equilibrium position.
Adjustable forces act between two appropriate parts and perform a series of adjustments during static
equilibrium to minimize the error between the current computed toe/camber angle and the desired
toe/camber.
You might, for example, use two parts for the tie rod, constrain them using a translational joint, and then
apply an adjustable force between the two parts to set static toe angle. The current formulation creates a
single-component force that acts between the two parts. The force function uses stiffness and damping
values that you can set. The user-defined force uses a differential equation to minimize the error between
desired and computed angles.
117
118 Adams/Car
The _double_wishbone_torsion template distributed in the shared car database contains an example of
an adjustable force.
If more than one adjustable force is defined in a model, you must use the pattern statement within the
adjustable force definition. The pattern statement defines the order in which adjustable forces are active.
The following table defines four adjustable forces.
Adjustable force:
Pattern 1:
Pattern 2:
Pattern 3:
10
1010
10101010
10
1010
10101010
01
0101
01010101
01
0101
01010101
10
1010
10101010
10
1010
10101010
01
0101
01010101
01
0101
01010101
In Pattern 1, two separate static analyses would be run. In the first analysis, the toe adjustable forces
would be active. During the second analysis, the camber adjustable forces would be active. In Pattern 2,
four separate static analyses would be run and the same order as in Pattern 1 would be repeated. Because
the camber is directly affected by the toe change and the toe change is affected by the camber, it is often
desirable to build up patterns such that you can find a static solution by running a number of separate
static analysis. Pattern 3 is an example of eight separate static analyses.
Once the static analysis has been run, one of two things will happen depending on whether the lock with
motion was set for the adjustable force. For example, in Adams/Car an adjustable force might be created
between the tie rod inner and tie rod outer parts. If the adjustable force is locked with motion, then after
the statics is complete, Adams/Car will create a fixed joint between the two tie rod parts, fixing the
displacement between these parts for subsequent dynamic analyses. But if the adjustable force is not
locked, then the same force between the tie rod parts at the end of the static analysis will be maintained
during subsequent dynamic analyses.
In Standard Interface, to modify an adjustable force:
1. From the Adjust menu, select Adjustable Force.
2. Press F1 and then follow the instructions in the dialog box help for Modify Adjustable Force.
3. Select OK.
In Template Builder, to create or modify an adjustable force:
1. From the Build menu, point to Adjustable Force, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Adjustable
Force.
3. Select OK.
Gears
We provide two constraint-based gear options within the Template Builder:
Differential gear - The differential gear applies a reduction ratio between an input joint and the
symmetric output joint pair. The joint can be either revolute or cylindrical. The motion direction
can be inverted between the input and output joints and a toggle exists to switch between the two
different modes, allowing the reduction ratio to always be positive.
The reduction ratio is based on the following equation:
input motion = reduction ratio * (input shaft - output shaft)/2
You can define the differential gear to be kinematically active, allowing the element to be turned
on or off depending on the type of analysis you are running: compliant or kinematic.
Reduction gear - The reduction gear applies a reduction ratio between the input and output
joint. Either joint type can be translational, revolute, or cylindrical. Additionally, the motion
direction can be inverted between the input and output joints and a toggle exists to switch
between the two different modes, allowing the reduction ratio to always be positive.
When you enter a cylindrical joint in the input or output Joint text box, an additional text box
becomes active. Because either the rotational or translational degree of freedom of the cylindrical
joint can be used, you must specify if the rotational or translational motion will be the output for
the gear.
The reduction ratio is based on the following equation:
input motion = reduction_ratio * output motion
You can define the differential gear as being kinematically active, allowing the element to be turned on
or off depending on the type of analysis you are running: compliant or kinematic.
Note:
119
120 Adams/Car
Actuators
We provide several actuator options with the Template Builder. An actuator lets you define an element
that can apply a force or motion function to a collection of modeling components. For example, you
might want to create a motion on a valvetrain system, or steer a vehicle around a corner. These
components include joints and parts but are not limited only to these.
Learn more about actuators:
About Actuators
Joint-Force Actuators
Joint-Motion Actuators
Point-Point Actuators
Point-Torque Actuators
Variable Actuators
Set Function
Set Activity
About Actuators
When used with appropriate feedback channels, actuators provide a very powerful method to control
your system.
Actuators differ from adjustable forces due to their behavior during dynamic analyses, with actuators
remaining active, whereas adjustable forces are either locked in place or replaced by a fixed joint.
If you create actuators as a symmetrical pair, then you can define separate left and right functions. You
can use the Function Builder to define functions.
Each actuator can have an application area and an identifier. The application area provides information
about the intended purpose of the actuator. The identifier should be used to describe the actuator instance
for this application area. A typical example would be:
Application area = steering
Identifier = steering_wheel_angle (e.g. for a motion type
actuator)
These two additional parameters support a more dynamic use of actuators. For example, to allow de/activation and function assignment on the assembly level by adding additional means for browsing and
filtering. Note that they are currently not required by your template-based product.
You can define limits for each actuator in the same way that you would define limits in a test laboratory
to prevent damage caused by excessive actuator force or travel. Although you can define limits for force,
displacement, velocity, and acceleration, it is not required that you do so.
You can define the activity of the actuator as either active or not active. You can define the activity either
from the dialog box or from the menu option Set Activity located under the Actuators menu. Learn about
defining the activity.
Joint-Force Actuators
A joint-force actuator defines either a translational or rotational single-component force acting between
two parts that a user-defined joint connects. You can select three types of joints:
Revolute joint - Selecting a revolute joint causes the Template Builder to automatically switch
to rotational and disable the Type of Freedom option. The single-component force will be a
rotational force acting between the two bodies that the revolute joint connects.
automatically switch to translational and disable the Type of Freedom option. The singlecomponent force will be a translational force acting between the two bodies that the translation
joint connects.
Cylindrical joint - Selecting a cylindrical joint makes an additional text box active. Because
either the rotational or translational degree of freedom of the cylindrical joint can be used, you
must specify if the rotational or translational force will be used. This allows you to decide
between the creation of a torque or a force, based on the selection of either the rotational or
translational type of freedom.
Learn more about actuators, such as creating symmetrical pairs, using application area and identifier
attributes, and defining limits.
Point-Point Actuators
A point-point actuator defines an action-reaction translational single-component force acting between
the two parts that I Part and J Part parameters specify. You define the direction of the resulting force by
selecting the two points of force application, which can be either hardpoint or construction frame
locations.
Learn more about actuators, such as creating symmetrical pairs, using application area and identifier
attributes, and defining limits.
121
122 Adams/Car
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Point Point
Actuator.
3. Select OK.
Joint-Motion Actuators
A joint-motion actuator defines either a translational or rotational motion acting between two parts that
a user-defined joint connects. You can select three types of joints:
Revolute joint - Selecting a revolute joint causes the Template Builder to automatically switch
to rotational and disable the Type of Freedom option. The motion will be a rotational motion
acting between the two bodies that the revolute joint connects.
Translational joint - Selecting a translational joint causes the Template Builder to automatically
switch to translational and disable the Type of Freedom option. The motion will be a
translational motion acting between the two bodies that the translational joint connects.
Cylindrical joint - Selecting a cylindrical joint makes an additional text box active. Because
either the rotational or translational degree of freedom of the cylindrical joint can be used, you
must specify if the rotational or translational motion will be used. This allows you to decide
between the creation of a rotational or a translational motion based on selection of either the
rotational or translational type of freedom.
Learn more about actuators, such as creating symmetrical pairs, using application area and identifier
Point-Torque Actuators
A point-torque actuator defines an action-reaction or action-only rotational single-component torque
acting between the two parts that the I Part and J Part parameters specify. You define the direction of the
resulting torque within the dialog box. Many of the parametric functions discussed in Construction
Frames are available to define the position and orientation of the resulting actuator.
If you define the actuator as action only, then the J Part text box is disabled and no reaction is exerted.
Learn more about actuators, such as creating symmetrical pairs, using application area and identifier
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Point Torque
Actuator.
3. Select OK.
Variable Actuators
A variable actuator is a user-defined element consisting of a data element variable and a series of
additional elements, such as strings and arrays. A variable actuator can be particularly useful where
either parts or joints cannot be referenced. An example of a variable actuator is the velocity of a vehicle:
the function could define a changing velocity which is then referenced by several other modeling
components.
Learn more about actuators, such as creating symmetrical pairs, using application area and identifier
attributes, and defining limits.
Set Function
You can use the set function menu item to modify or replace the function that you defined.
You can use the Function Builder to define functions.
To set actuator function:
1. From the Build menu, point to Actuators, and then select Set Function.
2. Press F1 and then follow the instructions in the dialog box help for Actuator Set Function.
3. Select OK.
Set Activity
You can use the set activity menu option to set the actuator to be either active or not active. The not active
option is particularly useful when actuator elements are not required.
To set actuator activity:
1. From the Build menu, point to Actuators, and then select Set Activity.
2. Press F1 and then follow the instructions in the dialog box help for Actuator Set Activity.
3. Select OK.
123
124 Adams/Car
Condition Sensors
A condition sensor is a user-defined element that consists of a data element array and strings. It references
an existing variable class element (data element variable or measure solver computed), which is then tied
to the label and unit strings by the array. The array also encapsulates a request (for plotting convenience)
and a units conversion factor.
In essence, a condition sensor represents a relationship between a measurable solver quantity (the
variable class object) and a string label identifier that can be used in an event file (.xml) to define a
condition for Adams/Car full-vehicle analyses.
Use of Condition Sensors in Adams/Car
Adams/Car browses the assembly for condition sensor elements prior to each vehicle analysis and
updates the data element end_conditions_array with the derived list. At the beginning of the simulation,
the Standard Driver Interface (SDI) then uses the specified end condition measure string in the driver
control file to identify the associated variable class object in the dataset, that calculates the quantity the
end condition sensor should compare to the target value.
This architecture allows you to extend the provided set of standard end conditions. If, for example, a
ramp-steer like custom vehicle event should be ended when the turn radius falls short of a certain
threshold, you could:
add a variable class element to calculate the desired turn radius
variable name = .__MDI_SDI_TESTRIG.body_turn_radius
function = (vx2 + vy2)1.5 / (vx*ay - vy*ax)
add a condition sensor referencing the variable above
label = "radius"
variable = .__MDI_SDI_TESTRIG.body_turn_radius
units = length
Then, you could use this new condition sensor with the following line in your driver control file:
(END_CONDITIONS)
{measure test value allowed_error filter_time delay_time group}
'RADIUS' '|<' 20000.0 500.0 0.0 0.0
Creating or Modifying Condition Sensors
To create/modify condition sensors:
1. From the Build menu, point to Condition Sensors, and then select New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify Condition
Sensor.
3. Select OK.
Feedback Channels
A feedback channel is a special user-defined element that contains a series of entities such as
Adams/Solver measures and Adams/View variables. Creating a feedback channel effectively
corresponds to creating a measure (Adams/Solver variable). It is then possible to display the measure.
For information on creating, displaying, and managing strip charts based on measures, see the
Adams/View online help.
Feedback channels are used in the __MDI_SUSPENSION_TESTRIG for the controller. Your templatebased product creates two channels:
Raw_channel - Controls an absolute value.
Offset_channel - Controls desired inputs for a deviation.
125
126 Adams/Car
2. Press F1 and then follow the instructions in the dialog box help for Set Feedback Channel
Function.
Setting Offset
You can use the set offset menu to modify the offset applied to the raw measuredchannel. You can toggle
the activity of the offset on or off.
To set feedback channel offset:
1. From the Build menu, point to Feedback Channels, and then select Set Offset.
2. Press F1 and then follow the instructions in the dialog box help for Set Feedback Channel Offset.
General Parameters
The general parameter is an Adams/View variable whose real value is based on a value stored in a
property file data block. The property file must be in the neutral file format of your template-based
product. When your template-based product reads the property files, it updates the general parameter
variable entity with the appropriate real value stored in the property file. The data block and attribute
names in the Create General Parameter dialog box identify the data that is being accessed from the
property file.
Adams/Car uses a general parameter to model the piston area within a steering system. The steering
system includes a data block as follows:
$---------------------------------------------------GENERAL_PARAMETER
[GENERAL_PARAMETER]
USAGE = 'rack_piston_area'
SYMMETRY = 'single'
PROPERTY_FILE =
'mdids://acar_shared/steering_assists.tbl/mdi_steer_assist.ste'
DATA_BLOCK = 'STEERING_ASSIST'
ATTRIBUTE_NAME = 'piston_area'
The parameter DATA_BLOCK refers to the sub-block (steering_assist) in which the parameter can be
found. The USAGE keyword describes the name of the attribute whose value must be located. The
example below shows the data for the piston_area referenced above:
$----------------------------------------------------STEERING_ASSIST
[STEERING_ASSIST]
piston_area <area> = 490.87
In this case, the general parameter variable (rack_piston_area) is set to 490.87.
If your template-based product does not find the specified data blocks in the selected property file, then
it issues a warning and the general parameter retains its default value (0.0).
127
128 Adams/Car
General Splines
The general spline is a spline whose values are stored in a property file. The property file must be in the
neutral file format of your template-based product. This method of creating splines allows great
flexibility: you can define the splines in your model depending on the numerical content of the selected
property files. When your template-based product reads the property files, it updates the spline entities
with the appropriate referenced values stored in the property files. The data that is being accessed from
the property file is identified by the data block and data sub-block names in the Create General Spline
dialog box. This allows for a very quick and efficient way to modify your data, without manually
modifying the data within an Adams spline.
For example, you could store the boost curve characteristics of many different steering systems in
separate property files and then test different steering systems by referencing those property files. If your
template-based product does not find the specified data blocks in the selected property file, then it issues
a warning and the spline retains its default values.
You can also create a spline using the Build -> Data Element -> Spline menus.This spline differs from
the general spline in a couple of subtle different ways:
A data element spline stores its data within the template and does not reference an external data
file defined by the neutral file format (TeimOrbit). Therefore, simple changes in data require that
you manually manipulate this spline in the Template Builder.
Because you cannot make variations to the spline data within the standard user environment, you
cannot carry out what-if scenarios, which you can easily do with the general spline.
Adams/Car uses a generalspline to model steering characteristics. The steering subsystem includes a data
block as follows:
$----------------------------------------------------GENERAL_SPLINE
[GENERAL_SPLINE]
USAGE = 'steering_assist'
SYMMETRY = 'single'
TYPE = 'two_dimensional'
PROPERTY_FILE =
'mdids://acar_shared/steering_assists.tbl/mdi_steer_assist.ste'
CURVE_NAME = 'steering_assist'
(COMMENTS)
{comment_line}
'Example of a steering assist spline'
The parameter steering_assist then refers to a sub-block of information within your property file. When
your product reads the property file, it populates the general spline with the data. The following shows
the data block for the steering_assist spline:
$----------------------------------------------------STEERING_ASSIST
[STEERING_ASSIST]
piston_area <area> = 490.87
(XY_DATA)
{tbar_deflection <angle> delta_pressure <MPa>}
-3.00 -4.00
-2.20 -4.00
-1.80 -3.60
-1.50 -3.00
-1.00 -2.00
-0.50 -1.00
0.00 0.00
0.50 1.00
1.00 2.00
1.50 3.00
1.80 3.60
2.20 4.00
3.00 4.00
This mechanism lets you generate and use both 2D and 3D splines with data stored within your database
structure by simply selecting the property file that stores the data and defining the data block.
To create or modify a general spline:
1. From the Build menu, point to General Data Elements, point to Spline, and then select
New/Modify.
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify General Spline.
3. Select OK.
General Variables
The general variable is an Adams/Solver (data element) variable whose real value is stored in a property
file data block. The property file must be in the neutral file format of your template-based product. When
your template-based product reads the property files, it updates the general variable entity with the
appropriate real value stored in the property file. The data block and attribute names in the Create
General Variable dialog box identify the data that is being accessed from the property file.
The mechanism described for the general parameter is equally applicable to the general variable.
If your template-based product does not find the specified data blocks in the selected property file, then
it issues a warning and the general variable function retains its default value (0.0).
To create or modify a general variable:
1. From the Build menu, point to General Data Elements, point to Variable, and then select
New/Modify.
129
130 Adams/Car
2. Press F1 and then follow the instructions in the dialog box help for Create/Modify General
Variable.
3. Select OK.
Parameter Variables
You can use parameter variables to parameterize various elements and entities in your template-based
product. There are three types of parameter variables:
String - Does not contain units information, only a string value.
Integer - Does not contain units information, only an integer value.
Real - Can contain both a real value and a units specification.
Regardless of the parameter variable type, you can choose to hide the parameter variable from the
standard user. When you designate a parameter variable as hidden, the standard user will not be able to
access it using the Modify Parameter Variable dialog box in the Standard Interface.
Requests
You can use the Create Request dialog box to create a request statement and auxiliary variables used by
your template-based product. A request statement indicates a set of data you want Adams/Solver to
output in the request file (.req). You can explicitly do the following:
Output a set of displacements, velocities, accelerations, or forces with respect to existing
markers in your template. Learn about markers.
Define the generic request function
Use the user-written subroutine REQSUB to define nonstandard output. For information on user-
Data Elements
Data elements include arrays, curves, splines, matrices, and strings.
For information on data elements, see the Adams/View online help
System Elements
System elements let you create general differential and/or algebraic equations.
For information on system elements, see the Adams/View online help
Backlash Components
This component represents a backlash gap between two parts. In Adams/Driveline you can work with
two types of backlash components: rotational and translational backlash.
Learn about backlash:
Creating or Modifying Backlash
About Rotational Backlash
About Translational Backlash
Note:
In the Standard Interface, you can use the Driveline Activity Wizard to manage the activity of each
backlash element.
The backlash law is defined with a combination of ATAN functions to guarantee smoothness and
derivative continuity
2 Adams/Driveline
where:
T = Resulting torque
sharp = Sharpness factor of the backlash
a = Relative angles of the two markers defining the backlash force
lash = Backlash (in radians)
stiff = Stiffness of the gear-to-gear contact
damp = Damping of the gear-to-gear contact
The sharpness factor lets you control how sharp the transition is between the lash region with zero forces
and the stiff region.
In this model, the expression of the sharpness factor is as follows:
This means that the backlash needs some time to be fully developed with the steady-state value of Nx.
This device makes integration easier. Nx is the value you define in the Rotational Backlash
Create/Modify dialog box.
4 Adams/Driveline
In the Standard Interface, you can vary values for the following:
Backlash
Stiffness
Damping
Sharpness factor
Request Definition
Result name: backlash_states
Component:
Component
name:
Component
units:
Definition:
F2
displacement
angle
F3
angular_velocity
F4
force
force
Subsystem Parameters
Backlash flag
Backlash
Stiffness
Damping
Sharpness factor
Note:
In the Standard Interface, you can manage the activity of each backlash element using the
Activity Wizard.
The backlash law is defined with a combination of ATAN functions to guarantee smoothness and
derivatives continuity.
6 Adams/Driveline
where:
F= Resulting force
Sharp = Sharpness factor of the backlash
a = Relative displacement angles of the two markers defining the backlash force
lash = Backlash in mm
stiff = Stiffness of gear-to-gear contact
damp = Damping of the gear-to-gear contact
The sharpness factor lets you control how sharp the transition is between the lash region with zero forces
and the stiff region.
In this model, the expression of the sharpness factor has been defined as follows:
This means that the backlash needs some time to be fully developed with the steady-state value of Nx.
This device makes integration easier. Nx is the value you select in the appropriate dialog box.
Sharpness Factor Development Time
8 Adams/Driveline
In the Standard Interface, you can vary values for the following:
Backlash
Stiffness
Damping
Sharpness factor
Request Definition
Result name: backlash_states
Component:
Componen Component
t name:
units:
F2
displacement length
F3
velocity
velocity
F4
force
force
Subsystem Parameters
Backlash flag
Backlash
Stiffness
Damping
Sharpness factor
Definition:
10 Adams/Driveline
Bearings
A bearing component describes a force-based connection between two parts. Adams/Driveline models a
bearing with a six-component force and allows the two parts to rotate around the z-axis. Adams/Driveline
also models all contact forces and drag. You can specify both radial and axial backlash for the bearing.
Learn about bearings:
Creating or Modifying Bearings
About Bearings
Modeling Bearings
Example Bearing Property File
About Bearings
In Adams/Driveline you can create two types of bearings:
Axial
Tapered
The driveline bearing formulation is based on values obtained from the Timken Company manual (for
free online resources register at http://www.timken.com/timken_ols/bearings/). The running torque
equations are for bearings whose torque has stabilized after a period of running under operating
conditions, so called a "running" bearing. The equations apply to bearings lubricated with circulating oil
or oil level systems. You can use the equations to model all single-row bearing loading conditions.
The component consists of the following objects:
A general force component featuring the actions and reactions between the inner and outer ring
of the bearing.
A request to output force and torque values.
Two revolution geometries to visualize the rings. The component creates these geometries on the
11
Component:
Component
name:
Component
units:
F2
dx
length
F3
dy
length
F4
dz
length
F6
ax
angle
F7
ay
angle
F8
az
angle
Definition:
Component:
Component
name:
F2
vx
velocity
F3
vy
velocity
F4
vz
velocity
F6
wx
angular velocity
F7
wy
angular velocity
F8
wz
angular velocity
Component
units:
Definition:
12 Adams/Driveline
Component:
Component
name:
Component
units:
Definition:
F2
fx
force
F3
fy
force
F4
fz
force
F6
tx
torque
F7
ty
torque
F8
tz
torque
Adams/Driveline calculates the force and torque for the bearing using backlash expressions. The force
or torque is almost zero until the relative translational or angular displacement is lower than the specified
lash, then the force or torque follows an elastic law.
For tapered roller bearings, the thrust force acts only along one direction (z-positive), being zero along
the other.
The reaction forces in the three translational directions are defined with a linear stiffness + backlash. The
two cardanic reaction torques are calculated based on the translational forces and the geometric
properties (bearing diameter). Learn about the rotational backlash formulation.
To calculate the running torque of the bearing, depending on several factors (bearing geometry, applied
loads, load zone, speed of rotation, and so on) the following expressions have been used:
Radial load or combined radial thrust load:
where:
T = Running torque
13
function of (K*Fa)/(Fr).
Fr = Radial load
Fa = Thrust road
Request Definition
Component:
Component
name:
Component
units:
Definition:
F2
angle
angle
F3
angular_velocity
F4
torque
torque
Modeling Bearings
In Adams/Car and Adams/Driveline you can model bearings in different ways, according to the effects
you want to observe in your models.
If, for example, you want to model a shaft with two bearings, the simplest solution is to connect the shaft
to the case with a revolute joint. The revolute joint is an ideal constraint that removes five degrees of
freedom. With this solution, compliance and drag effects are ignored. In addition, reaction forces on the
revolute joint are not comparable with the reaction forces you experience in a physical model.
A second solution is provided with a combination of kinematic joints: an inline primitive joint and a
spherical joint. The inline acts as a pure radial bearing (ideal) and the spherical joint as a combined radial
and axial bearing. This solution still does not take into account compliance and drag effects but provides
meaningful reaction forces.
When you want to model the connection between shaft and case, taking into account the compliance
effects, you can use the standard Adams/Car bushing element. You can define the radial and axial
stiffnesses using force versus displacement characteristics, and approximate the drag effects with a
constant rotational damping.
14 Adams/Driveline
The Adams/Driveline bearing component allows you to specify, in the three translational directions, a
linear stiffness with backlash effects. It also allows you to specify the same for the torques in the x and y
direction, while the torque along the z (spin) direction is computed based on values obtained from the
Timken Company manual (for free online resources register at
http://www.timken.com/timken_ols/bearings/). You can use the current implementation to model all
single-row bearing loading conditions, except for the pure thrust load (that means radial or combined
radial and thrust load bearing).
15
Chains
This component describes a simplified chain model in its global behavior. This component does not
model chain parts. It does, however, model the global behavior of the chain, which is a torsional load and
a longitudinal force (tension).
Learn about chains:
Creating or Modifying Chains
About Chains
About Chains
A chain describes a force-based connection between two sprockets. In Adams/Driveline you create a
simple chain model in which no chain links are modeled. Adams/Driveline models torsional and
translational loads in the chain with a rotational spring damper and a single-component force.
If you want to take into account the backlash effect, you can connect each sprocket to the respective shaft
with a rotational backlash component.
If you want to have a transmission ratio different from 1:1, you can connect the output sprocket to
another part with a kinematic gear component.
Adams/Driveline creates the following forces between the input and the output sprocket:
A rotational spring damper (acting between CM marker of the input sprocket and the CM
The reason why a rotational spring damper is used instead of a coupler is so that chain
elastic characteristics can be taken into account.
A translational single-component force (acting between driving sprocket and driven sprocket).
16 Adams/Driveline
If you decide to use the gear geometry (revolution) for sprockets, the radius will be deduced from that
component. Otherwise, you will have to enter the value in the create/modify dialog box.
In the Standard Interface, you can vary values for the following:
Rotational stiffness
Rotational damping
Sprocket radius (in case gear geometry has not been used)
Subsystem Parameters
Stiffness
Damping
17
Churning-Drag Forces
The churning-drag force component allows you to model the oil resistance acting on gears when they
rotate in oil. A churning drag describes a force-based component that models the oil resistance that forms
between gears and the gearbox case as soon as gears have a relative angular velocity with respect to the
gearbox case.
Learn about churning-drag components:
Creating or Modifying Churning-Drag Forces
About Churning-Drag Forces
In the Standard Interface, you can vary values for the following:
Constant
Breadth
Viscosity
Damping
18 Adams/Driveline
Component:
Component
name:
Component
units:
angle
Definition:
F2
angular
displacement
F3
angular_velocity angular velocity The relative velocity between the two parts
connected with the churning drag component.
F4
torque
torque
19
Clutch Connectors
This component allows you use the clutch connector in the driveline model. A property file stored in the
database determines the clutch connector characteristics. The component consists of a torque acting
between the two selected parts with the location and the orientation determined by a specified
construction frame.
Learn about clutch connectors:
Creating or Modifying Clutch Connectors
About Clutch Connectors
20 Adams/Driveline
Request Definition
Result name: torque_cvtr_variables
Component:
Component
name:
Component
units:
Definition:
F2
angle
angle
F3
angular velocity
angular velocity
F4
torque
torque
Subsystem Parameters
Property file (<db_name>/clutch_connectors.tbl)
21
Clutch Forces
This component represents contact forces in a clutch component. It models normal contact forces, as well
as friction forces.
Learn about clutch forces:
Creating or Modifying Clutch Forces
About Clutch Forces
Example Clutch-Force Property File
22 Adams/Driveline
23
Complex Springs
This component represents a complex rotational spring with hysteresis. You can use it to model rotational
springs in clutch friction disks, as well as any other connection in which a rotational spring damper with
hysteresis is needed.
Learn about complex springs:
Creating or Modifying Complex Springs
About Complex Springs
Calculation of Complex Spring Force
Example Complex-Spring Property File
24 Adams/Driveline
1)
unload_step = step5(WZ,- TRANSITION_VELOCITY, 1, TRANSITION_VELOCITY/2, 0)
load_spline = akispl(AZ,load_spline, 0)
unload_spline = akispl(AZ,unload_spline, 0)
When hysteresis_activity is set to off (0), the spring acts as a nonlinear torsion spring with viscous
damping, and only the first spline is used.
Note that you can also model torsion spring with hysteresis (and it's easier to define its parameters) using
the torsion spring.
25
26 Adams/Driveline
27
Component:
Component
name:
Component
units:
Definition:
F2
angle
angle
F3
Angular_velocity
angular velocity
F6
Clutch_pressure
pressure
F7
capacity
torque
F7
capacity
torque
Subsystem Parameters
Property file (<db_name>/clutch_forces.tbl)
28 Adams/Driveline
Gear Forces
This component represents a gear couple. You can use it to model Spur Gears and Bevel Gears.
Learn about gear forces:
Creating or Modifying Gear Forces
About Gear Forces
Adams/Driveline calculates the forces and torques between the gears using a user-defined general force,
whose action depends on the gear type.
To get reaction forces in the right direction, you must identify the orientation of the construction frames
used to define the gear forces. The following figure shows how construction frames must be oriented.
Notice that:
The z-axis must be oriented along the rotation axis
The x-axis has to point to the contact point
The y-axis is located based on the x- and z-axes
29
Parameter:
Description:
Gear type
Spur, bevel
Gear diameters
Backlash
Stiffness
Damping
Sharpness factor
Pressure angle a
--
Adams/Driveline calculates the transmitted torque for the gears using a backlash expression. (Torque is
almost zero until the relative angular displacement, scaled by gear ratio, is lower than the specified lash,
then the torque follows an elastic law.) Learn about rotational backlash.
The other torque and force components (radial and thrust) are derived from the transmitted torque
expression and from the gear type.
Spur Gears
From the transmitted torque, Adams/Driveline calculates the radial forces as follows:
30 Adams/Driveline
where:
Tz = Transmitted torque
Rp = Gear primitive radius
= Pressure angle
Bevel Gears
From the transmitted torque, Adams/Driveline evaluates the radial and thrust forces expressions as
follows:
where:
Fx = Radial load
Fz = Thrust load
= Gear ratio
31
Gear Pairs
This component represents a connection between two gears on two different shafts, according to a gear
ratio and a specified rotational backlash. To create a gear pair, input and output shafts, and input and
output gears must exist. A coupler element constrains the rotation of the output gear to the input gear.
Learn about gear pairs:
Creating or Modifying Gear Pairs
About Gear Pairs
Note:
The dummy part is required to allow proper behavior of the mechanism. Adams/Driveline creates the
part representing the mesh carrier within the UDE instance. It is used to effectively define the connection
of the input gear to the output gear via coupler element. Without the mesh carrier part, a rigidly connected
input gear would not produce any rotation of the output gear with respect to the output shaft.
32 Adams/Driveline
You can select the initial configuration of the synchronizing mechanism by choosing one of the following
options:
Input gear connected to input shaft (input gear perpendicular JPRIM is active)
Output gear connected to output shaft (output gear perpendicular JPRIM is active)
In the Standard Interface, you can vary values for the following:
Reduction ratio, in case it was not parameterized on the gear revolution geometries
Gear pair configuration
Output-to-input direction
Backlash
Stiffness
Damping
Sharpness factor
Ratio
Request Definition
Result name: gear_states_1 (input gear/shaft) and gear_states_2 (output gear/shaft)
33
Gear Parameters
Component:
Component
name:
Component
units:
angle
Definition:
F2
angle
F3
angular_velocity angular velocity The relative velocity between the two parts
(gear and shaft).
F4
torque
torque
34 Adams/Driveline
35
The forces exchanged between ring gear and pinion gear at the mesh point can be evaluated as shown in
the following tables.
36 Adams/Driveline
Axial force:
Separating force:
PINION
GEAR
Axial force:
PINION
GEAR
Separating force:
37
x, y, z
p,
p, g
= Pressure angle
p, g
Ap, Ag
Rp, Rg
z'
Adams/Driveline implements the component with general forces using, as reference, frame markers
positioned at the gear mesh point. It calculates the location and orientation of these reference markers
into the component using data you provide.
The following figure shows how you must orient reference frames for a correct evaluation of gear forces
38 Adams/Driveline
You must create the case reference frame on the intersection of the z-axis of the pinion reference frame
and the z-axis of the ring reference frame. Adams/Driveline uses the case reference frame to locate the
marker at the gear contact point.
In the Template Builder, you can specify the parameters as shown next.
Hypoid Gear Parameters
Parameter:
Description:
Pinion reference frame At pinion gear joint location, z-axis pointing towards pinion apex
Ring reference frame
39
Parameter:
Description:
Stiffness
Damping
Differential location
Front or rear
Property file
Stores the hypoid gear properties (see Hypoid Gear Example Property File).
PINION_N_OF_TEETH
PRESSURE_ANGLE
PINION_OFFSET
PINION_MEAN_CONE_DISTANCE
PINION_PITCH_ANGLE
PINION_MEAN_SPIRAL_ANGLE
RING_N_OF_TEETH
RING_MEAN_CONE_DISTANCE
RING_PITCH_ANGLE
RING_MEAN_SPIRAL_ANGLE
RING_OFFSET_ANGLE
RING_FACE_WIDTH
RING_PITCH_APEX
40 Adams/Driveline
PINION_MEAN_SPIRAL_ANGLE
= 48.533
RING_N_OF_TEETH
= 43
RING_MEAN_CONE_DISTANCE
= 102.0572
RING_PITCH_ANGLE
= 68.5333
RING_MEAN_SPIRAL_ANGLE
= 27.20
RING_OFFSET_ANGLE
= 20.0667
RING_FACE_WIDTH
= 32.512
RING_PITCH_APEX
= 3.556
41
torque is transferred from one side to the other if one wheel starts to spin. During the simulation,
as soon as one wheel start to spin the torque applied at that wheel decreases and is transferred to
the other wheel. The sum of torques applied at both wheels is kept constant and equal to the
torque exerted by the engine.
Clutch-pack - You can simulate the behavior of a clutch device which prevents one wheel from
spinning. Input parameters are friction coefficient, friction arm, preload, ramp angle of the gear,
side gear radius, and the revolute joints between side gears and the differential casing. This
component can evaluate thrust forces due to gear contacts, and can use these forces to calculate
the friction forces in the clutch.
Torque-sensing - You must specify the bias ratio and the torque threshold at which the
differential starts acting as a torque-sensing differential. You can also use the Adams variable,
which defines the input torque, as additional input. (In some cases, this variable is replaced by
the input communicator pointing to an Adams variable defined in another subsystem.)
The expression of the additional torque is as follows:
Dtorque = Input Torque * Scale * STEP(ABS(Dw),0,0,10,1)*
STEP(Input Torque, 0, 0, Torque Threshold, 1)
where:
Scale = 0.5 * (bias -1) / (bias + 1)
42 Adams/Driveline
You can deactivate the limited slip differential using the Adams/Driveline Activity Wizard.
In the Standard Interface, you can vary values for the following:
Property file (for viscous-sensing limited slip differentials)
Friction (for clutch-pack limited slip differentials)
Friction arm (for clutch-pack limited slip differentials)
Preload (for clutch-pack limited slip differentials)
Ramp (for clutch-pack limited slip differentials)
Side gear radius (for clutch-pack limited slip differentials)
Bias ratio (for torque-sensing limited slip differentials)
Torque threshold (for torque-sensing limited slip differentials)
Request Definition
Result name: lim_slip_diff_states
Component
name:
Component:
Component
units:
Definition:
F2
F3
right angular velocity angular velocity The angular velocity of the right side gear.
F4
left force
torque
F6
right force
torque
Subsystem Parameters
Type
Property file
Bias ratio
Torque threshold
43
Planetary Gears
This component represents a planetary gear.
Learn about planetary gears:
Creating or Modifying Planetary Gears
About Planetary Gears
44 Adams/Driveline
Therefore, using the Willis formula, we can determine that the coupler factors are:
sun number of teeth -> applied to the sun joint
(sun number of teeth + ring number of teeth) -> applied to the carrier joint
ring number of teeth -> applied to the ring joint
In the Standard Interface you can vary the property file.
Request Definition
Result name: request1
Component:
Component
name:
Component
units:
F2
Sun_rpm
F3
Ring_rpm
F4
Carrier_rpm
Definition:
Component:
Component
name:
Component
units:
F2
Sun_backlash
F3
Ring_backlash angle
F6
Sun_torque
torque
F7
Ring_torque
torque
angle
Subsystem Parameters
Property file (<db_name>/torque_converters.tbl)
Definition:
Angular lash between sun and sun lash parts.
45
Ravigneaux Gears
This component represents a ravigneaux gear.
Learn about ravigneaux gears:
Creating or Modifying Ravineaux Gears
About Ravigneaux Gears
46 Adams/Driveline
where r1, r2, and r3 are the scale factors for the three joints, and for each joint, q1, q2, and q3 are
rotational displacements of the joint I marker with respect to the joint J marker.
Therefore, using the Willis formula, we can determine that the coupler factors are:
COUPLER 1 (sp_planetary_gear_ratios), acting between sp sun lash joint, carrier joint and ring lash
joint:
Sp sun number of teeth -> applied to the sun joint
(- sp sun number of teeth + ring number of teeth) -> applied to the carrier joint
- ring number of teeth -> applied to the ring joint
COUPLER 2 (lp_planetary_gear_ratios), acting between lp sun lash joint, carrier joint, and ring lash
joint:
lp sun number of teeth -> applied to the sun joint
- (lp sun number of teeth + ring number of teeth) -> applied to the carrier joint
ring number of teeth -> applied to the ring joint
In the Standard Interface you can vary the property file.
Request Definition
Result name: request1
Component:
Component
name:
F2
Sp_Sun_rpm
F3
LP_sun_rpm
F4
Ring_rpm
F6
Carrier_rpm
Component
units:
Definition:
47
Component:
Component
name:
Component
units:
Definition:
F2
Sp_Sun_backlash
angle
F3
Lp_Sun_backlash
angle
F4
Ring_backlash
angle
F6
SP_Sun_torque
torque
F7
LP_Sun_torque
torque
F8
ring_torque
torque
Subsystem Parameters
Property file (<db_name>/torque_converters.tbl)
48 Adams/Driveline
Ride Wheels
The tire component consists of a rim and a ring.
Learn about ride wheels:
Creating or Modifying Ride Wheels
About Ride Wheels
Example Ride-Wheel Property File
The friction coefficient is calculated using the tire slip and the spline defining the dependency of the
friction on the tire slip (see figure Friction-Slip Function). The calculation follows:m = AKISPL(slip,0,
friction_spline) * friction_var
49
where:
slip = tire slip
friction_var = friction scaling function. This value is used to scale to the original friction spline, defined
for a maximum friction coefficient of 1.
Friction_var is defined using an adams_variable and can be defined to change either as a function of time
or traveled distance.
For example, if you want to have the friction on the front left tire go down to 0.5 at time = 1 sec and then
back to 1 at time = 2.5 with a transition time of 0.5 seconds, the expression for front left friction_var is
as follows:
STEP(TIME,1,1,1,5,0.5) + STEP(TIME, 2, 2.5, 0, 0.5)
You can set this dependency using a specific dialog box from the Adams/Driveline Standard Interface,
prior to submitting the . This dialog box allows you to set any kind of expression for the friction
coefficient, for an expression similar to the one explained above. You also have the graphical support
that gives you feedback on the shape of function you are using.
To access the dialog box, from the Simulate menu, point to Full-Vehicle Analysis, point to
Environmental Conditions, and then select Road Friction.
An Adams variable named traveled_distance automatically evaluates the distance traveled by the fullvehicle model. If friction has to be defined as a function of the traveled distance, the expression could be
something like:
STEP(VARVAL(traveled_distance),1,1,1,5,0.5) + STEP(VARVAL(traveled_distance), 2, 2.5, 0, 0.5)
50 Adams/Driveline
Friction-Slip Function
Adams/Driveline evaluates the tire slip according to the following formula (note that slip will be always
between -1 and 1):
slip = MAX(MIN((V - wr)/ABS(v), 1), -1)
where:
V = longitudinal speed of the car
w = rotational velocity of the wheel
r = loaded radius of the wheel (DZ(rim_cm, road))
Note that the reason why the ring part is connected to the road instead of the ground is because this
modeling technique allows you to put vertical and longitudinal actuators between the road and the
ground. This makes it possible to apply imposed motions to the full-vehicle model, such as known road
profiles or frequency sweep profiles.
The interposition of a rotational spring damper between the rim and the ring part is very important for
those analyses in which it is important to capture natural frequencies of the tire, such obstacle-passing
maneuver or tip in - tip out analyses.
51
Request Definition
Component:
Component
name:
Component
units:
Definition:
F2
Longitudinal slip
none
F3
Omega
RPM
F4
Traction
force
F6
Vertical force
force
Subsystem Parameters
Property file
52 Adams/Driveline
$------------------------------------------------FRICTION_vs_SLIP
[FRICTION_vs_SLIP]
{ slip_speed friction }
-1.0 -0.6508
-0.95 -0.6624
-0.91 -0.6799
-0.87 -0.6945
-0.83 -0.7061
-0.79 -0.7265
-0.75 -0.7497
-0.7 -0.7673
-0.666 -0.7847
-0.62 -0.8021
-0.58 -0.8168
-0.54 -0.8312
-0.5 -0.8487
-0.45 -0.8662
-0.41 -0.8837
-0.375 -0.9012
-0.33 -0.9274
-0.29 -0.9477
-0.25 -0.9639
-0.2 -0.9869
-0.166 -0.9927
-0.125 -1.0007
-8.0E-02 -0.9777
-4.0E-02 -0.8092
0.0 0.0
4.0E-02 0.8092
8.0E-02 0.9777
0.125 1.0007
0.166 0.9927
0.2 0.9869
0.25 0.9639
0.29 0.9477
0.33 0.9274
0.375 0.9012
0.41 0.8837
0.45 0.8662
0.5 0.8487
0.54 0.8312
0.58 0.8168
0.62 0.8021
0.666 0.7847
0.7 0.7673
0.75 0.7497
0.79 0.7265
0.83 0.7061
0.87 0.6945
0.91 0.6799
0.95 0.6624
1.0 0.6508
53
Torque Converters
This component allows you to define a torque converter in the driveline model.
Learn about torque converters:
Creating or Modifying Torque Converters
About Torque Converters
Example Torque-Converter Property File
These forces are defined according to the content of the property file you specify.
The property file stores two curves:
Torque ratio versus RPM ratio
Capacity factor versus RPM ratio
The following figures show sample plots for these two curves.
54 Adams/Driveline
Torque Ratio
Capacity Factor
The torque converter also includes a clutch part that is connected to the turbine with a torsion spring. The
clutch allows the direct engagement of the impeller to the turbine when the torque converter change-over
point is reached. You can define the clutch expression by either specifying the change-over point (so the
speed ratio at which the clutch must be engaged) or a clutch expression as a function of time.
Adams/Driveline uses the following formulas to evaluate action and reaction torque:
55
Component:
Component
name:
Component
units:
Definition:
F2
impeller_rpm
angular velocity
F3
turbine_rpm
angular velocity
F4
conv_clutch_rpm
angular velocity
F6
speed_ratio
no units
56 Adams/Driveline
Component:
Component
name:
Component
units:
Definition:
F2
impeller_drag
torque
F3
turbine_torque
angular velocity
F4
conv_clutch
angular velocity
F6
Capacity_factor
F8
Torque Ratio
no units
Subsystem Parameters
Property file (<db_name>/torque_converters.tbl)
57
1.0 0.0
$--------------------------------------------------IMPELLER_TORQUE
[IMPELLER_TORQUE]
(Z_DATA)
{ impeller_rpm <rpm>}
0.0
1000
1500
2000
2500
(XY_DATA)
{ rpm_ratio <rpm> impeller_torque <Nmm>}
0.0 0.0 1e4 1e4 1e4 1e4
0.1 0.0 9000 9000 9000 9000
0.2 0.0 8000 8000 8000 8000
0.3 0.0 7000 7000 7000 7000
0.4 0.0 6000 6000 6000 6000
0.5 0.0 5000 5000 5000 5000
0.6 0.0 4000 4000 4000 4000
0.7 0.0 3000 3000 3000 3000
0.8 0.0 2000 2000 2000 2000
0.9 0.0 1000 1000 1000 1000
1.0 0.0 900 900 900 900
58 Adams/Driveline
Torsion Springs
This component represents a simple torsional spring-damper connector. A torsion spring describes a
rotational connection between two parts. Adams/Driveline models the torsion spring with a singlecomponent force that works with the relative angular displacement and the relative angular velocity.
Adams/Driveline creates a revolute joint between the I and J parts.
Learn about torsion springs:
Creating or Modifying Torsion Springs
About Torsion Springs
Note:
59
Note:
The following applies to those using these components for shaft elasticity: In the
create/modify dialog box in the Template Builder and in the modify dialog box in the
Standard Interface (learn about the interface modes), you can access an additional dialog
box that helps you select "first attempt" values for Stiffness and Damping based upon the
material, length, and section type of the shaft. This option can be very useful in early stage
studies in which adequate data are not yet available.
In the Standard Interface, you can vary values for torsional stiffness and damping.
Request Definition
Result name: vcoupling_states
Component:
Component
name:
Component
units:
Definition:
F2
angular
displacement
angle
F3
angular velocity
velocity
F4
torque
force
Subsystem Parameters
Stiffness
Damping
60 Adams/Driveline
Unbalanced Mass
This component describes an unbalanced mass by its unbalanced momentum.
Learn about unbalanced mass:
Creating or Modifying Unbalanced Mass
About Unbalanced Mass
Viscous Coupling
This component represents viscous coupling. A property file determines the viscous characteristics. The
component consists of a rotational force acting between the two parts with the location and orientation
determined by the selected construction frame. A viscous coupling describes a force-based connection
between two parts. A viscous coupling exerts a torque whenever the relative angular velocity between
two parts exceeds a certain value. When the relative angular velocity is zero, no torque is transmitted.
Learn about viscous coupling:
Creating or Modifying Viscous-Coupling Components
About Viscous-Coupling Components
Example Viscous-Coupling Property File
61
In steady state conditions, equal velocities of the two half shafts produce a 0.0 torque.
In the Standard Interface, you can vary values for the property file, which effectively determines the
torque/slip-speed characteristic.
Request Definition
Result name: vcoupling_states
Component:
Component
name:
Component
units:
Definition:
F2
angular
displacement
angle
F3
velocity
velocity
F4
force
force
62 Adams/Driveline
Subsystem Parameters
Property file (<db_name>/differentials.tbl) (see Viscous Coupling Example Property File)
2 Adams/Driveline
Running Analyses
2 Adams/Driveline
Overview of Analyses
Adams/Driveline allows you to create virtual prototypes of vehicle subsystems, and analyze the virtual
prototypes much like you would analyze the physical prototypes.
Adams/Driveline lets you analyze virtual prototypes of full vehicles. Using Adams/Driveline, you can:
Easily modify the geometry and the properties of the components of your subsystems.
Select from a standard set of vehicle maneuvers to evaluate the dynamic characteristics of your
virtual prototype.
View the vehicle states and other characteristics through plots.
assembly that contains the appropriate components, or subsystems, that make up the prototype.
For example, you create a suspension assembly containing suspension and steering subsystems.
The kind of analysis you'd 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 fullvehicle.
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/Driveline, 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 can modify
the prototype and analyze it again to see if your modifications improved its behavior.
Each kind of analysis that you perform requires a minimum set of subsystems. For example, 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/Driveline, you must open or create the minimum set of subsystems required.
(Standard Interface) Simulate -> Full-Vehicle Analysis -> Driveline Tests -> Bench Test
3
Running Analyses
Bench-Test Analysis
Performs a bench-test analysis.
Do the following:
Assembly
Select the assembly you want to analyze. The menu lists all open
assemblies.
Output Prefix
Enter a string that specifies the analysis output name. The string can
contain only alphanumeric characters and underscores (_).
Adams/Driveline appends the suffix _bench to form the complete
analysis name. For example, if you enter test45 as the output prefix, the
analysis name becomes test45_bench.
End Time
Enter a number greater than zero to specify the duration of the simulation.
Number of Steps
Enter the number of output steps in output files (.req, .gra). It affects the
resolution of your animations and plots. Make sure that the number of
steps you specify is high enough to display the highest frequency you
want to observe.
Mode of Simulation
Specify a road data file. Tire subsystems use the information in road data
files to calculate the tire/ground interaction forces. If your model uses ride
tire subsystems, Adams/Driveline automatically deactivates this text box
because tire/ground interaction forces are evaluated in a different way.
For more information about road data files, see the Adams/Tire online
help.
4 Adams/Driveline
Do the following:
Enter the initial velocity of the car at the beginning of the simulation. You
can enter any number greater than or equal to zero. Adams/Driveline uses
this value to run an initial velocity analysis just after the static equilibrium
and to set all rotational velocities of the driveline.
In the text box to the right of Initial Velocity, select the most suitable units
set for the initial velocity. Before performing the analysis,
Adams/Driveline automatically converts the model units to the specified
units set.
5
Running Analyses
Do the following:
Select the initial gear to be used during the simulation. Adams/Driveline
sets the transmission_demand in the test rig to the value you specify.
If the model you want to analyze contains gear-pair elements, then
Adams/Driveline engages the correct one to both the input and output
shafts with kinematic joints.
6 Adams/Driveline
7
Running Analyses
If your assembly does not use a subsystem with initial condition motions,
Adams/Driveline informs you that there are no IC motions in your template. Select
OK, and the Driveline IC Motions Status dialog box opens.
4. Select Close.
Adams/Driveline skips the deactivated point motions from the group called lock array, and
ignores them during the initial velocity analysis.
8 Adams/Driveline
as a wheel part; therefore, no initial rotational velocity will be given to the tires. In this case, you
must manually add an initial rotational velocity to the wheel part. If you use Adams/Driveline
ride tires, the initial rotational velocity of the wheels is set automatically when the tires are
created.
If you build a model with standard Adams/Car components, Adams/Driveline will not
automatically create the ic_motion. You can create the ic_motion in the Template Builder by
selecting the Driveline Components menu, pointing to Advanced, and then selecting IC Motions
Create.
Currently, the procedure of setting initial rotational velocity only works for Adams/Driveline-
specific analyses. This is due to the specific set-up macro being called from a submit macro.
9
Running Analyses
If you manually specify initial rotational velocity on two parts that are constrained to each other,
Adams/Driveline will calculate the average initial rotational velocity and use it for both parts
(and all parts constrained to them).
If you are driving the model with a motion active during the initial condition analysis, the
motion velocity will overwrite all initial rotational velocities set on parts constrained by the
motion.
10 Adams/Driveline
11
Running Analyses
12 Adams/Driveline
13
Running Analyses
14 Adams/Driveline
15
Running Analyses
16 Adams/Driveline
17
Running Analyses
18 Adams/Driveline
19
Running Analyses
Examples
Getting Started Using Adams/Driveline
Example Files:
Example Bearing Property File
Example Clutch-Force Property File
Example Complex-Spring Property File
Engine Map Property File
Example Hypoid Gear-Forces Property File
Example Ride-Wheel Property File
Example Torque-Converter Property File
Example Viscous-Coupling Property File
20 Adams/Driveline
Reviewing Results
206 Adams/Car
Requests
Requests contain standard displacement, velocity, acceleration, or force information that can help you
investigate the results of simulations. You can also define other quantities (such as pressure, work,
energy, momentum, and more) that you want output during a simulation.
Adams stores the requests in request files (.req).
Reviewing Results
For more examples, investigate templates in the shared database that have the group
kinematic_mode_active, which is used for the Kinematic Mode option.
Request 907
Request 907 (req907) outputs displacement, velocity, accelerations, and body side-slip angle depending
on the value of par(2) in the parameter list. Req907 is compatible with both dynamic and steady-state
type analyses.
The definition of the parameters array and the resulting output is:
par(1) = Branch Flag 907
par(2) = Request Type:
0 = Displacement(Angles in radians)
1 = Velocities
(Translational vel. in KPH)
(Angular velocity in radians/s)
2 = Accelerations
(Translational acc. G's)
(Rotational acc. in radians/s/2)
3 = Body Side Slip Angle in Radians
par(3) = id I marker
par(4) = id J marker
par(5) = id RM marker
Any results with a magnitude less than 1e-7 are set to zero.
207
208 Adams/Car
The files currently support only one plot per page, which can contain multiple axes. You can cross-plot
multiple analyses of the same type using one plot configuration file.
Plot configuration files are TeimOrbit files and are stored in your database in the plot_configs.tbl
directory.
You can access the plot configuration file functionality in Adams/PostProcessor. Learn about creating a
plot configuration file through the interface. Learn about using plot configuration files.
Note:
To modify plots and curves, you can use the command statement in each block to invoke
macros, which must contain the modification commands. The macros must be contained in
your current binary file, which can be either private or site.
Reviewing Results
you can have your template-based product invoke the macro that contains a command keyword in its
user-entered command.
The plot configuration file specifies a subtitle for your plots. In addition, in the File Import dialog box
you can:
Add a title to all the plots.
Plot results of multiple analyses on one plot using the Cross Plotting option.
Change the look of your plot, such as fonts and size, using the option Execute Custom Macros.
To use this option, you must have a macro that defines the commands to be executed.
209
210 Adams/Car
3. From the File menu, point to Export, and then select Plot Configuration File.
The Save Plot Configuration File dialog box appears.
4. In the Configuration File Name text box, enter the name for the plot configuration.
5. If you want to include all plots currently in the Plotting window, including every page, select All
Plots.
6. If you did not select All Plots, in the Plot Name(s) text box, enter the names of the plots that you
want to include in the plot configuration file.
7. In the Plots and Curves text boxes, enter command keyword to invoke the macro that customizes
the plots and curves.
Your template-based product saves the command keyword with your plotting configuration file.
After it creates the plots and curves, your plotting configuration file invokes the macro which
contains the commands.
8. Select OK.
Reviewing Results
VERTICAL_AXIS
HORIZONTAL_AXIS
VERTICAL_COMPONENT
HORIZONTAL_COMPONENT
LEGEND_TEXT
COLOR
red, blue, yellow, magenta, cyan, black, white, skyblue,
midnight_blue, blue_gray,dark_gray, silver, peach, maize
STYLE
solid, dash, dotdash, dot
SYMBOL
none, x, o, plus, star, at
LINE_WEIGHT
Real value from 1-4
COMMAND
command_keyword
After your template-basedproduct creates each curve, it executes the following commands if you defined
a command keyword:
acar custom_plots <command_keyword> &
analysis=<analysis> &
plot_name=<plot_name> &
vertical_data=<y> &
horizontal_data=<x> &
curve_name=<curve_name>
The command acar custom_plots <command_keyword> must already be created in the current session,
either interactively or already present in the acar.bin, aengine.bin or arail.bin file.
211
212 Adams/Car
FILE_VERSION = 1.0
FILE_FORMAT
= 'ASCII'
$----------------------------------------------------------------------PLOT
[PLOT]
NAME = 'aircraft_plot_1'
SUBTITLE = 'Aircraft Linear CG Acceleration in Ground Coordinates'
TIME_LOWER_LIMIT = 0.0
TIME_UPPER_LIMIT = 0.0
(PLOT_AXES)
{axis_name
type
label
scaling divisions low_limit
up_limit}
'vaxis'
'vertical'
'Acceleration (inch/sec**2)'
'linear'
10
0
0
'haxis'
'horizontal'
'Time (sec)'
'linear'
4
0
0
$-----------------------------------------------------------------PLOT_CURVE
[PLOT_CURVE]
NAME = 'curve_1'
PLOT = 'aircraft_plot_1'
VERTICAL_AXIS = 'vaxis'
HORIZONTAL_AXIS = 'haxis'
VERTICAL_COMPONENT = 'AC_CG_Acc_GRND.ACCx'
HORIZONTAL_COMPONENT = 'AC_CG_Acc_GRND.TIME'
LEGEND_TEXT = 'AC_CG_Acc_GRND.ACCx'
COLOR = 'red'
STYLE = 'solid'
SYMBOL = 'NONE'
LINE_WEIGHT = 2.5
Reviewing Results
[PLOT_CURVE]
NAME = 'toe_angle_l'
PLOT = 'toe_angle'
VERTICAL_AXIS = 'vaxis'
HORIZONTAL_AXIS = 'haxis'
VERTICAL_COMPONENT = 'toe_angle.left'
HORIZONTAL_COMPONENT = 'wheel_travel.vertical_left'
LEGEND_TEXT = 'Left'
COLOR = 'blue' STYLE = 'dash'
SYMBOL = 'none'
LINE_WEIGHT = 2.0
213
214 Adams/Car
354 Adams/Car
Can:
Create and set up private databases in which to store files, such as
subsystems and property files, with which you are working.
Make copies of files in your private database or copy the entire database
use.
Expert user
Site manager
operation.
Expert user - You can access the management tools from the Tools menu.
To get expert-user access, modify your private .acar.cfg configuration file and change your user mode to
EXPERT. Learn about setting your product's environment.
355
356 Adams/Car
retrieve data from your private database. In addition, you can share your private database with
others. If a private database does not exist, your template-based product creates the private
database at the beginning of a session.
Shared database for all users - A shared database provides all users with access to standard,
accurate data. To prevent loss of data or the storing of inaccurate data in a shared database,
standard users can only retrieve data from a shared database. Typically, only the site manager has
the permissions necessary to create files in a shared database. An example of a shared database is
distributed with your template-based product, and it is usually placed in the installation
directory.
Database Structure
Each database consists of one directory (*.cdb) and several subdirectories (*.tbl), called tables. Each
subdirectory contains files for specific types of components, such as springs and dampers, or files for
performing tests, such as loadcasesand wheel envelopes. The number of tables varies, but you can define
the number in the shared and private configuration files.
By default, your template-based product divides a database into the following table elements:
Models and topological information (templates, assemblies, subsystems, and flexible bodies)
Analysis information (such as analysis scripts, loadcases, driver loadcases, and suspension
curves)
Each type of file that a table stores has a unique three-letter extension that identifies its contents. For
example, all files stored in the assembly table contain a .asy extension.
An example of the default structure of a database for Adams/Car is shown in the Information window. The
information window shows all the tables in the database, their names, the type of files they store, and the
file extension of the files that they store.
You can also add your own tables since the database is an open-architecture file repository. For example,
you might want to create a table that stores data files for an analysis that is specific to your company.
Learn about managing tables.
357
358 Adams/Car
For your template-based product to be able to store a database in its search list, the file system to which
the database points must be accessible on the current file system of the computer.
Learn about setting up the search list and the order in which databases are searched.
Managing Databases
Select a topic to learn about the operations you can perform on databases:
Creating Databases During a Session
Setting the Writable Database
Managing Tables in a Database
Creating Tar Files of Databases
Unless you save database changes to your private configuration file, Adams/Solver will
not be able to access the databases you added or created in a session
You should create a database for every project on which you are working. By creating separate databases
for each project, you can ensure that the property files belonging to different subsystems are kept
separate.
When you create a database, you define two elements for it:
Name - You use the name, or database alias, to select the database from the search list in dialog
boxes.
Note:
You can also create databases directly using the configuration files. Learn about managing
To create a database:
1. From the Tools menu, point to Database Management, and then select Create Database.
2. Press F1 and then follow the instructions in the dialog box help for Create New Database.
3. Select OK.
359
360 Adams/Car
By default, your template-based product doesn't search all defined databases when it
cannot locate a file. You can, however, re-enable the searching by setting the
MDI_CDB_SEARCH environment variable to yes. In the Command Navigator, you can
issue the following command:
variable set variable_name=do_search &
integer_value=(putenv("MDI_CDB_SEARCH","yes"))
For more information, see the Adams/Car release notes.
See the following topics to learn more about the search order, how it impacts you, and how you set it up:
About Search Order
Adding Databases to the Search List
Removing Databases from the Search List
Changing the Search Order
361
362 Adams/Car
this helpful in many cases, but it can produce unintended results when you change the search order
without realizing that you can access different files. The database search order is also important if you
specify the database path incorrectly.
To avoid using the search order to find a file, which can result in longer searches and unintended results,
you can specify the database name (its alias) directly in the associated property file to ensure that your
template-based product searches the correct database.
You can look at the search order of thedatabases in the search list usingthe Database Info command, as
shown in Viewing Database and Table Information. Your template-based product displays the current list
of databases, showing the search order level of each database in the first column. Learn about displaying
database information.
search order.
363
364 Adams/Car
Publishing Subsystems
When you publish a subsystem, you copy the subsystem file and all its associated property files to the
target database, which is the database where your template-based product saves all files. You can also
select to publish the subsystem's template file. As you publish the subsystem, you can choose to write
over existing files or create backups of the files.
You can also select to update the in-session subsystem data to point to the target database or to have the
subsystem retain the existing references.
The subsystem you are publishing must be currently opened in the standard interface, and the target
database must be writable. Learn about setting the writable database.
You can also publish an entire assembly. Learn about publishing an assembly.
To publish a subsystem:
1. From the Tools menu, point to Database Management, and then select Publish Subsystem.
2. Press F1 and then follow the instructions in the dialog box help for Publish an Open Subsystem.
3. Select OK.
Publishing Assemblies
When you publish an assembly, you copy each subsystem file included in the assembly definition,
including the associated property files for each subsystem, to the target database, which is the database
where your template-based product saves all files. You can also select to publish each subsystem's
template file. As you publish the assembly, you can select to write over existing files or create backups
of the files.
You can also select to update the in-session assembly data to point to the target database or to have the
assembly retain the existing references.
The assembly you are publishing must be currently opened in the standard interface, and the target
database must be writable. Learn about setting the writable database.
You can choose to publish only a subsystem, not an entire assembly. Learn about publishing a subsystem.
To publish an assembly:
1. From the Tools menu, point to Database Management, and then select Publish Assembly.
2. Press F1 and then follow the instructions in the dialog box help for Publish an Open Assembly.
3. Select OK.
365
366 Adams/Car
The private configuration file is not located in the installation directory. Never change the
acar.cfg file located in the installation.
If you have more than one private configuration file, you can choose the file you want to use for a given
session. Depending on the platform you are using, you do the following:
On UNIX - You use the Registry Editor on the Adams Toolbar to choose the file you want to
use. The registry setting name for your private configuration file is privateCfg.
On Windows - You can specify the private configuration file using an environment variable.
You can set this environment variable using the System option from the Control Panel, just as
you would for any other variable. Depending on your template-based product, you can specify
the following environment variables:
For Adams/Car, enter MDI_ACAR_PRIVATE_CFG
For Adams/Driveline, enter MDI_ADRV_PRIVATE_CFG
You should set up your private configuration file so it contains information specific to the work you are
performing. For example, you can set up your own tables in databases in which to store project data. You
can also override many of the default settings provided in the shared and site configuration files.
template-based product. For example, it identifies the type of user associated with the
configuration file. It also sets the mode in which your template-based product starts, Standard
Interface or Template Builder, and any other environment settings.
367
368 Adams/Car
Databases - The second block defines the databases in which users store files, the order in which
your template-based product searches databases, and the database to which files are written by
default.
Table Directories - The third block defines the list of personal table directories. For example,
Property Files - The fourth block contains a listing of default property files. When a dialog box
requires a property file, it automatically knows to load the desired files if you enter property files
in the property file block. You usually define property files in the shared configuration file. If
you enter values in your private configuration file, your template-based product overrides the
shared files with your personal property files.
Test Rigs - The fifth block defines the default test rig for a given assembly class. When a dialog
box requires a test rig, it automatically knows to load the desired test rigs. You usually define test
rigs in the shared configuration file.
VARIABLE_NAME
VARIABLE_VALUE
We've set up default environment variables in the shared configuration file, but we recommend that you
redefine them in the private or site configuration file to customize the work environment of your
template-based product. You can also define your own environment variables for use with user-written
subroutines or macros.
Learn about the standard environment entries that you can set and how to create your own environment
variables:
Setting User Access
Accessing Adams/View
Setting Defaults and Display of the Welcome Dialog Box
Replacing the Image on the Welcome and Exit Dialog Boxes
Setting Up Side Preferences
Setting the Orientation of the Global Reference Frame
Managing Result File Output
Redefining Environment Variables
Defining Your Own Environment Variables
Editing Files Using a Text Editor
The private configuration file is not located in the installation directory. Never change the
acar.cfg file located in the installation.
369
370 Adams/Car
EXPERT - User can access the Template Builder and create and modify templates. User can
access the Template Builder and other development tools that are located under the Tools menu.
Expert users can use the MDI_ACAR_PLUS_AVIEW keyword in the private configuration file
to access Adams/View. Learn about accessing Adams/View.
To change the value of this keyword, you must edit the private configuration file (.acar.cfg) using a text
editor and modify the corresponding string. The following gives you expert access:
! Desired user mode (standard/expert)
ENVIRONMENT MDI_ACAR_USERMODE EXPERT
When you start a new session, your template-based product reflects the changes to the private
configuration file.
Accessing Adams/View
If you are an expert user, you can use the MDI_ACAR_PLUS_AVIEW environment variable in the
private configuration file to obtain access to Adams/View.
MDI_ACAR_PLUS_AVIEW has the following format:
ENVIRONMENT
MDI_ACAR_PLUS_AVIEW
(yes, no)
To access Adams/View:
1. Set MDI_ACAR_PLUS_AVIEW to yes.
2. From the Tools menu, select Adams/View Interface.
To return to your template-based product:
From the Tools menu, point to Select Mode, and then select the interface mode to which you
want to return: Standard Interface or Template Builder.
MDI_AENG_HHT_ERROR 1e-5
This sets the HHT integrator as the default integrator with a default error tolerance of 1e-5 when
using Adams/Solver (C++).
3. Start a new session.
(template_builder, standard_interface)
(yes, no)
Setting it to yes displays the Welcome dialog box; setting it to no turns off the display of the Welcome
dialog box.
371
372 Adams/Car
The guesses in the pop-up menus in dialog boxes only contain left and single or right and
single entities based on the side preference. Your template-based product does this to limit the
number of guesses.
MDI_ACAR_SIDE_PREF
(right, left)
MDI_ACAR_VEHICLE_REAR
MDI_ACAR_VEHICLE_LEFT
1,0,0
0,-1,0
(yes, no)
If a result file exists, your template-based product will automatically read it in with the analysis, if you
run an interactive simulation.
If you run the simulation externally (background, files_only), you can read in the result file using either
of these two methods:
Review -> Analysis Management -> Read
File -> Import -> Adams Results File (*.res)
MDI_ACAR_USERMODE
expert
VARIABLE_NAME
VARIABLE_VALUE
debug_mode
yes
373
374 Adams/Car
You can place DATABASE entries in the private, site, or shared configuration files. The
DEFAULT_WRITE_DB, however, is reserved for the private and site configuration files.
Note that you can also set up databases through menus, as explained in Managing Databases. You may
find it more convenient to use the menus.
Learn more about managing databases through configuration files:
Setting Up Databases
Specifying Default Writable Database
Setting Up Databases
You can define databases in your template-based product using the keyword DATABASE. A
DATABASE keyword entry has the following format:
DATABASE
DB_NAME
DB_PATH
In the format, DB_NAME is the name assigned to the database and DB_PATH is the location of the
database in your file system. You can add any database to the DATABASE definition in any
configuration file. If the database does not exist, your template-based product creates it in the specified
location and adds it to the database list.
DB_NAME
The environment variable defines the initial database that you want as the default location for writing
files. Usually, you define the default writable database in your private configuration file, although you
can set the writable database in any configuration file. You can change it during the session as explained
in Setting the Writable Database. Note that you will need permission to write to the file system location
to which the DEFAULT_WRITE_DB points.
375
376 Adams/Car
Creating Tables
At start up, your template-based product determines when to create new table directories as follows:
1. Your template-based product verifies that all database directories defined in the private
configuration file contain table directories for the corresponding table directories also defined in
the private configuration file.
2. If a table directory does not exist inside the database, your template-based product creates one.
3. If a site configuration file exists, your template-based product ensures that for any table directory
specified in the site configuration file, a corresponding table directory exists for all database
directories defined in both the site and private configuration files.
4. Your template-based product ensures that for all table directories specified in the shared
configuration file, a corresponding table directory exists for all database directories defined in the
private, site (if it exists), and shared configuration files.
The TABLE keyword entry for creating tables has the format:
TABLE
TABLE_CLASS
TABLE_NAME
TABLE_EXTENSION
where:
TABLE_CLASS - A string identifying the table.
TABLE_NAME - The name that you want used to access the table.
TABLE_EXTENSION - The three-character extension of files stored in the table. Your
template-based product only recognizes files in the table that have the extension that you specify.
For example, the following creates a table that stores aerodynamic forces:
TABLE
aeroforces
/staff/my_name/my_db.cdb/aeroforces.tbl
aer
Adding the table definition shown above in the configuration file causes your template-based product to
recognize and correctly access files stored in that particular database table.
They are the standard set of tables that are distributed with your template-based product's database. You
cannot reconfigure TABLE entries. Changing these values disables your template-based product's ability
to assign properties to a class of entities.
PROPFILE_CLASS
PROPFILE_NAME
where:
PROPFILE_CLASS is a string that identifies the property file.
PROPFILE_NAME is the name of the property file.
For example:
PROPFILE
bushing
mdids://shared/bushings.tbl/mdi_0001.bus
You can define the property files in the private, site, or shared configuration files.
TESTRIG_CLASS
TESTRIG_NAME
where:
ASSEMBLY_CLASS is a string that identifies the type of assemblies which correspond to the
test rig.
For example:
TESTRIG
four_post
.__MY_FOURPOST
You can define the default test rigs in the private, site, or shared configuration files.
377
378 Adams/Car
380 Adams/Car
Overview
If you are an expert user or site manager, you can customize your template-based product to your
company's needs and preferences. You can extend your template-based product by adding new
functionality, modifying standard functionality, or tailoring its appearance to fit the needs of your work
environment. Customizing your template-based product lets you create a familiar environment in which
users can work.
Note:
You cannot customize all dialog boxes and tools. For example, you cannot customize the
Plugin Manager or the Information window. The Dialog-Box Builder's Dialog Box ->
Open menu provides access to those dialog boxes, containers, and toolbars that you can
customize.
You can typically modify your template-based product in three main areas. These require different levels
of understanding, ranging from the Adams macro language, Standard Developer Kit (Adams/SDK),
through FORTRAN and C solver routines, as described next.
Customizing the interface - Involves creating or modifying interface objects, such as macros,
dialog boxes, menus, and windows. This uses Adams command language to modify the look and
feel of the interface. It can be used to automate recurring tasks, using the scripting language, but
has limitations in terms of speed and would not be used to generate computationally complex
objects (1000 parts located and oriented to generate a chain). For these tasks, you would use an
Adams/View library written in C.
Note:
extend the functionality of your template-based product in terms of the solver. You save them in
custom libraries for later use.
Note:
Once you have finalized your customization of your template-based product, you can store your
customized dialog boxes, macros (binary files), Adams/View and Adams/Solver libraries in a site
directory, for use by all users, or in a private directory for personal use. You can extend this hierarchy to
support multiple operating systems from one installation.
Select an entry on the left to learn how to efficiently customize the environment of your product.
381
382 Adams/Car
Naming Conventions
We recommend that you use a naming convention when you create and modify interface objects or
macros. A naming convention reduces the chances of naming conflicts and provides a simple method for
organizing files, macros, and dialog boxes.
The naming convention that we recommend is the same one that template-based products currently use.
The naming convention uses the abbreviation of the object (for example, mac for macro) followed by a
set of characters that identify the commands or functionality that the object executes or performs. The
naming conventions for macros and dialog boxes are explained next.
Macro naming convention - The macro naming convention uses the abbreviation mac for
macro followed by the first three characters of each command in the user-entered command that
executes the macro. For example, if the user-entered commands for a macro are as shown below
(the first three characters are highlighted in boldface type):
acar analysis
suspension
Then, the name of the macro is:
single_travel
submit
mac_ana_sus_sin_sub
Dialog box naming convention - The naming convention for dialog boxes uses the abbreviation
dbox for dialog box followed by the first three characters of the words that identify the
functionality of the dialog box. For example, if a dialog box is the interface through which a user
creates a hardpoint, then the words that define its functionality are:
template_builder
and, its name is:
hardpoint
create
dbox_tem_har_cre
If, however, the dialog box performs two or more functions, as many dialog boxes do, then the
dialog box name does not include the words for the function. For example, if a dialog box lets a
user both create and modify a spring damper, the words that define its functionality are:
template_builder
and, its name is:
damper
create/modify
dbox_tem_dam
Using Libraries
We recommend that you use libraries to store the interface objects and macros that you create. Libraries
are repositories for Adams/View objects such as variables, assembly instances, macros, and dialog
boxes. Using libraries allows you to easily find, retrieve, or remove specific custom objects. You can add
to your template-based product as many libraries as you need. You can also have libraries within
libraries.
Your template-based product stores all its objects in libraries, named as follows:
Product name:
Library name:
Adams/Car .ACAR
You can view the objects in the library using the Database Navigator.
To create libraries, execute the following command either in your .cmd file or during an interactive
session. In the following command, MY_LIBRARY is the name of the library that will be created:
library create library_name=.MY_LIBRARY
Alternatively, you can add the command in the file you use to generate the site or private custom binary.
The files are named as follows:
383
384 Adams/Car
Product name:
File name:
Adams/Car acar_build.cmd
Learn more about those files.
Note that we supply many examples of how to code dialog boxes. You can find those examples in their
respective libraries. For example, acar.dboxes.
The next topics explain more about creating dialog boxes. For a general overview of creating and editing
dialog boxes in Adams products, see the Adams/View online help, under the Customize tab.
Dialog Box Objects
Layout and Sizing of Dialog Boxes
Commands in Dialog Boxes
Dialog Box Error Handling
Start, Execute, and Finish Commands
OK, Apply, and Cancel Buttons
When you have finished modifying your dialog boxes, review the options for saving your changes and
having them automatically included in your own version of your template-based product. Learn about
saving dialog boxes.
Accessing Dialog Box Programming Tools
You use the Dialog Box command on the Tools menu to create and modify dialog boxes.
To view, change, and create dialog boxes, you must have expert user access to your template-based
product.
Dialog Box Objects
Dialog boxes are a combination of different interface objects that you can modify using the Dialog-Box
Builder. These include the following:
List of Common Dialog Box Objects
The objects:
Are:
Containers
Text boxes
Pull-down menus
Menus that display a list of options from which you can select only
one option.
Radio boxes
Toggles that set a state or mode. You can only select one state or
mode.
Toggles that indicate an active state. You can select more than one
state.
Push buttons
Sliders
A continuous range of possible values from which you can select one
value.
385
386 Adams/Car
Location 3
3, 154
Width 3
70
Label width
150
Label height
25
240
Location 15
, 150
Width 40
Label width
150
Label height
25
244
You can also have commands operate on other objects in dialog boxes, which causes the dialog box to
change its appearance when a user makes a selection from an object. For example, when a user selects
an option from a pull-down menu, the dialog box changes to display objects for entering values for the
selected option as shown next.
387
388 Adams/Car
associated with a particular interface object when that object is displayed. The start commands
ensure, for example, that the dialog box is displayed properly based on the display parameters.
You should use the start commands to set an errorFlag variable to an initial value of zero, or no
error condition, as shown next:
variable set variable_name=$_self.errorFlag int=0
Template Builder dialog boxes usually have two possible startup parameters, which you should
set up in the start commands when a dialog box is displayed. The states are:
mode - Mode has two states, which represent the creation or modification states of a dialog
when an object is no longer displayed. You use them to clean up after a macro, delete
unnecessary objects, such as temporary variables, and so on.
To clean up variables:
You can use the command:
variable delete variable_name=(eval(db_children($_self, "variable")))
To clear the text boxes of a dialog box:
You can use the command:
for var=$_self.loopobj
object(eval(db_children($_self,"graphic_interface_field")))
interface field set
field=(eval($_self,"graphic_interface_field")))
string="" execute=no
end
OK, Apply, and Cancel Buttons
Each dialog box in your template-based product has three standard buttons:
389
390 Adams/Car
OK - Executes the commands associated with the dialog box, and if it executes the command
Apply - Executes the commands associated with the dialog box but leaves the dialog box open
Cancel or Close - Exits the dialog box without executing a command or executing only a
selected command. Only dialog boxes that have an Apply button have a Close button.
Button Size
To keep your dialog boxes consistent with the dialog boxes of your template-based product, you should
always keep the size of these buttons to 25 pixels high and 76 pixels wide.
Error Handling
Make sure that the commands associated with the OK button reference the dialog box error variable
(errorFlag). By referencing the error variable you ensure that the dialog box will not be closed if an
errorFlag was set during the execution of the dialog box commands. Because the following commands
are generic, you can use them to reference the errorFlag with any dialog box:
interface dialog execute dialog=$_parent undisplay=no
if condition=(!$_parent.errorFlag)
interface dialog undisplay dialog=$_parent
end
Learn about error handling in dialog boxes.
When you have finished modifying your macros, review the options for saving your changes and having
them automatically included in your own version of your template-based product. Learn about saving
macros.
Accessing Macro Programming Tools
You use the Macro command on the Tools menu to create and modify macros. For information on the
Macro command, see Editing and Creating Macros Using the Macro Editor.
To view, change, and create macros, you must have expert user access to your template-based product.
Viewing Existing Macros
Because macro programming is so well developed in your template-based product, you may find it
helpful to look at existing macros. Once you find a macro that most closely meets your needs, use it as
the basis of customization.
As you look at the existing analysis macros within your template-based product, notice that all of them
have the same basic structure.
To view existing macros:
1. From the Tools menu, point to Macro, point to Edit, and then select Modify.
The Database Navigator appears.
2. Select a macro to view.
The Macro Editor appears with the macro commands of the selected macro in the Commands text
area.
Using Parameters
Parameters are placeholders for information that users provide when they execute a macro in a templatebased product. You write parameters in a macro as a $followed by the name of the parameter. Parameters
let you make macros very flexible. When you create a macro, your template-based product scans the
command text to identify all the parameters.
When you issue the command to execute the macro, you provide values for the parameter or the
parameters assume default values. Your template-based product substitutes the values in place of the
parameters in the macro and executes the macro commands.
You identify parameters in macros using qualifiers. Qualifiers define a parameter's type, range, count
(number of values), and defaults.
391
392 Adams/Car
The following is an example of a list of parameters and their qualifiers for a macro:
! $part_name:t=string
! $location:t=location
! $type:t=string
! $orientation:t=orientation
! $mass:t=real
! $cm_location_from_part:t=location:d=0,0,0
! $Ixx:t=real
! $Iyy:t=real
! $Izz:t=real
! $Ixy:t=real:d=0
! $Izx:t=real:d=0
! $Iyz:t=real:d=0
!END_OF_PARAMETERS
Using the Echo Command
The command echo=on, which is the default, is a very helpful command because it lets you review the
full log of the macro execution in the command window or echoed in the acar log file.
To use the echo command, you can add the following line at the top of your macro:
default command echo=on
You will find it very helpful for debugging purposes.
Using Local Variables
You can create Adams/View variables to be used in your macros. A variable is storage location that can
contain data. Once you define a variable, you can use it in any parameter, macro, or function in your
template-based product.
You can define a variable as a child of any modeling object, including a macro. Defining a variable as a
child of a macro is helpful in macro programming when you need to create auxiliary Adams/View
variables, such as variables that call an Adams/View function or that act as a return variable from a called
macro. Being able to create these variables as children of the macro results in a cleaner macro.
As a child of the macro object, the variable inherits the object's name. Therefore, the text $_SELF
evaluates to the name of the parent object, which is the macro.
In addition, most often you will want to delete these auxiliary variables when the macro is finished.
Creating these variables under the macro simplifies this cleanup procedure.
You can delete local variables very easily as shown next:
To use local variables:
You should do the following:
variable set variable_name=$_self.filename &
string_value="tmpfile.cmd"
The following Adams/Car example shows how error handling works in a macro. The acar toolkit
warning utility macro displays a message in a window, informing you that it encountered an error
condition. The window remains open until you close it.
!---- Ensure a brake subsystem exists ---if condition=(!subsystem_role_exists($assembly,"brake_system"))
acar toolkit warning &
warning="This assembly does not have a brake subsystem!"
variable set variable_name=$error_variable integer=1
return
end
393
394 Adams/Car
If you do not attach your dialog box to a template, the dialog box will be lost when you
close the current session.
1. From the Build menu, point to Custom Gui, point to Dialog Box, and then select Attach.
2. Select << Add.
3. In the Selections dialog box, double-click the name of your dialog box. In this case, dbox_1. If
you have multiple dialog boxes you want to store, repeat these steps for each dialog box.
4. Select OK.
To verify that your product stored your dialog box:
1. From the Build menu, point to Custom Gui, point to Dialog Box, and then select Display.
2. In the Selections dialog box, double-click the name of the dialog box you want to display.
Your product displays the dialog box.
To export a custom dialog box:
From the Dialog Box Builder's Dialog Box menu, point to Export, and then select Command
File.
To import a dialog box:
To import a dialog box from a command file and attach it to a template, you must manually
rename every entity in the command file for .ACAR.custom. For example:
MY_LIBRARY.dboxes.dbox_1 becomes .ACAR.custom.dbox_1
MY_LIBRARY.dboxes.dbox_1.field_1 becomes .ACAR.custom.dbox_1.field_1
that you can use to collect push buttons (in this context, think of push buttons as options located
under a submenu). For example, under the Build menu, Hardpoint is a submenu containing five
push buttons/options (Modify, Table, New, Info, and Delete), as shown next.
395
396 Adams/Car
Push button - You can use a push button to execute a command such as displaying a dialog box
or executing a macro.
When creating menus, we recommend that you first think about the structure of what you are trying to
achieve. By using a hierarchical approach, you can use submenus to categorize different buttons.
In the following example we assume that you have created a custom dialog box named dbox_1. We are
first going to create a submenu named Example.
To create a submenu:
1. From the Build menu, point to Custom Gui, point to Menu, point to Submenu, and then select
Create.
Your product displays the Create Custom Submenu dialog box.
2. Enter the label that you want to use, in this case Example, and then reference the template in
which this custom menu will be stored.
3. Select OK.
Now you create a push button that resides as a child of submenu, and call the button Display. You then
execute a command to display the custom dialog box, dbox_1.
To create a push button:
1. From the Build menu, point to Custom Gui, point to Menu, point to Push Button, and then
select Create.
Your product displays the Create Custom Push Button dialog box.
2. Enter the label that you want to use, in this case Display.
3. Set Parent Menu to menu1, which is the submenu Example you created above. Note that as you
create submenus, your product references them internally as menu1, menu2, and so on, rather
than by name (in this case, Example). If you created several submenus and lost track of their
names, you can use the Info command to see how your product names them: from the Build
menu, point to Custom Gui, point to Menu, and then select Info.
4. The execution command is highly dependent on what you want to achieve. In this example, you
want to display the custom dialog box, dbox_1, so in the Commands text box enter:
interface dialog_box display dialog_box_nam = .ACAR.custom.dbox_1
If, however, you wanted to view the front view of your model, you would enter a command
similar to the following:
acar interface view_restore view_orientation = front
5. Select OK.
6. To validate that the push button works, from the Build menu, point to Example, and then select
Display. Your template-based product should display your dialog box.
To change the order of your submenus:
1. From the Build menu, point to Custom Gui, point to Menu, and then select Reorder.
2. Press F1 and then follow the instructions in the dialog box help for Reorder Custom Menus.
To get information about your custom menu structure:
From the Build menu, point to Custom Gui, point to Menu, and then select Info.
Your product displays the information in the Information window.
397
398 Adams/Car
If you decide to build either a site or private binary file, then you must place this file at the top level, as
defined by the path in MDI_ACAR_SITE or MDI_ACAR_PRIVATE.
Navigator.
Adams/Car displays the dialog box in build mode, along with the Dialog Box Builder.
From the Dialog Box Builder's Dialog Box menu, point to Export, and then select Command
File.
Adams/Car writes a command file to your file system. The name of the resulting command
file will be derived from the dialog box name. If the dialog box is named
dbox_ana_ful_tst_sub, then the dialog box will be saved as dbox_ana_ful_tst_sub.cmd.
3. Create a command file, named as shown in tableFile Names, that reads in thecommand files that
customize the interface. See an example of an acar_build.cmd file.
4. Add commands to that command file that automatically reads the macro and dialog box. The
following would read the macro and dialog box, as saved in the steps above.
!------Read a macro----macro read &
macro_name = .MY_LIBRARY.mac_ana_ful_tst_sub &
file_name = "C:\temp\mac_ana_ful_tst_sub.cmd" &
user_entered = "Analysis full-vehicle test submit" &
wrap_in_undo = no &
create_panel = no
!------Read a dialog box----file command read &
file_name = "C:\temp\abox_ana_ful_tst_sub.cmd
5. Store the file in the desired private or site file repository. Learn about private and site file
repositories.
6. Create a private or a site-specific binary, including the saved interface objects, as explained in
Creating Binary Files in the guide Running and Configuring Adams
399
400 Adams/Car
If successful, this execution results in the generation of a wavefront file based on the input parameter
contained in shell_file (as an example, my_road.obj).
In this case, you call a function (create_a_road) in your Adams/View library. You can set up this code to
return a Boolean flag, such as 0 if it failed and 1 if it was successfully executed. You can check this flag
to see if the operation was successful or not, and take action based on the result.
After you check the error flag, you can execute a read Wavefront file in the macro, specifying the
shell_file file as generated by the Adams/View library:
file wavefront read &
file_name = (eval($_self_shell_file)) &
port_name = $assembly_ground
You can input C or FORTRAN source files to create Adams/Solver user libraries and only C source files
to create Adams/View user libraries. You must compile these subroutines before linking them with an
Adams product. See the hardware and software specifications that come with your Adams product for
the type of compiler you need
(http://www.mscsoftware.com/support/prod_support/adams/?Q=135&Z=144&Y=174). Also refer to your
compiler documentation for details.
Therefore, you can write an Adams/Solver routine in FORTRAN or C, but keep in mind that:
The solver subroutine is expected to be in FORTRAN.
If the solver subroutine is written in C, you must make it emulate a FORTRAN subroutine, as
You must have the linkers from the FORTRAN compilers to create a library, even if the
subroutine is in C.
point to your template-based product (in this case, ACar), and then select Advanced.
401
402 Adams/Car
Press Enter again to select the default, which tells the compiler not to build debug libraries.
Your template-based product displays the compile options.
On UNIX:
At the prompt, enter mdi -c acar cr-acarprivate, and then press Enter.
Press Enter again to select the default, which tells the compiler not to build debug libraries.
Your template-based product displays the compile options.
your custom function. You can reference your function using the Function Builder or macro code.
For example, you want to create a force element that represents an aircraft landing-gear damper, then you
could create a custom Adams/Solver library to define the calculations used to produce that force. Inputs
to the damper might include damper velocity, damper displacement, and operating temperature. Output
could be force.
To use your custom Adams/Solver subroutine, you first compile your C or FORTRAN code. You then
link those files into an Adams/Solver library (*.dll or *.so (on UNIX)). The resulting file is stored in a
location defined by either MDI_ACAR_SITE or MDI_ACAR_PRIVATE_DIR. When you invoke the
site or private solver, the library is automatically loaded and the functions become available (dispatched
using the auto-generated code in dispatch.f). A statement in the solver dataset, for the aircraft damper
mentioned above, may look like this:
SFORCE/1
,TRANSLATIONAL
,I = 1
,J = 2
,FUNCTION = USER (2001, 1, 2, 3)
where:
2001 is the branch ID of your sfo subroutine (your function in your subroutine would be
sfo2001(par, npar)
This function would provide the force to the damper element. Assuming that a subroutine named sfo2001
is included in your custom solver code, the general dispatcher will call this subroutine, pass information
to the subroutine, and return the force from the subroutine.
Learn more about Adams/Solver libraries:
Requirements for Creating Custom Libraries
Creating and Using Adams/Solver Libraries
403
404 Adams/Car
You can input C or FORTRAN source files to create Adams/Solver user libraries and only C source files
to create Adams/View user libraries. You must compile these subroutines before linking them with an
Adams product. See the hardware and software specifications that come with your Adams product for
the type of compiler you need
(http://www.mscsoftware.com/support/prod_support/adams/?Q=135&Z=144&Y=174). Also refer to your
compiler documentation for details.
Therefore, you can write an Adams/Solver routine in FORTRAN or C, but keep in mind that:
The solver subroutine is expected to be in FORTRAN.
If the solver subroutine is written in C, you must make it emulate a FORTRAN subroutine, as
subroutine is in C.
requirements for the Adams/Solver dataset and the naming conventions for the subroutines and files
containing subroutines. To review some of those concepts, assume that you have an Adams/Solver
statement similar to the following:
REQUEST/1, FUNCTION = USER(123, ..., ...)
Then, you would need to generate a file named REQ123.f, which would contain a subroutine named
req123. For example:
C Request subroutine to calculate Yaw angle
subroutine req123 (par, npar)
If you follow this convention, generating your own custom libraries should be easy.
To generate a custom library:
1. Make a list of files that you want to include in your custom Adams/Solver library.
2. Save this list in a text file named sub_list.lst. The following is an example list:
req123
sfo456
con789
3. Build your custom Adams/Solver Library:
On Windows:
From the Start button, point to Programs, point to MSC.Software, point to MD Adams R3,
point to your template-based product (for example, Adams/Car), and then select Advanced.
Adams/Solver library.
Press Enter.
On UNIX:
At the prompt, type mdi -c acar cr-solverprivate, and then press Enter.
Press Enter again to select the default, which tells the compiler not to build debug libraries.
Your template-based product displays the compiler options for the C and FORTRAN
Type @sub_list.lst to provide the list of files you want to include in your custom
Adams/Solver library.
Press Enter.
4. Alternatively, from the command line you can create your custom library by typing the following
command:
mdi -c acar cr-solverpr n @sub_list.lst -n
405
406 Adams/Car
Note:
Adams/Car writes the resulting acarsolver.dll (the name of the file is dependent on
If you are having difficulty building your custom code, we recommend using a
If you want to create a site solver library, you can replace the command cr-
Your compiled files and sub_list.lst are stored in a working directory. Your
On Windows:
From the Start button, point to Programs, point to MSC.Software, point to
Select Properties.
In the Start in text box, enter the location of your files (for example, c:\temp).
On UNIX, move into the directory where sub_list.lst is located (for example, cd
/usr/home/my_home/work).
After you created the private Adams/Solver library, modify an existing Adams/Solver dataset to verify
that your custom functions are working. You might find it helpful to write basic 'write' statements in your
FORTRAN code to verify that the code is being executed.
Overview of GENDISP
When you write a standard REQSUB subroutine, you often need to process output in more than one way.
You might have one subroutine that computes toe, camber, and caster angle, and another that computes
lateral acceleration and body sideslip angle. In your dataset you may have the following requests, which
reference two user subroutines to calculate toe, camber, and caster, and in the second subroutine lateral
acceleration and body sideslip.
REQUEST/111
!toe, camber, caster
FUNCTION = USER(1, 1, 2, 3)
REQUEST/222
!lateral acceleration, body sideslip
FUNCTION = USER(2, 4, 5, 6)
The parameters of interest are USER(1, and USER(2, where the values 1 and 2 correspond to PAR(1) in
the expression that follows. In your REQSUB, you must have logic to branch to the different subroutines
as shown next:
IF (NINT( PAR(1)) .EQ. 1 ) THEN
CALL TCCREQ( ID, TIME, PAR, NPAR, IFLAG, RESULT )
ELSE IF (NINT( PAR(1)) .EQ. 2 ) THEN
CALL BSAREQ( ID, TIME, PAR, NPAR, IFLAG, RESULT )
.
.
.
In the above example, if PAR(1) is equal to 1 (as defined by REQUEST/111), then the subroutine
TCCREQ is called. Likewise, if PAR(1) is equal to 2 (as defined by REQUEST/222), then the subroutine
BSAREQ is called.
Each time you add a new subroutine, you must rewrite your REQSUB to call that subroutine. If your
company has a standard REQSUB, you have to create a local version for yourself and then add your
subroutines to it.
With the template-based products, however, if you follow a simple naming convention for your userwritten subroutines, GENDISP automatically creates a REQSUB, SFOSUB, and so on, with all the
branches to your routines as part of the linking of a library. GENDISP places these subroutines in an
automatically generated file, named dispatch.f.
For example, if you rename the subroutine TCCREQ to REQ001 and the subroutine BSAREQ to
REQ002, then GENDISP creates a REQSUB for you with branches to REQ001 and REQ002 as shown
next:
IF (NINT( PAR(1)) .EQ. 1 ) THEN
CALL REQ001( ID, TIME, PAR, NPAR, IFLAG, RESULT )
ELSEIF (NINT( PAR(1)) .EQ. 2 ) THEN
407
408 Adams/Car
as the calling user subroutine and the last three characters of the subroutine name must be
numbers. For example, the subroutine called by a REQSUB, must be named REQ001, REQ002,
and so on. Another example would be naming GFORCE user subroutines called from a
GFOSUB names like GFO241, GFO534, and so on.
Name your source code or object code files according to this convention. For GENDISP to work,
the source code or object code files must have the same root name as the subroutine (for
example, req001.f or req001.o). Note that GENDISP ignores case. Therefore, REQ001.f is the
same as req001.f or ReQ001.f. GENDISP generates branches based on the root file name.
GENDISP does not examine the contents of a file for names matching the convention.
When invoking a user subroutine from your Adams model, make sure that the first user
parameter matches the subroutine you want to call. For example, the following sensor statement
generates a call to SEN743:
SENSOR/1, FUNC=USER(743, .......)\
Remember to always reserve the first parameter for branching when writing your user
subroutines.
Number all your routines in the 001 to 799 range (for example, REQ300 and SFO465). The
Description:
rol command
COUSUB
COUXX
COUXX2
CURSUB Curve
statement
Name:
DIFSUB D
DMPSUB Mod
FIESUB Field
GFOSUB Gforce
GSESUB
Description:
ifferential equation statement
al damping subroutine
statement
statement
General state equation subroutine
Adams/Car provides generic GSEYU, GSEXU, GSEXX and GSEYX
subroutines that numerically difference a GSE subroutine. The general
dispatcher, however, does not provide support for the revised GSE
implementation using the GSE_DERIV, GSE_UPDATE, GSE_OUTPUT,
and GSE_SAMP subroutines.
MFORCE Modal
force subroutine
MOTSUB Motion
statement
REQSUB Reques
t statement
SENSUB Sensor
statement
SFOSUB Sforce
statement
TIRSUB
UCOSUB Uco
VARSUB V
VFOSUB Vforce
VTOSUB Vtorque
Description:
demand
teering demand
rottle demand
Adams/Tire now supports dynamic loading (dispatching) of tire (TYRSUB) and road contact
(ARCSUB) subroutines. Support for standard driver interface (SDISUB) for lack of usage.
409
410 Adams/Car
array passed to the user subroutine as in REQSUB or PAR must be created using the
(CODE_BEFORE_BRANCH) option as Example of Using GENDISP.
code, and must follow FORTRAN's strict formatting rules. For example, executable code on a
line must be indented six spaces.
& TIME,
& PAR,
& NPAR,
& IFLAG,
& RESULT )
ELSE IF ( NINT(PAR(1)).EQ.901 ) THEN
CALL req901 ( ID,
& TIME,
& PAR,
& NPAR,
& IFLAG,
& RESULT )
ELSE IF ( NINT(PAR(1)).EQ.221 ) THEN
CALL req221 ( ID,
& TIME,
& PAR,
& NPAR,
& IFLAG,
& RESULT )
ELSE
WRITE (ERRMSG,'(A,I4.4)')
& 'Error in dispatcher subroutine reqSUB: Invalid
PAR(1): ',
& NINT( PAR(1) )
CALL ERRMES( .TRUE., ERRMSG, 0, 'STOP')
ENDIF
RETURN
END
Each block for a subroutine in dispatch.dat must contain a (PARAMETERS) sub-block that defines the
subroutine parameter types. Optionally, a block may contain a (CODE_BEFORE_BRANCH) sub-block
as illustrated in the example MYUSUB shown in Example of Using GENDISP.
Using GENDISP
The following procedure is only applicable if you want to extend the libraries that GENDISP dispatches.
Here we provide an overview of how to test additions to the dispatch.dat file. The result of this procedure
should be a fully populated dispatch.f file, which you can examine to verify that valid subroutines have
been written. In normal circumstances, this procedure should not required because this process is
automated by the acarcom and acarsolvercom scripts. We provide this procedure as a means to validate
that you correctly modified the dispatch.dat file.
GENDISP is invoked when linking private or site libraries. A list of standard template-based product file
names, plus file names you supply, are passed to GENDISP. GENDISP examines the list of files for
names matching the supported subroutine types given in the file dispatch.dat. For each matching name,
GENDISP creates a branch in the appropriate user subroutine and outputs the source code file dispatch.f
to the working directory.
The file dispatch.f can contain multiple subroutines, but only one of each type (for example, one
REQSUB or one CURSUB). The acarcom and acarsolvercom scripts include dispatch.f when linking.
The files dispatch.f and dispatch.o are left in the working directory so you can look at them.
411
412 Adams/Car
For testing or other purposes, you can execute GENDISP yourself. You can find GENDISP at the
following location, where install_dir is the installation directory, and product_name is the name of your
template-based product:
$install_dir/$product_name/$MDI_CPU/gendisp
For example, the location of GENDISP might be:
/usr/mdi12/acar/irix32/gendisp
You invoke GENDISP with the following arguments:
gendisp file.lst dispatch.f dispatch.dat
where:
file.lst - File containing a list of user subroutine filenames for GENDISP processing.
dispatch.f - Source code file name output by GENDISP.
dispatch.dat - TeimOrbit format file defining the supported subroutine types and their parameter
lists.
switch:',
END
To dispatch.dat, you add a block for MYSSUB that looks like the following:
$********************************************
[MYU]
(PARAMETERS)
{type name}
'INTEGER' 'SWITCH'
'INTEGER' 'NDPAR'
'DOUBLE PRECISION' 'DPAR(NDPAR)'
'DOUBLE PRECISION' 'VECTOR(3)'
(CODE_BEFORE_BRANCH)
{code}
' INTEGER PAR(2)'
' PAR(1) = SWITCH'
$********************************************
The code GENDISP generates for MYUSUB looks a little different then the example above, but
functions in the same way:
Ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
subroutine myusub( SWITCH,
& NDPAR,
& DPAR
,
& VECTOR )
C This is a dispatcher routine written by gendisp
INTEGER SWITCH
INTEGER NDPAR
DOUBLE PRECISION DPAR(NDPAR)
DOUBLE PRECISION VECTOR(3)
C Local variables
character*(80) errmsg
INTEGER PAR(2)
PAR(1) = SWITCH
IF ( NINT(PAR(1)).EQ.532 ) THEN
CALL myu532 ( SWITCH,
& NDPAR,
& DPAR,
& VECTOR )
ELSE IF ( NINT(PAR(1)).EQ.253 ) THEN
CALL myu253 ( SWITCH,
& NDPAR,
& DPAR,
& VECTOR )
ELSE
WRITE (ERRMSG,'(A,I4.4)')
& 'Error in dispatcher subroutine myuSUB: Invalid
PAR(1): ',
& NINT( PAR(1) )
CALL ERRMES( .TRUE., ERRMSG, 0, 'STOP'
)
ENDIF
RETURN
END
413
414 Adams/Car
Utility Functions
This topic lists utility functions that help you extend the Adams/View macro language. The functions
help you access information that is not easy to access using the standard Adams/View macro language.
You can use the utility functions in macros and in dialog boxes.
The following functions are used by the template-based products. To see information on all functions
available in the Function Builder, see the Function Builder online help.
Units-Conversion Functions
String Functions
Database Functions
File Functions
Database Lookup Functions
Miscellaneous Functions
Units-Conversion Functions
The units-conversion functions convert an input value to a different unit system. The units-conversion
functions are:
convert_from_units
convert_units
convert_to_radians
units_to_mks
convert_from_units
Definition
convert_from_units converts the input value from aunit type to the equivalent modeling units. It accepts
any valid units string (for example, mm, newton, or inch) for the unit type. It returns the converted value.
Format
REAL convert_from_units (STRING from_units, REAL in_value)
Arguments
from_units
in_value
Examples
The following example converts the current length units, which are in inches (inch), to millimeters (mm):
variable set variable=units_convert &
real_value=(eval(CONVERT_FROM_UNITS("inch", 1.0)))
units_convert = 25.4
convert_units
Definition
convert_units returns the conversion factor necessary to convert a value from the current units
(from_units) to the desired units (to_units). It accepts any valid units string (for example, mm, newton,
or inch) for the units strings. The units should be equivalent modeling units of length, force, mass, time,
or angle.
Format
REAL convert_units (STRING from_units, REAL to_units)
Arguments
from_units
to_units
Examples
The following example returns the conversion factor necessary to convert miles to millimeters:
variable set variable=convert_factor &
real_value=(CONVERT_UNITS( "mile" , "mm" ))
convert_factor = 1.609344E+06
convert_to_radians
Definition
convert_to_radians converts an angle from degrees to radians. You specify the input value in current
modeling angular units.Format
REAL convert_to_radians (REAL in_value)
Arguments
in_value
415
416 Adams/Car
Examples
The following example converts the current modeling angular units, which are in degrees, to radians:
variable set variable=angle_radians &
real_value=(CONVERT_TO_RADIANS(90))
angle_radians = 1.5707963268
units_to_mks
Definition
units_to_mks returns the conversion factor from user units to database units (meters, kilograms, seconds,
radians, or mks).Format
REAL units_to_mks (INTEGER units)
Arguments
units
An integer value.
Examples
The following example returns the conversion factor necessary to change degrees to database units:
variable ser variable=myvar1 &
real_value=90.0 units=angle
variable set variable=myvar2 &
real_value=(UNITS_TO_MKS( myvar1.units ))
myvar2 = 1.7453...E-02
String Functions
The string functions allow you to manipulate character strings. The string functions are:
str_assembly_class
str_char_swap
str_filename
str_model_class
str_prefix
str_remove
str_replace
str_typecheck
str_assembly_class
Definition
str_assembly_class returns the assembly class of an assembled model. Your template-based product
stores the returned information in the assembly_class variable under all assemblies. For Adams/Car,
typical assembly classes include suspension and full_vehicle. You can also extend the assembly classes.
If no assembly variable exists within the assembled model, str_assembly_class returns an empty string.
Format
STRING str_assembly_class (OBJECT assembled_model)
Arguments
assembled_model Name of the assembled model.
Examples
variable set variable=current_class &
string_value=(STR_ASSEMBLY_CLASS(.susp_assy))
current_class = "suspension"
str_char_swap
Definition
str_char_swap changes a single character in a string (object_name) at a particular location (index) to
another character string. It changes the characters as specified in swap_str.
str_char_swap compares the strings and changes them only in the string following the last . in
object_name. In addition, swap_str must be two or more characters long and contain an even number of
characters.
The first half of swap_str determines the characters to be changed ("from characters") and the second
half of swap_str determines the characters to which the characters are to be changed ("to characters"). If
str_char_swap does not change any characters, it returns the original object_name string.
Format
STRING str_char_swap (STRING object_name, STRING swap_str, INT index)
417
418 Adams/Car
Arguments
object_name
swap_str
index
Examples
In the following Adams/Car example, lrrl is the string that defines what should be changed. The first half
of the string (lr) represents the valid "from characters." The second half of the string (rl) represents the
"to characters."
If the example finds one of the "from characters" at position 3 in the string
._front_susp.ground.hpl_lca_front, it replaces the "from characters" with the corresponding "to
characters." In this example, l would change to r.
variable set variable=symmetric_name &
string_value=(STR_CHAR_SWAP("._front_susp.ground.hpl_lca_front",
"lrrl", 3))
symmetric_name = "._front_susp.ground.hpr_lca_front"
str_filename
Definition
str_filename strips an input string (in_str) to a base file name (with extension) and then substitutes a new
string (new_str) for the old string (old_str) if the old string exists in the base name. If old_str occurs more
than once in the input string, str_filename only replaces the last occurrence.
Format
STRING str_filename (STRING in_str, STRING old_str, INT new_str)
Arguments
in_str
old_str
new_str
Examples
variable set variable=base_filename &
string_value=(STR_FILENAME("/usr/car.cdb/test.tpl", "tpl","sub"))
base_filename = "test.sub"
str_model_class
Definition
str_model_class returns a model's model class. This information is stored in the model_class variable
under all models. If no such variable exists within the model, str_model_class returns an empty string.
Typical model classes include template, subsystem, and assembly.
Format
STRING str_model_class (OBJECT model)
Arguments
model
A model entity.
Examples
variable set variable=current_class &
string_value=(STR_MODEL_CLASS(._front_susp))
current_class = "template"
str_prefix
Definition
str_prefix returns the generic prefix for a given string (object_name). The length of the return string is
always four characters long. str_prefix also pares the input down to only the string following the last . in
object_name.
Format
STRING str_prefix (STRING object_name)
Arguments
object_name
Examples
variable set variable=name_prefix &
string_value=(STR_PREFIX("._front_susp.ground.hpl_lca_outer"))
name_prefix = "hps_"
419
420 Adams/Car
str_remove
Definition
str_remove trims an input string (in_str) by removing a string (begin_str) from the beginning of in_str
and a string (end_str) from the end of in_str.
str_remove removes begin_str before removing end_str so if the beginning and ending string in in_str
overlap, str_remove only removes begin_str.
Format
STRING str_remove (STRING in_str, STRING begin_str, STRING end_str)
Arguments
in_str
begin_str
end_str
Examples
variable set variable=trim_string &
string_value=(STR_REMOVE("abcdef", "ab", "ef"))
trim_string = "cd"
variable set variable=trim_string &
string_value=(STR_REMOVE("abcdef", "", "ef"))
trim_string="abcd"
str_replace
Definition
str_replace replaces a string (old_str) with a new string (new_str) in the string in_str. If there are multiple
occurrences of old_str, str_replace replaces the last occurrence.
Format
STRING str_replace (STRING in_str, STRING old_str, STRING new_str)
Arguments
in_str
old_str
new_str
Examples
variable set variable=other_filename &
string_value=(STR_REPLACE("/usr/car.cdb/test.tpl", "test",
"junk"))
other_filename = "/usr/car.cdb/junk.tpl"
str_typecheck
Definition
str_typecheck returns a 1 if a list of characters (type) matches the third character in the base name of an
object's name (object_name). str_typecheck always pares down the input to only the string following the
last . in object_name.
You can specify more than one character in type.
Format
STRING str_typecheck (STRING object_name, STRING type)
Arguments
object_name
type
Examples
variable set variable=check_type &
string_value=(STR_TYPECHECK("._front_susp.ground.hpl_lca_outer",
"ls"))
check_type = 1
variable set variable=check_type &
string_value=(STR_TYPECHECK("._front_susp.ground.hpl_lca_outer",
"r"))
check_type = 0
Database Functions
The database functions let you manage and access the databases of your template-based product. The
database functions are:
cdb_alias2path
cdb_path2alias
cdb_input2base
cdb_input2ext
cdb_input2file
421
422 Adams/Car
cdb_input2path
cdb_input2full
cdb_search_file
cdb_runtime_path_port
cdb_alias2path
Definition
cdb_alias2path returns the full path associated with a given table path alias or cdb_name. If
cdb_alias2path does not find the full table path corresponding to the alias, it returns the input string. By
returning the input string, you can input normal path names and filenames, and cdb_alias2path returns
them without modification.
Format
STRING cdb_alias2path (STRING path_alias)
Arguments
path_alias
Examples
This example finds the file system path associated with database prototype:
variable set variable=a2p &
string_value=(eval(cdb_alias2path("prototype")))
a2p = "/local/proto.cdb"
cdb_path2alias
Definition
cdb_path2alias returns the path alias associated with a given table path alias or cdb_name. If
cdb_path2alias does not find a path alias corresponding to the full path name, it returns the input string.
By returning the input string, cdb_path2alias allows you to enter normal path names and filenames, and
returns them without modification.
Note:
Format
STRING cdb_path2alias (STRING path)
Arguments
path
Examples
This example finds the database alias associated with database:
variable set variable=p2a &
string_value=(eval(cdb_path2alias("/local/proto.cdb")))
p2a = "prototype"
cdb_input2base
Definition
cdb_input2base returns the base name of a file (input_name). It strips the input_name of both its file
system path prefixes and extension or suffix, if any.
Format
STRING cdb_input2base (STRING input_name)
Arguments
input_name
Examples
This example finds the base name for the file /local/proto.cdb/bushings.tbl/my_bush.bus:
variable set variable=i2b &
string_value(eval(cdb_input2base("/local/proto.cdb/bushings.tbl/m
y_bush.bus")))
i2b = "my_bush"
cdb_input2ext
Definition
cdb_input2ext returns the extension or suffix of a file (input_name). It returns an empty string if it finds
no extension
Format
STRING cdb_input2ext (STRING input_name)
423
424 Adams/Car
Arguments
input_name
Examples
This example finds the extension for the file /local/proto.cdb/bushings.tbl/my_bush.bus:
variable set variable=i2e &
string_value=(eval(cdb_input2ext("/local/proto.cdb/bushings.tbl/my
_bush.bus")))
i2e = "bus"
cdb_input2file
Definition
cdb_input2file returns the filename contained in input_name. cdb_input2file strips input_name of any
file system path prefix and returns the result.
Format
STRING cdb_input2file (STRING input_name)
Arguments
input_name
Examples
This example finds the filename for the file /local/proto.cdb/bushings.tbl/my_bush.bus:
variable set variable=i2file &
string_value=(eval(cdb_input2file("/local/proto.cdb/bushings.tbl/my_bush
.bus")))
i2file = "my_bush.bus"
cdb_input2path
Definition
cdb_input2path returns the file system path prefix of a filename. If the path prefix is not present,
cdb_input2path returns an empty string.
Format
STRING cdb_input2path (STRING input_name)
Arguments
input_name Filename to be converted into file system path prefix.
Examples
This example finds the file system path prefix for the file /local/proto.cdb/bushings.tbl/my_bush.bus:
variable set variable=i2p &
string_value=(eval(cdb_input2path("/local/proto.cdb/bushings.tbl/my_bush
.bus")))
i2p = "/local/proto.cdb/bushings.tbl"
cdb_input2full
Definition
cdb_input2full returns the file system path of a filename containing a database alias. If cdb_input2full
finds no database alias present, it returns the input string.
Format
STRING cdb_input2full (STRING input_name)
Arguments
input_name
Examples
This example finds the file system path for the file mdids://prototype/bushings.tbl/my_bush.bus:
variable set variable=i2full &
string_value=(eval(cdb_input2full("mdids://prototype/bushings.tbl/
my_bush.bus")))
i2full = "/local/proto.cdb/bushings.tbl/my_bush.bus"
cdb_search_file
Definition
cdb_search_file returns the file system path of the input file (filename). First, it checks to determine if
the filename as input corresponds to an existing file. It expands any database alias to its corresponding
file system path, and looks for the filename at the resultant location. If it finds no file, it removes any file
system path prefix from the filename, and begins its to search the different databases in the specified
search order.
Remember that search order may be important. If two identically named files exist in different databases,
the search order determines which of these files cdb_search_file finds and returns.
425
426 Adams/Car
cdb_search_file returns an empty string if it does not find the requested filename after searching the
databases.
Format
STRING cdb_search_file (STRING class_name, STRING filename, INT level)
Arguments
class_name
The type class name for the table in which to search for the file. It is defined in the
configuration files.
filename
level
The level in the search list at which to start searching. The value is usually 1, which
indicates a full search.
Examples
This example finds the file system path for file my_bush.bus:
variable set variable=sfile &
string_value=(eval(cdb_search_file("bushing","my_bush.bus",1)))
sfile="/local/proto.cdb/bushings.tbl/my_bush.bus"
cdb_runtime_path_port
Definition
cdb_runtime_path_port returns the filename of the input string (input_name) converted to the appropriate
operating system format. You will find cdb_runtime_path_port useful when you are sharing filenames
between UNIX and Windows file systems. It also lets you use a database alias instead of a full file system
path.
Format
STRING cdb_runtime_path_port (STRING input_name)
Arguments
input_name
Examples
This example returns the Windows version of the filename for the file
mdids://prototype/bushings.tbl/my_bush.bus:
variable set variable=rpp &
string_value=(eval(cdb_runtime_path_port(mdids://prototype/bushings.tbl/
my_bush.bus)))
rpp = "mdids://prototype\bushings.tb\my_bush.bus"
File Functions
The file functions return information about the major and minor roles of templates and subsystems:
template_hdr_major_role
subsystem_hdr_major_role
subsystem_hdr_minor_role
template_hdr_major_role
Definition
template_hdr_major_role returns the major role of a template. Your template-based product stores the
major role information in the header information of all template files (.tpl). template_hdr_major_role
automatically opens a template file, retrieves the information from the file header, and closes the file.
Format
STRING template_hdr_major_role (STRING filename)
Arguments
filename
Examples
This is an example of the header information that is stored in an Adams/Car template file:
$------------------------TEMPLATE_HEADER----------------------$
[TEMPLATE_HEADER]
MAJOR_ROLE = 'suspension'
TIMESTAMP ='1999/02/04,13:13:38'
HEADER_SIZE = 5
The following example returns the major role of a template, which it obtains from the header information
shown above:
variable set variable=tpl_major_role &
string_value=(TEMPLATE_HDR_MAJOR_ROLE
("mdids://shared/template.tbl/_dbl_wish.tpl"))
tpl_major_role = "suspension"
427
428 Adams/Car
subsystem_hdr_major_role
Definition
subsystem_hdr_major_role returns the major role of a subsystem. Your template-based product stores the
major role information in the headerinformation of all subsystem files (.sub). subsystem_hdr_major_role
automatically opens a subsystem file, retrieves the information from the file header, and closes the file.
Format
STRING subsystem_hdr_major_role (STRING filename)
Arguments
filename
Examples
This is an example of the header information that is stored in an Adams/Car subsystem file:
$--------------------------SUBSYSTEM_HEADER -----------------------$
[SUBSYSTEM_HEADER]
TEMPLATE_NAME = mdids://shared/templates.tbl/_double_wishbone.tpl
MAJOR_ROLE = suspension
MINOR_ROLE = front
TIMESTAMP = 1999/02/04,17:18:18
The following example returns the major role of an Adams/Car subsystem, which it obtains from the
header information shown above:
variable set variable=sub_major_role &
string_value=(SUBSYSTEM_HDR_MAJOR_ROLE("mdids://shared/subsystem.tbl/
front_susp.sub"))
sub_major_role = "suspension"
subsystem_hdr_minor_role
Definition
subsystem_hdr_minor_role returns the minor role of asubsystem. Your template-based product stores the
minor role information in the header information of all subsystem files (.sub).
subsystem_hdr_minor_role automatically opens a subsystem file, retrieves the information from the file
header, and closes the file.
Format
STRING subsystem_hdr_minor_role (STRING filename)
Arguments
filename
Examples
This is an example of the header information that is stored in an Adams/Car subsystem file:
$------------------------SUBSYSTEM_HEADER ----------------------$
[SUBSYSTEM_HEADER]
TEMPLATE_NAME = mdids://shared/templates.tbl/_double_wishbone.tpl
MAJOR_ROLE= suspension
MINOR_ROLE= front
TIMESTAMP= 1999/02/04,17:18:18
The following example returns the minor role of an Adams/Car subsystem, which it obtains from the
header information shown above:
variable set variable=sub_minor_role &
string_value=(SUBSYSTEM_HDR_MINOR_ROLE("mdids://shared/subsystem
.tbl/front_susp.sub"))
sub_minor_role = "front"
model_class_exists
Definition
model_class_exists lets you easily determine if a model of a particular model class exists in the current
session. model_class returns a 1 if a model of the specified model class exists.
Your template-based product stores the model class information in the model_class variable under all
models. Typical model classes include template, subsystem, and assembly.
Format
INT model_class_exists (STRING model_class)
429
430 Adams/Car
Arguments
model_class
Examples
if condition=(model_class_exists("assembly") == 0)
! No Assemblies !
end
subsystem_lookup
Definition
subsystem_lookup returns the subsystem contained in the assembled model with the specified major and
minor role. If no such subsystem exists, subsystem_lookup returns no object or NONE.
Format
OBJECT subsystem_lookup (OBJECT model, STRING major_role, STRING minor_role)
Arguments
model
major_role
minor_role
Examples
variable set variable=front_susp_subsystem &
object_value=(eval(SUBSYSTEM_LOOKUP(.susp_assy, "suspension",
"front")))
front_susp_subsystem = .susp_assy.TR_Front_Suspension
subsystem_role_exists
Definition
subsystem_role_exists lets you easily determine if a subsystem of a particular role exists in an assembled
model. subsystem_role_exists returns a 1 if the assembled model contains such a subsystem. Your
template-based product stores the role information in the role variable that exists in each subsystem.
Format
INT subsystem_role_exists (OBJECT model, STRING role)
Arguments
model
role
Examples
if condition=(subsystem_role_exists(.fveh_assembly, "brake_system")
== 0)
! No Brakes !
end
Miscellaneous Functions
This topic lists utility functions that help you extend the Adams/View macro language. The functions
help you access information that is not easy to access using the standard Adams/View macro language.
You can use the utility functions in macros and in dialog boxes.
ac_info_mass
ac_info_mass
Definition
ac_info_mass computes the aggregate mass of the assembly.
Format
ac_info_mass(OBJECT model)
Arguments
model
Examples
variable set variable_name=total_mass &
real_value=(EVAL(ac_info_mass(.model_name)))
431
432 Adams/Car
For example, when a group of users needs to access the same information or are working on the same
project, you can create a custom site repository. By having a site repository, they can share site-specific
versions of the template-based product and configuration files.
Also, a private repository is a convenient way for a single user to create several custom versions of a
template-based product or to work on different projects. Private locations let you create an unlimited
number of site binaries and libraries.
In the site or private repository, your template-based product creates a directory structure that mimics the
installation directory structure. The directory contains subdirectories for each platform for which you
created a binary or a library.
You control the location of the private repository using the privateDir setting. The privateDir setting tells
Adams where to locate the appropriate files and where to store the resulting files. The default location of
the private repository is as follows:
Default Location of Private Repository
Product name:
File name:
Adams/Car $HOME/acar_private
Where $HOME represents your user home directory when you log on to your computer.
Note:
The following procedures show how you can define the site and private repositories for
Adams/Car. Follow the same basic procedures to define the site repository for your
template-based product.
mdi -c rtool
set /MDI/ACar/Preferences/siteDir /usr/people/someone/acar_site
To define the site repository in Windows:
1. From the Start menu, point to Programs, point to MSC.Software, point to MD Adams R3, and
then select Adams - Settings.
2. Double-click the name of your product (ACar).
3. Select Preferences.
4. To the right of siteDir, in the Value column, enter (or right-click to browse for) a directory path,
such as d:\acar_custom.
5. Select Apply or OK.
Defining Private Repositories
To define the private repository in UNIX:
In Adams Toolbar, change the privateDir setting in the Adams/Car preferences. For example,
change it to:
/usr/people/someone/new_private
You can also change the privateDir setting using the Registry Shell Tool from the command
433
434 Adams/Car
Creating and Running a Macro: Introduces the concepts of creating and running a macro for the
C:\MSC.Software\Adams\MDR2\acar\examples\fourpost\customization_example.
/usr/MSC.Software/MDR2acar/examples/fourpost/customization_example.
MD Adams R3, and then select Adams - Command. In the command window, type acar;
cr-sitebin
Adams/Car automatically executes acar_build.cmd and builds all the appropriate entities and
libraries into a site version of the Adams binary file.
3. To run the site binary file, follow the steps outlined above, but replace the cr-sitebin command
with ru-site.
Test Description
You can use the four-post test rig to investigate the vertical dynamics of the full vehicle and its
suspension systems. You can then plot the time-based results and study them in the frequency domain to
understand the various ride modes and their respective damping levels. The investigation will also help
you learn more about the influences of the vehicle's vertical dynamics effects on handling behavior by
studying the system's dynamic responses, which includes:
Front-to-rear modal balance
Suspension-to-body transfer function gain and phase
Suspension-to-tire transfer function gain and phase
Tire contact patch vertical load variation
The test involves assembling a standard full-vehicle model to a four-post test rig. The test rig is defined
by four parts representing the tire pads that support the vehicle. The tire pads are constrained to move
only in the vertical direction and a displacement actuator, or motion controller, controls their vertical
motion.
The only constraint between the pads and the vehicle's tires is the friction of the tires.
Not all tire models have adequate zero speed modeling for being used with the four-post rig test: a rolling
tire acts as a damper because the force response depends on tire slip speeds; a non-rolling tire should act
as a spring and forces must depend on tire deflection.
The following tire models support the four-post rig test:
PAC2002, in transient mode, USE_MODE >10
PAC-TIME, in transient mode, USE_MODE >10
PAC-MC, in transient mode, USE_MODE >10
UA-Tire, in transient mode, USE_MODE = 2
Ftire
Note:
By default, the PAC2002 tire model is not used in the assembly packed in the examples
directory. The simulation will not succeed if the default Pacejka '89 tire is used.
An analytical function controls the vertical actuators. Analytical functions also describe the
displacement profile of the actuator in the time domain and they are limited to constant amplitude
sinusoidal input that sweeps over a predetermined frequency range in a set amount of time. When using
the analytical function control, users can use four excitation modes:
Heave - All tire pads move vertically in phase.
435
436 Adams/Car
Pitch - The front tire pads move 180o out of phase with the rear tire pads.
Roll - The left tire pads move 180o out of phase with the right tire pads.
Warp - The left-front and right-rear tire pads move 180o out of phase with the right-front and
left-rear pads.
We recommend that you add the database to your configuration file. Otherwise, when you submit
an analysis, the solver does not know about this new database search path, and consequently will
not read the appropriate tire files.
Open the assembly contained in the cdb database as follows:
1. From the File menu, point to Open, and then select Assembly.
2. Open the MDI_Vehicle_4PostRig.asy.
You can also create a new assembly by doing the following:
1. From the File menu, point to New, and then select Full-Vehicle Assembly.
2. Select the appropriate subsystem files.
3. Change the vehicle test rig from __MDI_SDI_TESTRIG to __acme_4PostRig.
4. Select OK.
Running a Test
You should have a full-vehicle assembly mounted to the four-post test rig as shown next.
Note:
You must change the tires from Pacejka '89 model to one of the following tire models:
PAC2002, in transient mode, USE_MODE >10
PAC-TIME, in transient mode, USE_MODE >10
PAC-MC, in transient mode, USE_MODE >10
UA-Tire, in transient mode, USE_MODE = 2
Ftire
You can find these tires in the supplied database shipped in the examples directory. Failure to switch
these tires will result in a solver failure while trying to run an analysis.
437
438 Adams/Car
Because we have not provided a custom dialog box or interface to submit one of the tests outlined above,
you must use the autogenerated dialog box associated with the Command Navigator:
1. To open the Command Navigator, from the Tools menu, select cp10 Navigator.
2. To run a full-vehicle analysis with the four-post test rig, you must select acme -> analysis ->
full_vehicle -> four_post -> submit (double-click).
Adams/Car displays the following dialog box (without the values, which we added for your
convenience):
3. After the analysis is completed, review the results using the animation and post-processing tools.
439
440 Adams/Car
User-Input Parameters
Analysis input parameters are the values that you enter to control a simulation or some other event in the
template-based products. Analysis input parameters can be grouped into two categories:
Parameters common to all analyses:
Output prefix
End time
Number of steps
Type of analysis (interactive, background)
Analysis log file (yes, no)
Parameters specific to this four-post test rig. You use the four-post simulation input parameters
to define the boundary conditions of the desired vertical excitation test. The parameters are:
Peak displacement
Displacement units (such as m, mm, inch)
Frequency range (units hardcoded to Hz)
Excitation mode (heave, pitch, roll, or warp)
To avoid aliasing of the input during the simulation, users should set the maximum time step that the
integrator is allowed to take (HMAX argument on the integrator) to at least 1/10 of the maximum
frequency range. For example, if the frequency range you set is 20 Hz, then the HMAX should be
1/10*1/20 = 1/200 (0.005).
Creating the Macro
This four-post vertical excitation example provides instructions to help youcreate your own macro based
on a given user scenario. The objective of the analysis is described in Test Description.
Creating the macro involves the following:
Defining Parameters
Handling Errors
Reading Property Files
Setting Up the Assembly and Test Rig
Submitting the Analysis
Logging the Analysis Results
Finishing up the Macro
Defining Parameters
We determined the parameters for the four-post analysis macro from User-Input Parameters (for a
description of the parameters whose values are important for the success of thefour-post simulation, see
the table Parameter Descriptions):
! $assembly:t=model
! $output_prefix:t=string
! $comment:t=string:d=""
! $end_time:t=real:gt=0
! $number_of_steps:t=integer:gt=0
! $analysis_mode:t=list(interactive,graphical,background):d=interact
ive
! $peak_displacement:t=real:gt=0
! $units:t=list(mm):d=mm
! $frequency_range:t=real:gt=0
! $excitation_mode:t=list(heave,pitch,roll,warp):d=heave
! $load_results:t=list(yes,no):u=yes
441
442 Adams/Car
! $log_file:t=list(yes,no):u=yes
! $error_variable:t=variable:d=.ACAR.variables.errorFlag
Parameter Descriptions
Parameter name:
Description:
assembly
output_prefix
String value that specifies the name of the analysis. This name is used to write
the analysis files (.adm, .acf, and so on) to the file system and also when the
solver files are read back into Adams/Car.
comment
Stores comments in the Adams dataset, d=" "; d specifies default, which is an
empty string.
end_time
Real value that tells Adams/Solver the end time of the four-post analysis. gt=0;
gt specifies greater than.
number_of_steps
analysis_mode
String value that specifies the mode of the analysis. The three valid modes are
interactive, background, or graphical; the list specifies the valid options.
peak_displacement Indicates
units
frequency_range Real
Hardcoded to millimeters for tutorial, but you can expand it to include other
units.
value indicating the frequency range of the actuator motion functions.
excitation_mode
List value that indicates the direction of the shaker pad motions.
load_results
Specifies whether to load the results once Adams/Solver has finished the
analysis. The default is yes.
log_file
Handling Errors
With this macro, users must perform the four-post analysis with the .__acme_4PostRig test rig described
in Test Rig Description. The assembly and test rig perform actions based on the elements that exist in the
.__acme_4PostRig test rig. Therefore, as part of error checking, the macro checks for the correct test rig.
For a description of the setup of the assembly and test rig, see About the Simulation Process.
In addition to verifying that the user is using the correct test rig, the macro also checks if the analysis
name is unique for this assembly. Notice that we use indenting and comments to make the macro easier
to read; as with all programming languages, this is a good practice to get into.
variable set variable_name=$error_variable integer=0
!---- Check to ensure the assembly has the proper test rig ---if condition=($assembly.original_testrig_name != "__acme_4PostRig")
acar toolkit warning &
w="Analysis cannot be submitted!", &
"The assembly does not have the proper testrig. This analysis only", &
"works with assemblies using the '__acme_4PostRig' testrig."
variable set variable_name=$error_variable integer=1
return
end
!---- Check if analysis name already exists ---if condition=(db_exists("$assembly.$'output_prefix'_fourpost"))
if condition=(alert("question","An analysis called
\'$'output_prefix'_fourpost\' &
already exists. Overwrite it?","Yes","No","",2)
== 2)
variable set variable_name=$error_variable integer=1
return
end
end
echo_to_logfile=no
443
444 Adams/Car
reference markers only occurs once for a particular assembly. If you use the same assembly for multiple
four-post analyses, the initial setup will be valid for each analysis.
For each wheel, the tire reference marker is assigned to a shaker pad. The first step is to find each tire in
the full-vehicle assembly. The reassignment occurs through an output communicator in the test rig. The
communicator holds the name of the part on the shaker pad where you should attach the tire reference
marker.
if condition=(!db_exists("$assembly.fourpostSetup"))
!--- Parameterize the 4post pad height to the global road height marker
just previously adjusted --marker modify &
marker_name=$assembly.testrig.ground.std_tire_ref &
location=($assembly.ground.std_tire_ref.location) &
relative_to=$assembly.testrig.ground
variable set variable=$_self.frontWheel &
object_value=(eval(subsystem_lookup($assembly,"wheel","front")))
variable set variable=$_self.leftFrontWheel &
object_value=(eval(db_filter_name(db_children($_self.frontWheel[1],"ac_ti
re"),"til_*")))
variable set variable=$_self.rightFrontWheel &
object_value=(eval(db_filter_name(db_children($_self.frontWheel[1],"ac_ti
re"),"tir_*")))
variable set variable=$_self.rearWheel &
object_value=(eval(subsystem_lookup($assembly,"wheel","rear")))
variable set variable=$_self.leftRearWheel &
object_value=(eval(db_filter_name(db_children($_self.rearWheel[1],"ac_tir
e"),"til_*")))
variable set variable=$_self.rightRearWheel &
object_value=(eval(db_filter_name(db_children($_self.rearWheel[1],"ac_tir
e"),"tir_*")))
marker modify &
marker_name=(eval($_self.leftFrontWheel.object_value.ref_marker.object_va
lue)) &
new_marker_name=
(eval($assembly.testrig.col_front_pad_mount[1]//"."//$_self.leftFrontWheel.o
bject_value.ref_marker.object_value.name))
marker modify &
marker_name=(eval($_self.rightFrontWheel.object_value.ref_marker.object_v
alue)) &
new_marker_name=(eval($assembly.testrig.cor_front_pad_mount[1]//
"."//$_self.rightFrontWheel.object_value.ref_marker.object_value.name))
marker modify &
marker_name=(eval($_self.leftRearWheel.object_value.ref_marker.object_val
ue)) &
new_marker_name=(eval($assembly.testrig.col_rear_pad_mount[1]//"."//$_sel
f.leftRearWheel.object_value.ref_marker.object_value.name))
marker modify &
marker_name=(eval($_self.rightRearWheel.object_value.ref_marker.object_va
lue)) &
new_marker_name=(eval($assembly.testrig.cor_rear_pad_mount[1]//"."//$_sel
f.rightRearWheel.object_value.ref_marker.object_value.name))
variable set variable=$assembly.fourpostSetup &
integer_value=1
end
You must reset the motion actuators drivingthe displacement of the shaker pads for each individual fourpost analysis. This is in contrast to the tire reference marker setup, described in the previous paragraphs,
which needs to occur only once for a particular assembly, and remains valid for all successive four-post
analyses.
Each of the four shaker pads will have the same magnitude of motion, but a specific excitation mode will
determine the direction of the motion:
Heave mode - All four shaker pads move in the same direction.
Pitch mode - The front and rear tires move in opposite directions.
Roll mode - The left and right tires move in opposite directions.
Warp mode - The left front and right rear tires move opposite to the direction traveled by the
You set the different excitation modes by specifying a 1 or -1 multiplier at the beginning of the actuator
function definition, as shown next:
!---- Assign actuator functions based on excitation mode ---!-Heave Excitation
if condition=("$excitation_mode" == "heave")
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_front_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_front_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
!-- Pitch Excitation
elseif condition=("$excitation_mode" == "pitch")
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_front_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_front_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
!-- Roll Excitation
elseif condition=("$excitation_mode" == "roll")
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_front_actuator
&
445
446 Adams/Car
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_front_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
!-- Warp Excitation
elseif condition=("$excitation_mode" == "warp")
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_front_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_front_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_left_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_time*time**2)"
acar template_builder actuator set function &
actuator=$assembly.testrig.jms_right_rear_actuator
&
function="1*$peak_displacement*sin(.5*360d*$frequency_range/$end_tim
e*time**2)"
end
&
The following table describes the important parameters associated with the four-post full-vehicle
submission macro.
Parameter name:
Description:
load_results
String value that specifies if the results of the analysis should be read in
after the analysis is complete. Expected values are yes or no.
road_data_file
generate_road_geometry
simulation_type
&
if condition=("$analysis_mode" != "background")
acar toolkit message &
message="Simulation is complete."
end
Finishing up the Macro
Delete all local variables created in the macro using the $_self nomenclature:
variable delete variable_name=(eval(db_children($_self,"variable")))
447
448 Adams/Car
When you access the four-post macro from the Command Navigator, Adams/Car automatically creates
a dialog box based on the parameters in the macro. Users can use this dialog box, shown next, to execute
the macro and submit the four-post analysis.
Modify the Load Results pull-down menu to be radio boxes, and then decrease the area they
occupy.
Shorten the Brief and Log File pull-down menus to match the Load Results radio boxes.
449
450 Adams/Car
You can add the four-post custom dialog box to either the private or site binary (or interactively read it
in during your Adams/Car session). The command shown next creates the dialog box by reading in the
command file found at the location you specify or we have provided an example dialog box in the
examples directory (install_dir\acar\examples\fourpost\customization_example\analysis\dboxes).
We have also provided dboxes_ana.cmd in the example, which contains the following code.
You must place these commands either in the acar_build.cmd file as described in Configuring Your
Product or place a command in the macros_ana.cmd file to read the dboxes_ana.cmd file.
!---- Check if dialog box exists and delete it if it does ---if condition=(db_exists(".acar.dboxes.dbox_ana_ful_fou_sub"))
interface dialog_box delete
dialog_box_name=.acar.dboxes.dbox_ana_ful_fou_sub
end
!---- Read the Fouir Post shaker dialog box ----
451
452 Adams/Car
Examples
Examples
Getting Started Using Adams/Driveline
Example Files:
Example Bearing Property File
Example Clutch-Force Property File
Example Complex-Spring Property File
Engine Map Property File
Example Hypoid Gear-Forces Property File
Example Ride-Wheel Property File
Example Torque-Converter Property File
Example Viscous-Coupling Property File