Adams_2020_Adams_Vibration_User_Guide

Adams 2020
Adams Vibration User's Guide

Corporate Europe, Middle East, Africa
MSC Software Corporation MSC Software GmbH
4675 MacArthur Court, Suite 900 Am Moosfeld 13
Newport Beach, CA 92660 81829 Munich, Germany
Telephone: (714) 540-8900 Telephone: (49) 89 431 98 70
Toll Free Number: 1 855 672 7638 Email: europe@mscsoftware.com
Email: americas.contact@mscsoftware.com
Japan Asia-Pacific
MSC Software Japan Ltd. MSC Software (S) Pte. Ltd.
Shinjuku First West 8F 100 Beach Road
23-7 Nishi Shinjuku #16-05 Shaw Tower
1-Chome, Shinjuku-Ku Singapore 189702
Tokyo 160-0023, JAPAN Telephone: 65-6272-0082
Telephone: (81) (3)-6911-1200 Email: APAC.Contact@mscsoftware.com
Email: MSCJ.Market@mscsoftware.com
Worldwide Web
www.mscsoftware.com
Support
http://www.mscsoftware.com/Contents/Services/Technical-Support/Contact-Technical-Support.aspx
Disclaimer
This documentation, as well as the software described in it, is furnished under license and may be used only in accordance with the
terms of such license.
MSC Software Corporation reserves the right to make changes in specifications and other information contained in this document
without prior notice.
The concepts, methods, and examples presented in this text are for illustrative and educational purposes only, and are not intended
to be exhaustive or to apply to any particular engineering problem or design. MSC Software Corporation assumes no liability or
responsibility to any person or company for direct or indirect damages resulting from the use of any information contained herein.
User Documentation: Copyright © 2020 MSC Software Corporation. Printed in U.S.A. All Rights Reserved.
This notice shall be marked on any reproduction of this documentation, in whole or in part. Any reproduction or distribution of this
document, in whole or in part, without the prior written consent of MSC Software Corporation is prohibited.
This software may contain certain third-party software that is protected by copyright and licensed from MSC Software suppliers.
Additional terms and conditions and/or notices may apply for certain third party software. Such additional third party software terms
and conditions and/or notices may be set forth in documentation and/or at http://www.mscsoftware.com/thirdpartysoftware (or successor
website designated by MSC from time to time). Portions of this software are owned by Siemens Product Lifecycle Management, Inc.
© Copyright 2020
The MSC Software logo, MSC, MSC Adams, MD Adams, and Adams are trademarks or registered trademarks of MSC Software
Corporation in the United States and/or other countries. Hexagon and the Hexagon logo are trademarks or registered trademarks of
Hexagon AB and/or its subsidiaries. FLEXlm and FlexNet Publisher are trademarks or registered trademarks of Flexera Software.
Parasolid is a registered trademark of Siemens Product Lifecycle Management, Inc. All other trademarks are the property of their
respective owners.
ADAM:V2020:Z:Z:Z:DC-VIB
Documentation Feedback
At MSC Software, we strive to produce the highest quality documentation and welcome your feedback.
If you have comments or suggestions about our documentation, write to us at: documentation-
feedback@mscsoftware.com.
Please include the following information with your feedback:
 Document name
 Release/Version number
 Chapter/Section name
 Topic title (for Online Help)
 Brief description of the content (for example, incomplete/incorrect information, grammatical
errors, information that requires clarification or more details and so on).
 Your suggestions for correcting/improving documentation
You may also provide your feedback about MSC Software documentation by taking a short 5-minute
survey at: http://msc-documentation.questionpro.com.
Note: The above mentioned e-mail address is only for providing documentation specific
feedback. If you have any technical problems, issues, or queries, please contact Technical
Support.
Welcome to Adams Vibration
Introduction to Adams Vibration

Adams Vibration is an Adams plugin for performing frequency-domain analyses. Using Adams Vibration,
you can study forced vibrations within your Adams models. For example, you can simulate driving an
automobile over a bumpy road an measure its frequency response. Both inputs and outputs are described in
the frequency domain.
Using Adams Vibration, you can:

 Analyze the forced response of a model in the frequency domain over different operating points.
 Include the effects of hydraulics, controls, and user-subsystems in the frequency analysis.
 Transfer your linearized model from Adams products to Adams Vibration completely and quickly.
 Create input and output channels for vibration analyses.
 Specify frequency domain input functions, such as swept sine amplitude/frequency, power spectral
density (PSD), and rotational imbalance.
 Create user-defined, frequency-based forces.
 Solve for system modes over frequency range of interest.
 Evaluate frequency response functions for magnitude and phase characteristics.
 Animate forced response and individual mode response.
 Tabulate system modal contributions to forced vibration response.
 Tabulate contribution of model elements to kinetic, static, and dissipative energy distribution in
system modes.
 Perform modal stress recovery of flexible bodies.
 Specify direct kinematic inputs.
 Plot Stress/Strain FRFs
Adams Vibration Process

Using Adams Vibration, you can assemble models of various subsystems, perform linear vibration analysis,
and use Adams post-processing tools to view results as plots and animations.
2 Adams Vibration
How You Benefit from Using Adams Vibration

Adams Vibration enables you to work faster and smarter, letting you replace physical testing for vibration
studies using shaker devices with virtual testing. Physical testing with shaker devices in the test lab or in the
field is expensive and can typically only occur at later stages of the design process. Using Adams Vibration,
you can perform these tests early in the design process cutting down on design time and expense.
It is impossible to eliminate all vibration from products that are made up of flexible components. It is
possible, however, to design products that do not have bothersome vibrations. For example, at certain speeds,
3
poorly designed automobiles can have annoying noises that are due to vibrations of certain components.
Some companies have design guidelines that indicate acceptable ranges of vibration frequencies.
Adams Vibration output data can be used in noise/vibration/harshness (NVH) studies to predict the impact
of vibration on the rider's experience in an automobile, train, plane, and so on.
Loading and Unloading Adams Vibration

Adams Vibration runs as a plugin to several products: Adams View, and Adams Car. After you start a core
product, you then load the Adams Vibration plugin. To work with an existing Adams model, you can load
the Adams Vibration plugin either before or after you import the model. You can also create a model in
another Adams product and then load the Adams Vibration plugin.
When you import a model that already contains Adams Vibration data, you do not have to load the Adams
Vibration plugin manually; the core product automatically loads the plugin for you. This section shows you
how to load the Adams Vibration plugin into Adams View. Loading the plugin into other core products is
similar.
To load Adams Vibration:

1. From the Tools menu, point to Plugin Manager.
2. Select the Load checkbox next to Adams Vibration.
3. Select OK.
The Adams Vibration plugin loads in Adams View. If you get an error message, you might have a
problem with your licensing. Contact your system administrator or your Adams contact person.
To unload Adams Vibration:

1. From the Tools menu, point to Plugin Manager.
2. Clear the Load checkbox next to Adams Vibration.
3. Select OK.
Starting Adams Vibration

To start Adams Vibration, you must first start Adams View (or one of the Adams vertical products), and then
load the Adams Vibration plugin.
To start Adams View and import your model:

1. Do either of the following depending on the platform on which you are running Adams View:
• On Linux, type the command to start the Adams Toolbar at the command prompt, and then
press Enter. Select the Adams View tool.
• On Windows, from the Start menu, point to Programs, point to Adams 2020, and then select
Adams View.
The Welcome dialog box appears in the Adams View main window.
4 Adams Vibration
2. Select Import a File.

3. Select the Find Directory tool next to the Start in text box. This displays the Find Directory dialog
box.
The Start in text box specifies the working directory that Adams Vibration uses as the default
directory for reading and writing files.
4. Navigate to the working directory.
5. Select OK
This ensures that all your work gets stored in the working directory you selected.
6. Select OK.
The File Import dialog box appears.
7. Right-click the File to Read text box, and select Browse.
8. Select your model file.
9. Select OK.
Adams Vibration opens and displays the model.
10. Load the Adams Vibration plugin. Learn how.
Building Your Model
FD Dampers
When you are given experimentally measured component force magnitude and phase data in the frequency
domain, you can use a frequency-dependent (FD) element to represent it in an Adams simulation. Using an
FD identification tool, you can compute FD coefficients to best fit the measured data. There are four
different forms of FD components:
 Pfeffer Linear
 Simple FD
 Simple FD Bushing
 General
The Pfeffer model has a specific representation (see Reference 2 below).
Once you create and verify an FD modeling element in Adams Vibration, you can use it in a time-domain
analysis.
References:
1. Knowledge Base Article 12294: AVB-013: Frequency Dependent (FD) Modeling Elements
(http://simcompanion.mscsoftware.com/KB8016149).
2. Pfeffer, P. and Hofer, K. Simple non-linear model for elastomer and hydro mountings, ATZ Worldwide,
104, 5/2002, May, 2002, 5-7, ISSN: 000 12785.
To create or modify an FD damper:

1. From the Vibration menu, point to Build, point to FD Damper or FD 3D Damper, and then select
New (to create an FD damper) or Modify (to modify an FD damper).
2. Depending on the type of FD damper you are creating or modifying, follow the instructions in the
dialog box help for Create/Modify FD 3D Damper or Create/Modify FD Damper.
3. Select OK.
To delete an FD damper:
1. From the Vibration menu, point to Build, point to FD Damper or FD 3D Damper, and then select
Delete.
2. From the Database Navigator, select the FD damper you want to delete.
3. Select OK.
Input Channels
Input channels provide a port into your system so you can plot the frequency response or drive your system
with an input force using a vibration actuator. You must create an input function to vibrate your system. A
vibration actuator applies an input force to vibrate the system. A vibration actuator can contain expressions
8 Adams Vibration
Building Your Model
that let you use both time and frequency inputs. Each input channel must reference only one vibration
actuator. Each vibration actuator, however, can be associated with multiple input channels.
To create an input channel:

1. From the Vibration menu, point to Build, point to Input Channel, and then select New.
2. Follow the instructions in the dialog box help for Create/Modify Vibration Input Channel.
3. Select OK.
To delete an input channel:

1. From the Plugins Tab, select Vibration container. Click and point to Build, point to Input Channel,
and then select Delete.
2. From the Database Navigator, select the input channel you want to delete, and then select OK.
3. In the message window that appears, select one of the following:
 Delete All - Deletes the input channel and all of its dependents.
 Remove Parametric Expressions - Deletes the input channel after removing all of its parametric
dependencies.
 Cancel - Stops the process without deleting the input channel.
To modify an input channel:

1. From the Plugins Tab, select Vibration container. Click and point to Build, point to Input Channel,
and then select Modify.
2. Select the input channel you want to modify.
3. Select OK.
4. Modify the vibration actuator, as needed, by performing the following:
 If you want to associate the input channel with a new actuator, select Actuator Parameters, and
enter the appropriate information.
 If you want to create a new vibration actuator, select Existing Actuator, and perform one of the
following:
9
Building Your Model
• Enter the name of the vibration actuator you want to reference.

• Right-click, select Vibration_Actuator and use the Guesses or Browse to select the vibration
actuator.
5. If you want to, modify other parameters as described in Create/Modify Vibration Input Channel.
6. Select OK.
Output Channels
Output channels provide ports in your system at which you examine the frequency response of the system.
You can think of output channels as instrumentation ports where you can measure system response and report
the results directly in the frequency domain. Output channels can be any valid Adams Solver run-time
function, but are typically displacements, velocities, or accelerations.
To create an output channel:

1. From the Plugins Tab, select Vibration container. Click and point to Build, point to Output
Channel, and then select New.
2. Follow the instructions in the dialog box help for Create/Modify Vibration Output Channel.
Note: Measures are not fully supported. To avoid syntactical warnings or errors, be sure to
enter the run-time function directly.
3. Select OK.
To delete an output channel:

Channel, and then select Delete.
2. From the Database Navigator, select the output channel you want to delete, and then select OK.
3. In the message window that appears, select one of the following:
• Delete All - Deletes the output channel and all of its dependents.
• Remove Parametric Expressions - Deletes the output channel after removing all of its
parametric dependencies.
• Cancel - Stops the process without deleting the output channel.
To modify an output channel:

Channel, and then select Modify.
2. Enter the name of the output channel you want to modify.
3. Modify the output channel, as needed, as described in Create/Modify Vibration Output Channel.
10 Adams Vibration
Building Your Model
4. Select OK.
Vibration Actuators
Vibration actuators are an Adams Vibration function definition, such as a periodic sine curve, a step, or a
spline curve, used to drive an input channel during a forced vibration analysis. The different types are:
 Power Spectral Density
 Rotating Mass
 Swept Sine
 User-Defined Function
Power Spectral Density

The PSD vibration actuator is defined using a spline function. You can specify either a force PSD or a
kinematic PSD.
You can specify that different PSD input channels are in cross correlation with each other; the corresponding
off-diagonal terms are automatically created for the frequency domain analysis. See the PSD Cross Correlation
dialog box.
Learn about computing Power Spectral Density (PSD).
Note: You cannot combine vibration actuators of the non-PSD-type with PSD-type vibration
actuators in the same vibration analysis.
Rotating Mass
A rotating mass applies a frequency-dependent force. This actuator represents the force due to a rotating mass
located at a specified radial offset (distance perpendicular to the axis of rotation). The axis of rotation is
defined by the input channel to which this vibrational actuator is applied.
2
f(ω) = m ⋅ ω ⋅ r
where:
 ω is the frequency
 f ( ω ) is the unbalanced mass forcing function
 m is the unbalanced mass
 r is the radial offset of the unbalanced mass from the axis of rotation
11
Building Your Model
Similarly, a rotating mass placed at a distance offset normal to the plane (distance along the axis of rotation)
results in an unbalanced moment.
2
t(ω) = m ⋅ ω ⋅ r ⋅ d
where:
 t ( ω ) is the moment due to unbalanced mass with offset

 d is the offset normal to the plane of the unbalanced mass (along the axis of rotation.)
12 Adams Vibration
Building Your Model
Example
1. Assume one mass (green) in the figure. The leading Force Direction represents the direction of
2
centrifugal force ( mr ω ) and points perpendicularly from the axis of rotation to the mass (y-axis in
figure). Radial Offset is the perpendicular distance from the axis of rotation to the mass.
2. The lagging Force Direction axis points perpendicularly from the axis of rotation to where the mass
will be after 90 degrees of rotation (z-axis in figure). Thus it determines the direction of rotation.
3. The leading moment is the moment created by centrifugal force. The Torque Axis is the moment
vector created by centrifugal force (z axis in figure). If it is a negative axis, use -d/2 for the "Offset
Normal to Plane" or create another marker with an axis pointing in the opposite direction. If a second
mass is present as shown (brown), the entered mass value will be the same but the "Offset Normal to
Plane" will be twice what you would enter for the single mass case.
The lagging Torque Axis is where the moment vector will point after 90 degrees of rotation (-y axis in the
figure). If it is a negative axis, use -d/2 for the "Offset Normal to Plane" or create an-other marker with an
axis pointing in the opposite direction. If a second mass is present as shown (brown), the entered mass value
will be the same but the "Offset Normal to Plane" will be twice what you would enter for the single mass case.
Swept Sine
Swept sine defines a constant amplitude sine function being applied to the model. The amplitude of the sine
function and the starting phase angle are required and must be specified in the Create Vibration Actuator
dialog box.
f ( ω ) = F • [ cos ( θ ) + j • sin ( θ ) ]
13
Building Your Model
where:
 f is the forcing function
 F is the magnitude of the force
 θ is the phase angle
User-Defined Function
You can define any function of the independent variable omega:
f(ω) = g(ω)
where:
 g ( ω ) is the general function of omega
Note: When the function is evaluated, omega is populated with each frequency from the vibration
analysis.
Macro for Removing Vibration Objects

You can use a utility macro to clean out all vibration entities from a model. This is useful when you want to
share your model with other Adams users who will not be using the model for Adams Vibration analysis,
allowing them to start with a clean model.
Issue the command associated with the macro from the command line. For example:
mdi vibration model cleanup model=YourModel retain_fd_dampers=no
Note:  YourModel is the name of the model from which you want the objects deleted.
 retain_fd_dampers defines whether or not FD damper elements will remain in the model.
If set to no, they are deleted. If set to yes, FD damper elements will remain, but all other
vibration entities, such as input or output channels, will be removed.
14 Adams Vibration
Building Your Model
Testing Your Model
Analyses and Scripts
Creating and Running a Forced Vibration Analysis

1. From the Vibration menu, point to Test, and then select Vibration Analysis.
2. Select New Vibration Analysis.
3. Create your analysis as described in the dialog box help for Perform Vibration Analysis, being sure to select
Forced Vibration Analysis.
4. Optionally select Create Multi-Run Script and following the instructions in Create Vibration Multi-Run
Script.
5. Select OK.
Adams Vibration performs a forced vibration analysis. The process runs quickly. If no error messages
appear, you can assume the vibration analysis completed correctly. If you receive error messages,
correct the problem, and rerun your analysis.
Note: You cannot combine vibration actuators of the non-PSD-type with PSD-type vibration
actuators in the same vibration analysis.
Creating and Running a Normal Modes Analysis

2. Select New Vibration Analysis.
3. Create your analysis as described in the dialog box help for Perform Vibration Analysis, being sure to select
Normal Modes Analysis.
4. Optionally, select Create Multi-Run Script and follow the instructions in Create Vibration Multi-Run
Script.
5. Select OK.
Adams Vibration performs a normal modes analysis. The process runs quickly. If no error messages
appear, you can assume the vibration analysis completed correctly. If you receive error messages,
correct the problem, and rerun your analysis.
Modifying Existing Analyses

2. Select Vibration Analysis.
3. In the corresponding text box, enter the name of your existing vibration analysis.
16 Adams Vibration
4. Make changes as necessary.

5. Select OK to run your analysis.
Vibration Analysis Calculation Methods

This section only provides an overview of the calculation methods in Adams Vibration; see Adams Vibration
Theory section for more details.
A forced vibration analysis is a simulation in the frequency domain; this type of. analysis requires the
definition of actuators, input channels, and output channels. Adams Vibration will compute the response of
each output channel and the transfer functions. A normal modes analysis computes the eigenvalues and mode
shapes for the model.
 Frequency Response
 Modal Coordinates
 Power Spectral Density (PSD)
 Transfer Function
Frequency Response
The frequency response of a given output channel is the magnitude and phase response produced by a given
input channel, for each specified frequency.
For frequency response computation, the linearized model is represented as:
sx(s) = A x(s) + B u(s)
y(s) = C x(s) + D u(s)
where:
 s is the Laplace variable
 A, B, C, and D are state matrices for the linearized model. These matrices are computed by Adams.
 x(s) is Laplace transform of the linearization states.
 u(s) and y(s) are the Laplace transforms of the inputs and output channels.
The system transfer function can be represented as:
y(s)
H ( s ) = ---------- = C ( sI – A ) – 1 B + D
u(s)
where:
 H(s) is the transfer function for the model
 I is the identity matrix of dimension equal to the number of system states
For a given vibration analysis, the system frequency response is given as:
y ( s ) = H ( s )u ( s )
Testing Your Model 17
Modal Coordinates
Modal coordinates are states in the frequency domain solution associated with a specific mode. Modes most
active in a frequency response can be identified from the modal coordinates. The modal coordinates are
computed as:
x ( s ) = ( sI – A ) – 1 Bu ( s )
Power Spectral Density (PSD)

PSD of output channels for given input PSDs is given as:
p ( s ) = H∗ ( s ) ⋅ U ( s ) ⋅ H ( s )
where:
 p(s) is the matrix of power spectral density
 H*(s) is the complex conjugate transpose of H(s)
 U(s) is the matrix of input spectral density
The matrix of input spectral densities is a diagonal matrix with the vibration actuator PSDs on the diagonal
locations. Off-diagonal locations of this matrix are populated with cross-correlation PSD specification.
For example, for a model with two input channels with actuators of type PSD:
U 1 ( s ) U 12 ( s )
U(s) =
U 21 ( s ) U 2 ( s )
where:
 U1(s) is the PSD of input channel 1
 U2(s) is the PSD of input channel 2
 U12(s) is the cross correlation PSD of input channel 1 to input channel 2
 U21(s) is U12(s)
Transfer Function
Transfer function is a basic property of a model, and is computed as the magnitude and phase response at a
given output channel for a given input channel with a unit swept sine vibration actuator.
For frequency response computation, the linearized model is represented as:
sx(s) = A x(s) + B u(s)
y(s) = C x(s) + D u(s)
18 Adams Vibration
where:
 s is the Laplace variable
 A, B, C and D are state matrices for the linearized model
The system transfer function can be represented as:
y(s)
H ( s ) = ---------- = C ( sI – A ) – 1 B + D
u(s)
where:
 H(s) is the transfer function for the model
 I is the identity matrix of dimension equal to the number of system states
Creating a Multi-Run Script

You can create a simulation Script that you can use during multi-run simulations (such as Design study, Design
of experiments (DOE), and so on).
To create a multi-run script:

1. Perform one of the following:
• From the Vibration menu, point to Test, and then select Create Multi-Run Script.
• From the Vibration menu, point to Test, and then select Vibration Analysis. In the Perform
Vibration Analysis dialog box, select Create Multi-Run Script.
2. Complete the dialog box as described in Create Vibration Multi-Run Script.
3. Select OK.
Specifying Solver Settings

You can specify the default solver options for your simulation.
To specify the solver settings:

1. From the Vibration menu, point to Test, and then select Solver Settings.
2. Complete the dialog box as described in Solver Settings - Executable.
3. Select OK.
Batch Mode Analysis
Batch Mode Analysis
Overview of Batch Mode Analysis

In Adams Vibration, you can perform batch mode vibration analysis. This functionality is available in the
Python scripting environment. The Python scripting language was selected for its ease of use, power, and
flexibility. A basic understanding of the python language is prerequisite to using batch mode analysis. For
more information on the Python scripting language see http://www.python.org.
To perform vibration batch mode analysis, you must have an existing Adams model in the form of a dataset
(.adm) file. Based on this model, you are required to create a Python script to perform the following:
1. Set up the model for vibration analysis.
a. Define vibration actuator
b. Define vibration input channels
c. Define vibration output channels
d. Define vibration analyses
2. Perform vibration analysis
a. Create a vibration model
b. Perform the vibration analysis
3. Export analysis results for postprocessing
a. Export simulation data to a stand-alone file in the .xml format. This file may be imported in third-
party packages for plotting.
b. Export an Adams View command file, which can be imported into Adams PostProcessor for
postprocessing of Adams Vibration analysis data.
4. Check out and check in Adams Vibration license (optional, but good practice)
Once you've created the Python script, you can run it using one of the following commands:
 On Windows, from a command prompt:
adams2020 python my_model.py
 On Linux, in a Linux shell:
adams2020 -c python my_model.py
where my_model.py is the python script file.
Alternatively, you can also type the commands contained in this file directly into the Python interpreter to
perform the same analysis.
Python Examples
Your installation directory contains many examples that use Python scripts to perform various Adams
Vibration activities. The following table lists the location and description of each example.
20 Adams Vibration
Classes
Note: All example directories are located in install_dir/vibration/examples, where install_dir is the
directory where Adams is installed.
Example directory: Instructions file: Description of example:

achassis_demo Readme.txt Using an Adams Chassis vehicle model,
runs batch mode analysis in the
frequency domain using Adams
Vibration.
mechanical_transfer_functions Readme.txt Illustrates the calculation of mechanical
transfer functions in the frequency
domain using Adams Vibration. Also
saves vibration results in a .res file.
multi_point_analysis Readme.txt Using a concept vehicle model, runs a
batch-mode analysis in the frequency
domain using Adams Vibration. The
analysis calculates the compliance matrix
of the model at multiple operating points
during the simulation.
python_batch_analysis Readme.txt Using a concept vehicle model, runs a
batch-mode analysis in the frequency
domain using Adams Vibration.
python_plotting Readme.txt Illustrates the plotting of vibration data
in Python. Each Python script produces a
different kind of plot.
Classes
Actuator
Modules
msc.Adams.Vibration.libAvAPIc os struct types
libsip re sys
math string traceback
Functions
Actuator(self, ActInfo)
Classes
AvActuator
This the entry point for the Actuators
Modules
libsip re sys
Classes
AvActuator
AvActuatorPSDFunction
AvActuatorRotatingMass
AvActuatorSweptSine
AvActuatorUserFunction
class AvActuator
Methods defined here:

CrossActuator(id)
DVAType(self)
EvalPSD(self, w)
Evaluate(self, w)
HasCrossActuator(id)
Name(self)
PSD(self)
__init__(self, Name)
class AvActuatorPSDFunction(AvActuator)

Actuator(self)
WritePy(self, oFile, space)
WriteXML(self, oFile, space)
PSD Function
__init__(self, Name, Type, Func, Args, CrossList)
22 Adams Vibration
Classes
Methods inherited from AvActuator:

CrossActuator(id)
DVAType(self)
EvalPSD(self, w)
Evaluate(self, w)
Name(self)
PSD(self)
class AvActuatorRotatingMass(AvActuator)

Actuator(self)
Create an actuator from the dialog box data
Rotating Mass
__init__(self, Name, Type, Leading, Mass, Offset, Normal=None)

CrossActuator(id)
DVAType(self)
EvalPSD(self, w)
Evaluate(self, w)
Name(self)
PSD(self)
class AvActuatorSweptSine(AvActuator)
Actuator(self)
Swept sine
__init__(self, Name, Type, Mag, Phase)
Classes

CrossActuator(id)
DVAType(self)
EvalPSD(self, w)
Evaluate(self, w)
Name(self)
PSD(self)
class AvActuatorUserFunction(AvActuator)

Actuator(self)
User
__init__(self, Name, Type, Func, Args)

CrossActuator(id)
DVAType(self)
EvalPSD(self, w)
Evaluate(self, w)
Name(self)
PSD(self)
AvAMD
From Adams Vibration.AvAMD import *
Constructor:
AvAMD(fName)
Constructor
Returns: object
Parameters:
string fName: Name of the adm file with the Adams Solver model
in it
24 Adams Vibration
Classes
Adams_OBJECT Model()
Get the key to the model
Returns: int - the key to the model
Parameters: None
Adams_OBJECT Ground()
Get the key to the ground object
Returns: int - the key to ground
Parameters: None
int AdamsID(Object)
Get the objects Adams ID
Returns: int - the id assigned to the object
Parameters:
Object - Adams_OBJECT database object to get the id from
Adams_OBJECT CreateVariable(func)
Create a solver variable in the database
Returns: int - the key to the variable
Parameters:
func - string solver function
list PartList()
Get a list of parts in the model
Returns: list - list of keys
Parameters: None
list MarkerList(part)
Get a list of markers for the given part
Returns: list - list of markers
Parameters:
part - Adams_OBJECT part to get the markers from
list StateMatrixList(results)
Get a list of state matrix objects for the given results object
Returns: list - list of state matrix
Parameters:
results - Adams_OBJECT results object to get the state
matrix from
Adams_OBJECT PartFromMarker(markerID)
Get the markers parent
Returns: Adams_OBJECT - key of the parent part
Parameters:
markerID - int Adams ID of the marker
Adams_OBJECT CreateMarker(partId, dir)

Create a marker in the database
Returns: Adams_OBJECT - key of the marker
Parameters:
partID - int Adams ID of the parent part
Classes
dir - char direction to align Z axis
string ObjName(dbObject)
Get the name of the database object
Returns: string - Name of the object
Parameters:
dbObject - Adams_OBJECT database object to get name from
string MarkerName(markerID)
Get the name of the marker
Returns: string - Name of the marker
Parameters:
markerID - int Adams ID of the marker
Adams_OBJECT CreateSForce(iMarkId, jMarkId, action, type, func)

Create an SFORCE in the database
Returns: Adams_OBJECT - key to the SFORCE
Parameters:
iMarkId - int Adams ID of the I marker
jMarkId - int Adams ID of the J marker
action - string "ACTIONONLY" or None
type - string "Translational" or "Rotational"
func - string solver function
Adams_OBJECT CreateResults()
Create a results object in the database
Returns: Adams_OBJECT - key to the results object
Parameters: None
bool WriteADM(fName)
Write the model to a solver database file
Returns: bool - true for success
Parameters:
fName - string name of the adm file to write
Adams_OBJECT CreatePInput(varIDs)
Create a plant input object in the database
Returns: Adams_OBJECT - key to the plant input object
Parameters:
varIDs - list of Adams ID's of the solver variables for
the plant input
Adams_OBJECT CreatePOutput(const int*) const;

Create a plant output object in the database
Returns: Adams_OBJECT - key to the plant output object
Parameters:
varIDs - list of Adams ID's of the solver variables for
the plant output
double DM(iMarkID, jMarkID)

Get the distance between two markers
Returns: double - distance between markers
Parameters:
iMarkID - Adams ID of the I marker
26 Adams Vibration
Classes
jMarkID - Adams ID of the J marker
int DiffID()
Get the Adams ID to assign to the next DIFF
Returns: int - Adams ID of the DIFF
Parameters: None
Adams_OBJECT CreateDiff(id, func, IC)

Create a DIFF object in the database
Returns: Adams_OBJECT - key to the DIFF object
Parameters:
id - Adams ID if the DIFF to create
func - string solver function for the DIFF
IC - double DIFF initial value for the DIFF
Adams_OBJECT CreateMatrix(nRow, nCol, order, data)

Create a matrix object in the database
Returns: Adams_OBJECT - key to the matrix object
Parameters:
nRow - int number of rows
nCol - int number of columns
order - string Row order or Column order of the data
data - list matrix values
Adams_OBJECT CreateArray(which, data)

Create an array object in the database
Returns: Adams_OBJECT - key to the array object
Parameters:
which - character X, Y, U, I
data - string optional values for the array used with I & U
Adams_OBJECT CreateLSE(xArray, uArray, yArray, icArray, aMat, bMat,
cMat, dMat)
Create an LSE object in the database
Returns: Adams_OBJECT - key to the LSE object
Parameters:
xArray - int Adams ID of the X array
uArray - int Adams ID of the U array
yArray - int Adams ID of the Y array
icArray - int Adams ID of the IC array
aMat - int Adams ID of the A matrix
bMat - int Adams ID of the B matrix
cMat - int Adams ID of the C matrix
dMat - int Adams ID of the D matrix
Adams_OBJECT CreateGSE(nIn, nOut, xArray, uArray, yArray, icArray,

xxFlag, xuFlag, yxFlag, yuFlag, Parm,libFunc)
Create an LSE object in the database
Returns: Adams_OBJECT - key to the LSE object
Parameters:
nIn - int number of inputs to system
nOut - int number of system outputs
xArray - int Adams ID of the X array
uArray - int Adams ID of the U array
Classes
yArray - int Adams ID of the Y array

icArray - int Adams ID of the IC array
xxFlag - char U user function provided None other wise
xuFlag - char U user function provided None other wise
yxFlag - char U user function provided None other wise
yuFlag - char U user function provided None other wise
Parm - list user parameters or empty
libFunc - string user function lib::func names
Adams_OBJECT CreateGForce( const int iMarkId, const int jMarkId,

const int rMarkId, const char* Fx, const char* Fy, const char* Fz,
const char* Tx, const char* Ty, const char*Tz)
Create an GFORCE object in the database
Returns: Adams_OBJECT - key to the GFORCE object
Parameters:
iMarkId - int I marker Adams ID
jMarkId - int J marker Adams ID
rMarkId - int Ref marker Adams ID
Fx - string solver function for force in the X direction
FY - string solver function for force in the Y direction
Fz - string solver function for force in the Z direction
TX - string solver function for torque in the X axis
Ty - string solver function for torque in the Y axis
Tz - string solver function for torque in the Z axis
Adams_OBJECT ReadResultsFile(analysisName, fileName)

Read a results file
Returns: Adams_OBJECT - key to the results object
Parameters:
analysisName - string name for the analysis
filename - string name of the .res file
bool WriteResultsFile(analysisObject, filename)
Write a results file
Returns: boolean - true if file written successfully false
otherwise
Parameters:
analysisObject - Adams_OBJECT key of the analysis to write
filename - string name of the .res file
Adams_OBJECT CreateResultsVariable(analysisObject,
variableName,comment1, comment2, data)
Create a results variable
Returns: Adams_OBJECT - key of the variable
Parameters:
analysisObject - Adams_OBJECT key of the analysis
variableName - string name of the new variable
comment1 - string variable comment
comment2 - string variable comment
data - list values to assign to variable
AvAPI_Matrix StateMatrix(smObject, which)

Get a matrix from a state matrix object
Returns: AvAPI_Matrix - the matrix
Parameters:
28 Adams Vibration
Classes
smObject - Adams_OBJECT key to the state matrix object

which - char matrix to get A, B, C, D
double StateMatrixTime(smObject)
Get the time from a state matrix object
Returns: double - simulation time the state matrix object was
created
Parameters:
bool StateMatrixABCD(smObject)
Determine if a state matrix object has B, C, D matrix
Returns: Boolean - true if B, C, and D exist false otherwise
Parameters:
<![endif]>int NodeID(Marker)
Get the objects Node ID of a marker

Returns: int - the id of the node
Parameters:
Marker - Adams_OBJECT database object to get the id fromlist
DependList(Object)
Get a list of dependants for the given object

Returns: list - list of objects
Parameters:
Object - Adams_OBJECT to get the dependants from
list ReferenceList(Object)
Get a list of objects that reference the given object
Returns: list - list of objects
Parameters:
Object - Adams_OBJECT to get the references from
list MKCList(results)
Get a list of MKC objects for the given results object
Returns: list - list of MKC objects
Parameters:
results - Adams_OBJECT results object to get the MKC from
list FlexList()
Get a list of parts in the model
Returns: list - list of keys
Parameters: None
Adams_OBJECT Marker(Id)
Get a marker key given the id
Returns: Adams_OBJECT
Parameters:
Id - Adams id of the marker
Adams_OBJECT FixedJointMarker(Fixed, IorJ)

Get a marker key of a fixed joint given I or J
Classes
Parameters:
Fixed - key to the fixed joint
IorJ - character 'I' marker or 'J' marker
Adams_OBJECT GForceMarker(GF, IorJ)

Get a marker key of a GFORCE given I or J
Parameters:
GF - key to the GFORCE
IorJ - character 'I' marker or 'J' marker
void Delete(k_obj)
Delete an object from the database
Returns: None
Parameters:
k_obj - key to the object to be removed
list MarkerLocationOrientation(Marker, Analysis);

Returns the location and orientation of a marker
Returns: a six long list [X, Y, Z, Ax, Ay, Az]
Parameters:
Marker - Adams_OBJECT marker to get information for Analysis
- Adams_OBJECT non-zero Analysis will return the current information
zero Analysis will return the initial information
void ForceOnElement(k_obj, Analysis)

Returns the force action on the object
Returns: a six long list [FX, FY, FZ, Tx, Ty, Tz]
Parameters:
k_obj - Adams_OBJECT key to the object Analysis -
Adams_OBJECT Analysis to return the forces from
AvAPI_Matrix MKC(k_obj, which)
Get a matrix from a MKC object
Returns: AvAPI_Matrix - the matrix
Parameters:
k_obj - Adams_OBJECT key to the MKC object
which - char matrix to get M, K, C (B)
Adams_OBJECT CreateFixedJoint(iMark, jMark)

Create a fixed joint between the given markers
Returns: Adams_OBJECT - key to the fixed joint
Parameters:
iMark - Adams id of the I marker
jMark - Adams id of the J marker
Adams_OBJECT CreateAnalysis(model, name)

Create an analysis object
Returns: Adams_OBJECT - key to the analysis
Parameters:
model - Adams_OBJECT key to the model
mane - string name of the analysis
char* UnitString(unit)
Get the unit string for the given unit
30 Adams Vibration
Classes
Returns: string - unit string

Parameters:
unit - eUNIT any of the following
enum eUNIT
{
eNONE,
eANGLE,
eFORCE,
eFREQUENCY,
eLENGTH,
eMASS,
eTIME,
eINERTIA,
eVELOCITY,
eACCELERATION,
eANGULAR_VEL,
eANGULAR_ACCEL,
eSTIFFNESS,
eDAMPING,
eTORSION_STIFF,
eTORSION_DAMP,
eAREA,
eVOLUME,
eTORQUE,
ePRESSURE,
eAREA_INERTIA,
eDENSITY,
eENERGY,
eFORCE_TIME,
eTORQUE_TIME,
eFLOWRATE_PRESSURE_D,
eFLOW_RATE,
eF_PER_ANG,
eC_PER_ANG,
eCOMPOSED
};
AvAPI Class
Public Methods:
bool AcquireLicense(void)
Check out an Adams Vibration license
Returns: bool - true on success false otherwise
Parameters: None
void ReleaseLicense(void)
Check in Adams Vibration license
Returns: void
Parameters: None -
bool CheckLicense(void)
Classes
Check to see if process has a vibration license

Returns: bool - true on success; false otherwise
Parameters: None -
vib_message_handler PushMessageHandler(mh, Args)
Sets the current function to handle vibration messages
Returns: Current message handler
Parameters:
stringmh - Name of the function func(msg, type, args)
string MSG - Message being sent
character type - Type of message [e, i, w]
list args - Argument list given by user when function was set
listArgs - user data to send back to the handler
vib_message_handler PopMessageHandler(void)
Replace the current function to handle vibration messages with the pervious one
Returns: Current message handler
Parameters: None -
AvAPI_Actuator Class
Constructors:
AvAPI_Actuator(fdva, mag, phase)
Swept sine Constructor
Returns: Object pointer
Parameters:
char fdva - type of actuator [‘F’, ‘D’, ‘V’, ‘A’]
F = Force
D = Displacement
V = Velocity
A = Acceleration
double mag - magnitude of sine
double phase - phase of sine
AvAPI_Actuator(isForce, isLeading, mass, offset, dnormal)
Rotating mass Constructor
Parameters:
bool isForce - true for force; false for moment
32 Adams Vibration
Classes
bool isLeading- true for leading; false for lagging

double mass - mass of rotation
double offset - radial distance to the imbalance
double dnormal - perpendicular distance to the plane (moment only)
AvAPI_Actuator(fdva, ufunc, data)
User function Constructor
Parameters:
char fdva - type of actuator [‘F’, ’D’, ‘V’, ‘A’]
F = Force
D = Displacement
V = Velocity
A = Acceleration
string ufunc - name of the user function must be in the global dictionary
complex ufunc(data , w)
Returns: complex f(w) actuator value at w
Parameters:
list data - user data given when actuator was constructed
double w - frequency of evaluation
list data - user data to be returned when ufunc is called
AvAPI_Actuator(fdva, ufunc, data, crossList)
PSD Constructor
Parameters:
char fdva - type of actuator [‘F’, ‘D’, ‘V’, ‘A’]
F = Force
D = Displacement
V = Velocity
A = Acceleration
string ufunc - name of the user function must be in the global dictionary
complex ufunc(data , w)
Returns:complex f(w) actuator value at w
Parameters:
Classes
list data - user data given when actuator was constructed

double w - frequency of evaluation
list data - user data to be returned when ufunc is called
list crossList - list of cross correlation actuators
Public Methods:
AvAPI_Matrix Evaluate(Omega)
Actuator evaluation multiple frequencies
Returns:AvAPI_Matrix - vector of complex values
Parameters:
AvAPI_MatrixOmega - Vector of frequencies to evaluate at
AvAPI_Complex Evaluate(Omega)
Actuator evaluation single frequency
Returns:AvAPI_Complex - complex value
Parameters:
doubleOmega - Frequency of evaluation
char DVAType(void)
Type of actuator
Returns: char [‘F’, ‘D’, ‘V’, ‘A’]
F = Force
D = Displacement
V = Velocity
A = Acceleration
Parameters: None
boolPSD(void)
PSD type actuator
Returns: bool True if PSD actuator False otherwise
Parameters: None
AvAPI_Actuator CrossActuator(iIC)
Get the cross correlation actuator for given input channel
Returns: AvAPI_Actuator cross correlation actuator
Parameters: int iic input channel index
bool HasCrossActuator(int iic)
Determine if cross correlation actuator exists
34 Adams Vibration
Classes
Returns: bool True if the given input channel has a cross correlation actuator False
otherwise
Parameters:
int iic input channel index.
If iic is less than zero the function returns True if any input channel has a cross
correlation actuator.
AvAPI_Complex Class
Constructors:
AvAPI_Complex(void)
AvAPI_Complex default Constructor
Returns: Object pointer real and imaginary set to zero
Parameters: None
AvAPI_Complex(r, i)
AvAPI_Complex Constructor
Parameters:
double r - real part
double i - imaginary part
Public Methods:
AvAPI_Complex& byMP(magnitude, theta)
Set real and imag parts using the magnitude and phase given
Returns:AvAPI_Complex& - reference to this object
Parameters:
double magnitude - magnitude of the complex value
double theta - phase angle in degrees
Note: real = magnitude * cos(theta)
imag = magnitude * sin(theta)
double real(void)
Return the real part of the complex number
Returns: double - real part
Parameters: None -
double imag(void)
Return the imaginary part of the complex number
Returns: double - imag part
Classes
Parameters:None -
double Mag(void)
Return the magnitude of the complex number
Returns: double - magnitude
Parameters: None -
double Phase(void)
Return the phase of the complex number
Returns: double - phase angle in degrees
Parameters: None -
AvAPI_Matrix Class
Constructors:
AvAPI_Matrix(nRow, vals)
Vector Constructor
Returns:Object
Parameters:
intnRow- Number of rows of data
list of double or complex vals - Data values column wise
AvAPI_Matrix(nRow, nCol, vals)

Dense column wise Constructor
Returns:Object pointer
Parameters:
int nRow- Number of rows of data
int nCol - Number of columns of data
list of double or complex vals - Data values column wise
AvAPI_Matrix(vals, nRow, nCol)
Dense row wise Constructor
Parameters:
list of double or complex vals - Data values row wise
AvAPI_Matrix(nSlot, nRow, nCol, vals)

36 Adams Vibration
Classes
Dense 3D Constructor
Parameters:
int nSlot- Number of slots of data
list of double or complex vals - Data values slot wise column wise
Methods:
double Value(row)
Value at location [row,0]
Returns:double- Value of the matrix location[row,0]
Parameters:int row- Row number
double Value(row, col)
Value at location [row, col]
Returns:double- Value of the matrix location[row,col]
Parameters:
int row- Row number
int col - Column number
double Value(slot, row, col)
Value at location [row, col] for matrix at the specified slot number
Returns:double- Value of the matrix location [row,col] ] for matrix at specified slot number
Parameters:
int slot- Slot number
int row- Row number
AvAPI_Complex ValueC(row, col)
Value at location [row, col]
Returns:AvAPI_Complex- Value of the matrix location[row,col]
Parameters:
int row- Row number
AvAPI_Complex ValueC(slot, row, col)
Value at location
Classes
Returns:AvAPI_Complex- Value at location [row,col] for matrix at specified slot number

Parameters:
int slot - Slot number
int row- Row number
int Size(dim)
Matrix dimension
Returns: int - size of the matrix int the given dimension
Parameters:
int dim- Dimension to get the size 0, 1, or 2
list MultMv(vector)
Multiply the vector by the matrix
Returns: list - output vector
Parameters:
list vector- List of double or complex values
AvAPI_System Class
Constructor:
AvAPI_System(Time, A, B, C, D, actuatorList, modeList)
Constructor for a license system
Parameters:
double Time - Simulation time of linearization
AvAPI_Matrix A - system A matrix from Adams
AvAPI_Matrix B - system B matrix from Adams
AvAPI_Matrix C - system C matrix from Adams
AvAPI_Matrix D - system D matrix from Adams
list actuatorList - list of actuators
list modeList - list of modes by index to use in system calculations; NULL for including all
modes.
Public Methods:
AvAPI_ActuatorActuator (iIC)
Actuator
Returns:AvAPI_Actuatoractuator for given input channel
38 Adams Vibration
Classes
Parameters:int iicindex of the input channel

int Inputs(void)
Inputs
Returns:int- number of system inputs
Parameters: None
intOutputs(void)
Outputs
Returns:int- number of system outputs
Parameters: None
intDefective(which)
defective eigen value index
Returns:int- index of eigen value if equal to which eigen value is not defective
Parameters: int which - index of eigen value
AvAPI_ComplexEigenvalue (indx, cyclesPerTime)
eigen value
Returns:AvAPI_Complex the eigen value
Parameters:
int indx - index of the eigen value to be returned
bool cyclesPerTime - True value is scaled by 2 π
intEigenvalues(void)
number of eigen values found
Returns:int- number of eigen values
Parameters: None
AvAPI_ComplexEigenvector(which, indx)
eigen vector
Returns:the eigen vector component V[indx]
Parameters:
int which - eigen vector index
int indx - index into the vector
AvAPI_MatrixTransferFunction(Omega)
Transfer Function
Returns:AvAPI_Matrix - system transfer function3D complex matrix of the number of
output channels times the number of input channels times the number of frequencies
Parameters: AvAPI_Matrix Omega vector of frequencies
Classes
AvAPI_MatrixFrequencyResponse (Omega)
Frequency Response
Returns:AvAPI_Matrix- system frequency response3D complex matrix of the number
of output channels times the number of input channels times the number of frequencies
AvAPI_Matrix MCT (Omega, scaleMCT)
modal coordinate table
Returns:AvAPI_Matrix- modal coordinate table
Parameters:
AvAPI_Matrix Omega vector of frequencies
bool scaleMCT- ifTrue MCT matrix is scaled by the input actuators
AvAPI_Matrix MPF (iic, iOC, iFr, iMd, Omega)
modal participation factors
Returns:AvAPI_Matrix- system modal participation factors
Parameters:
int iic - input channel index
int IOC - output channel index
int iFr - frequency index
int imd - mode number
AvAPI_Complex PSD (IOC, frequency)
Compute power spectral density (PSD)
Returns: AvAPI_Complex PSD value
Parameters:
int IOC - input channel index
double frequency - frequency for evaluation
AvAPI_Matrix PSD (frequency)
Returns:AvAPI - Computed PSD values
Parameters:
double Time()
Get the time of linearization
Returns:double Time given
40 Adams Vibration
Classes
Parameters: None
AvAPI_Matrix ModalMatrix (Which)
Get A,B,C, or D Matrix
Returns:AvAPI_Matrix Matrix
Parameters:
char Which - Matrix to get A B C D
AvAPI_SystemSS Class
Constructor:
AvAPI_SystemSS(Time, A, B, C, D, actuatorList)
Constructor for a state space linear system
Returns: Object
Parameters:
double Time - Simulation time of linearization
AvAPI_Matrix A - system A matrix from Adams AvAPI_Matrix
B - system B matrix from Adams
AvAPI_Matrix C - system C matrix from Adams
AvAPI_Matrix D - system D matrix from Adams
list actuatorList - list of actuators
Public Methods:
double Time()
Get the time of linearization
Returns:double Time given
Parameters: None
AvAPI_Actuator Actuator(iIC)
Actuator
Returns:AvAPI_Actuator actuator for given input channel
Parameters:int iicindex of the input channel
int Inputs (void)
Inputs
Returns: int - number of system inputs
Parameters: None
int Outputs (void)
Outputs
Returns: int - number of system outputs
Classes
Parameters: None
AvAPI_Matrix TransferFunction(Omega)
Transfer Function
Returns:AvAPI_Matrix - system transfer function3D complex matrix of the number
of output channels times the number of input channels times the number of frequencies
AvAPI_Matrix FrequencyResponse (Omega)
Frequency Response
Returns: AvAPI_Matrix - system frequency response3D complex matrix of the
number of output channels times the number of input channels times the number of frequencies
AvAPI_Matrix MCT (Omega, scaleMCT)
modal coordinate table
Returns: AvAPI_Matrix - modal coordinate table
Parameters:
AvAPI_MatrixOmega vector of frequencies
bool scaleMCT - ifTrue MCT matrix is scaled by the input actuators
AvAPI_Matrix MPF (iic, iOC, iFr, iMd, Omega)
modal participation factors
Returns: AvAPI_Matrix - system modal participation factors
Parameters:
int iic - input channel index
int IOC - output channel index
int iFr - frequency index
int imd - mode number
AvAPI_Complex PSD (IOC, frequency)
Returns: AvAPI_Complex PSD value
Parameters:
int IOC - input channel index
AvAPI_Matrix PSD (frequency)
Returns:AvAPI_Matrix PSD values
42 Adams Vibration
Classes
Parameters:
AvAPI_Matrix ModalMatrix (Which)
Get A,B,C, or D Matrix
Returns:AvAPI_Matrix Matrix
Parameters:
char Which - Matrix to get A B C D
AvAPI_Matrix ComplianceMatrix ()
Compute the compliance matrix
Returns:AvAPI_Matrix Compliance Matrix
Parameters: None
AvAPI_ToolBox
From msc.Adams.Vibration.AvAPI import *
Data Members:
AvAPI_ToolBox.eRECTANGULAR
AvAPI_ToolBox.eHAMMING,
AvAPI_ToolBox.eHANNING,
AvAPI_ToolBox.ePARZEN,
AvAPI_ToolBox.eWELCH
double Frequency(i, nFFT, dt, HZ)
return the frequency associated with the ith point of the FFT
Returns: double
Parameters:int i - point number
int nFFT - total number of points in FFT
double DT - point spacing
bool HZ - true frequency returned in HZ
AvAPI_Matrix FFT(data, n, detrend, window)
compute the Fast Fourier Transformations (FFT)
Returns: AvAPI_Matrix
Parameters:
AvAPI_Matrix& data - input data in columns
int n - number of points to use in FFT
Classes
bool detrend - true detrend data

AvAPI_ToolBox::eWindow window - window to use
AvAPI_Matrix PSD(const AvAPI_Matrix& data, AvAPI_ToolBox::eWindow window, int nSeg, int
nOverlap)
compute the Power Spectral Density (PSD)
Returns: AvAPI_Matrix
Parameters:
AvAPI_Matrix& data - input data in columns
AvAPI_ToolBox::eWindow window - window to use
int nSeg - number of segments to use
int nOverlap - number of points to overlap
AvAPI_Matrix FDElementID(data)
Determine the parameters for an FD Element
Returns: AvAPI_Matrix 1D K1 - C3
Parameters:
AvAPI_Matrix& data - test data
AvAPI_Matrix FDEvaluate(AvAPI_Matrix& K1, AvAPI_Matrix& C1, AvAPI_Matrix& K2,
AvAPI_Matrix& C2, AvAPI_Matrix& K3, AvAPI_Matrix& C3, const AvAPI_Matrix& omega, bool
MagPhase)
Evaluate an FD Element
Returns: AvAPI_Matrix Element transfer function
Parameters:
double or AvAPI_Matrix& K1 - value(s) to use for K1
double or AvAPI_Matrix& C1 - value(s) to use for C1
AvAPI_Matrix& omega - Frequencies to evaluate at
bool MagPhase - return magnitude / phase or real / imaginary
Constructors:
AvAPI_ToolBox()
44 Adams Vibration
Classes
Constructor
Returns: object
Parameters: None
AvBuild
This the entry point for Vibration Build
Modules
msc.Adams.Vibration.libAvAMDc libsip string traceback
msc.Adams.Vibration.libAvAPIc math struct types
msc.Adams.Vibration.Plotting.libVibPlotc os sys
libqtc re tempfile
Classes
AvBuild
AvBuildActuator
AvBuildFDElement
AvBuildFDInstance
AvBuildInputChannel
AvBuildOutputChannel
AvBuildPlot
AvBuildTest
class AvBuild

Actuator(self)
FDElement(self)
FDInstance(self)
InputChannel(self)
Name(self)
OutputChannel(self)
Plot(self)
Test(self)
__init__(self, Name=None)
Classes
class AvBuildActuator

Actuator(self, Name)
Name(self)
PSDFunction(self, Name, Type, Func, Args, CrossList)
RotatingMass(self, Name, Type, Leading, Mass, Offset, Normal=None)
SweptSine(self, Name, Type, Mag, Phase)
UserFunction(self, Name, Type, Func, Args)
__init__(self, Parent, Name=None)
class AvBuildFDElement

Bushing(self, Name, k2, k3, c3)
Damper(self, Name, k1, k2, c3)
FDElement(self, Name)
Hydromount(self, Name, k1, c1, k2, c3)
Name(self)
Pfeffer(self, Name, k1, c2, k3, c3)
Supper(self, Name, k1, c1, k2, c2, k3, c3)
class AvBuildFDInstance

FDInstance(self, Name, Type, Imark, Jmark, FdElement, preload)
List(self)
Name(self)
class AvBuildInputChannel

List(self)
Marker(self, Name, Marker_Adams_ID, FunctionType, Global, Direction, Actuator)
46 Adams Vibration
Classes
Name(self)
Names(self)
StateVariable(self, Name, StateVarID, Actuator)
class AvBuildOutputChannel

List(self)
Name(self)
Names(self)
Predefined(self, Name, MarkerID, GC, Dir, JMarkerID=0)
User(self, Name, Function)
class AvBuildPlot

Bode(self, Name, inputList, outputList)
Eigen(self, Name)
FRF(self, Name, inputList, outputList, Mag=1)
List(self)
Name(self)
TransferFunction(self, Name, inputList, outputList, Mag=1)
Data and non-method functions defined here:

__doc__ = None
__module__ = 'AvBuild'
str(object) -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
class AvBuildTest

List(self)(self)
Classes
Name(self)(self)
Test(self, Name, modelFile, simScript, damping, modeList, start, end, steps, outName=None)
TestCompliance(self, Name, modelFile, simScript, damping, modeList, outName=None)
TestM(self, Name, modelFile, acfFile, modeList, start, end, steps, outName=None, SS=0)
__init__(self, Parent, Name=None)(self, Parent, Name=None)
Functions
bitBlt(...)
qAlpha(...)
qAppName(...)
qBlue(...)
qDrawPlainRect(...)
qDrawShadeLine(...)
qDrawShadePanel(...)
qDrawShadeRect(...)
qDrawWinButton(...)
qDrawWinPanel(...)
qGray(...)
qGreen(...)
qRed(...)
qRgb(...)
qRgba(...)
qVersion(...)
qt_xdisplay(...)
qt_xrootwin(...)
qt_xscreen(...)
AvFDElement
This the entry point for the FD Element
Modules
libsip re sys

48 Adams Vibration
Classes
Classes
AvFDElement
class AvFDElement

C1(self)
C2(self)
C3(self)
Evaluate(self, w)
K1(self)
K2(self)
K3(self)
Name(self)
Symetric(self)
FD Emement
__init__(self, Name, k1, c1, k2, c2, k3, c3)
AvFDInstance
This the entry point for the FD Instance
Modules
msc.Adams.Vibration.libAvAMDc math string traceback
libsip re sys
Classes
AvFDInstance
class AvFDInstance

Add(self, amdModel)
Add1D(self, amdModel)
Classes
Add3D(self, amdModel)
FDElement(self)
IMarker(self)
JMarker(self)
Name(self)
Preload(self)
FD Emement
__init__(self, Name, Type, Imark, Jmark, FdElement, preload)
AvFreqRespSol
The entry point for the Adams Vibration Mechanical Transfer functions
Modules
msc.Adams.Vibration.libAvAMDc math string tempfile
msc.Adams.Vibration.libAvAPIc os struct traceback
libsip re sys types
Classes
AvMTF
Sol
class AvMTF
Adams Vibration class for computing mechanical transfer functions

AnaObjLst(self, AnaObj=None)
BaseName(self)
FreqRange(self)
FreqRangeHz(self)
InDir(self)
OutDir(self)
ResList(self, AnaObj=None)
__init__(self, Name, Model_base_name, Freq_range, iDir, oDir)
50 Adams Vibration
Classes
Marker AvMechanicalTF:
@param Name: Name to assign to mechanical transfer fu
nction
@type Name: string
@param Model_base_name: base name for the model.
@type Model_base_name: string
@param Marker_in: Input marker object
@param Freq_range: Frequency range for analysis
@type Freq_range: Frequency range object
@type Marker_in: Marker spec object
@param Marker_I_out: Output I marker object
@type Marker_I_out: I Marker spec object
@param Marker_J_out: Output J marker object
@type Marker_J_out: J Marker spec object
@return: the object
@rtype: Object
__mul__(self, a, b)
class Sol

ActName(self)
CleanUp(self)
CreateIOChannels(self)
ErrStr(self)
Initialize(self, Model, InpMarkerList, OutMarkerList)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
__init__(self)
AvHelp
Classes
Modules
os string sys
Classes
AvHelp
class AvHelp

__init__(self, File=None)
browser(self, File)
AvInputChannel
The entry point for the Adams Vibration Input Channel
Modules
msc.Adams.Vibration.libAvAPIc math re sys
libsip os string
Classes
AvInputChannel
AvInputChannelMarker
AvInputChannelStateVariable
class AvInputChannel
Adams Vibration Input Channel Base Class

Actuator(self)
AddActuator(self, amdModel)
Name(self)
__init__(self, Name, Actuator)
Base class for AvInput Channels:

@param Name: Name to assigne to input channel or none
@type Name: string
@param Actuator: AvAPI_Actuator object to use with imput channel
52 Adams Vibration
Classes
@type Actuator: object

@return: the object
@rtype: Object
class AvInputChannelMarker(AvInputChannel)
Marker Input Channel

Add(self, amdModel)
DVAUnitStr(self)
Return the unit string associated with the kinematic input channel
Direction(self)
Returns the local global string
FunctionType(self)
Global(self)
KinFunction(self)
Returns function string for the VARIABLE solver statement of the extra output for
kinematic actuators
KinFunctionPrefix(self)
Return the Solver function string i.e. DX
MarkerID(self)
VariableFunction(self)
Returns function string for the VARIABLE solver statement
Marker Input Channel
__init__(self, Name, Marker_Adams_ID, FunctionType, Global, Direction, Actuator)
Marker AvInput Channel:

@type Name: string
@param Marker_Adams_ID: Marker ID
@type Marker_Adams_ID: integer
@param FunctionType: <Translational, Rotational>
Classes
@type FunctionType: string

@param Global: <Global, Local>
@type Global: string
@param Direction: <X, Y, Z>
@type Direction: string
@return: the object
@rtype: Object
Methods inherited from AvInputChannel:
Actuator(self)
Name(self)
class AvInputChannelStateVariable(AvInputChannel)
State Variable Input Channel

Add(self, amdModel)
StateVarID(self)
State Variable Input Channel
__init__(self, Name, StateVarID, Actuator)
State Variable AvInput Channel:
@type Name: string
@param StateVarID: ID of the State Variable
@type StateVarID: integer
@param StateVarName: State Variable Name
@type StateVarName: string
@return: the object
@rtype: Object
54 Adams Vibration
Classes
Methods inherited from AvInputChannel:

Actuator(self)
Name(self)
Functions
EvalFunc(argList, w)
User function used to test this module
AvIOC
#
Modules
libsip re sys
Functions
InputChannel(ChName, MrkInfo, ActObj)
OutputChannel(ChName, MrkInfo)
AvLinearize
Modules
libsip re sys
Classes
AvLinearize
class AvLinearize
Create a linear system model from an Adams non-linear system.

A(self)
Return the system A matrix
Classes
AcfToScript(self, iFile)
B(self)
Return the system B matrix
C(self)
Return the system C matrix
D(self)
Return the system D matrix
FindMarker(self, id, inList)
GetId(self, str)
ReadMatrix(self, matFile)
Read ABCD system matrices from the given dat file
RmFile(self, rFile)
Remove a file
Simulate(self, simScript, outName, damping, pInId, pOutId)
__init__(self, modelFile, inputList, outputList, simScript, damping, outName='Adams',
FDList={})
AvLinearize:
@param modelFile: Adams .adm file to be linearize
@type modelFile: string
@param inputList: List of input channels (AvInputChannel objects)
@type inputList: List
@param outputList: List of output channels (AvOutputChannel objects)
@type outputList: List
@param simScript: Script of Adams solver commands to acheive
operating point Or name of an existing .acf file
@type simScript: string
@param damping: Include damping True or False
@type damping: Bool
@param outName: Base name for solver output files default = Adams
@type outName: string
@return: the object
@rtype: Object
Functions
AvLinearModel(modelFile, inputList, outputList, simScript, damping, outName, mList)
56 Adams Vibration
Classes
AvLinearModel:
@param modelFile: Adams .adm file to be linearize
@type modelFile: string
@param inputList: List of input channels (AvInputChannel objects)
@type inputList: List
@param outputList: List of output channels (AvOutputChannel objects)
@type outputList: List
@param simScript: Script of Adams solver commands to acheive operating point
Or name of an existing .acf file
@type simScript: string
@param damping: Include damping True or False
@type damping: Bool
@param outName: Base name for solver output files default = Adams
@type outName: string
@param mList: List of modes to use null for all
@type mList: integer list
@return: the object
@rtype: Object
AvMarkerSpec
The entry point for the Adams Vibration Marker specification
Modules
libsip os string
Classes
AvMarkerSpec
class AvMarkerSpec
Adams Vibration class for specifying marker info

Direction(self, NewDir=None)
Returns the direction string
FunctionType(self)
Classes
Returns the direction type string

Global(self)
MarkerID(self)
MarkerName(self)
Name(self)
__init__(self, Name, Marker_Adams_ID, MarkerName, FunctionType, Global, Direction)
Marker AvMarkerSpec:
@param Name: Name to assign to marker data spec
@type Name: string
@param Marker_Adams_ID: Marker ID
@type Marker_Adams_ID: integer
@param MarkerName: Marker Name
@type MarkerName: string
@param FunctionType: <Translational, Rotational>
@type FunctionType: string
@param Global: <Global, Local>
@type Global: string
@param Direction: <X, Y, Z>
@type Direction: string
@return: the object
@rtype: Object
AvMechTFs
Modules
libsip re sys types
Functions
CreateModel(BaseName, FreqRange, iDir, oDir)
DoVibrAnalysis(Ac, modl)
GetActionList(Ac)
RegisterAnalysis(AnaObj)
58 Adams Vibration
Classes
message_handler(msg, type, data)

Message handler for vibration
AvMTF
The entry point for the Adams Vibration Mechanical Transfer functions
Modules
libsip re sys types
Classes
msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol
Accelerance
Compliance
DynamicInertia
DynamicStiffness
ForceTransmissibility
Impedence
Mobility
MotionTransmissibility
class Accelerance(msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)
# Accelerance

__init__(self, Model, InpMarkerList, OutMarkerList)
Methods inherited from

href="avfreqrespsol.html#Sol">msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol:
ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Classes
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
class Compliance


ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
class DynamicInertia
(href="avfreqrespsol.html#Sol">msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)
# Dynamic Inertia
60 Adams Vibration
Classes

Methods inherited from:

ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
class DynamicStiffness


ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Classes
Results(self)
VarName(self)
__del__(self)
class ForceTransmissibility(msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)
Force Transmissibility


ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
class Impedence


ActName(self)
CleanUp(self)
62 Adams Vibration
Classes
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
class Mobility
(href="avfreqrespsol.html#Sol">msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)
# Mobility


ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
Classes
__del__(self)
class MotionTransmissibility
(href="avfreqrespsol.html#Sol"> Adams Vibration.InstrumentPacks.AvFreqRespSol.Sol)
# Motion Transmissiblity

Methods inherited from:

ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
AvNibble
Modules
copy math struct types
msc.Adams.Vibration.libAvAMDc os sys
msc.Adams.Vibration.libAvAPIc re tempfile
libsip string traceback
Classes
msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol
Nibble
64 Adams Vibration
Classes
class Nibble(msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)

__init__(self, Model, InpMarkerList, OutMarkerList, UnBalMass)
Methods inherited from msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol:

ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
AvOutputChannel
This the entry point for the Output Cannel Property Editor
Modules
libsip os string
Classes
AvOutputChannel
AvOutputChannelCompliance
AvOutputChannelPredefined
AvOutputChannelUser
class AvOutputChannel
Adams Vibration Output Channel Base Class
Classes

Add(self, amdModel)
Name(self)
Returns the name of the output channel
__init__(self, Name, MarkerID=None)
Base class for AvOutput Channels:
@param Name: Name to assigne to output channel or none
@type Name: string
@param MarkerID: Adams Marker ID
@type MarkerID: integer
class AvOutputChannelCompliance(AvOutputChannel)
Adams Vibration Predefined Output Channel

Add(self, amdModel)
MarkerID(self)
Returns the marker ID of the output channel's marker
Compliance Output Channel
__init__(self, Name, MarkerID, RMarkerID=0)
Compliance AvOutput Channels:
Methods inherited from AvOutputChannel:

Name(self)
class AvOutputChannelPredefined(AvOutputChannel)
Adams Vibration Predefined Output Channel

JMarkerID(self)
MarkerID(self)
66 Adams Vibration
Classes
VariableFunctionPrefix(self)
Returns the string for the solver function i.e. DX, ACCZ
Predefined Output Channel
__init__(self, Name, MarkerID, GC, Dir, JMarkerID=0)
Predefined AvOutput Channels:
@param GC: Function <Displacement, Velocity, Acceleration, Force,
Angular Displacement, Angular Velocity, Angular Acceleration,
Torque>
@type GC: string
@param Dir: Direction <X, Y, Z, Mag>
@type Dir: string

Add(self, amdModel)
Name(self)
class AvOutputChannelUser(AvOutputChannel)
Adams Vibration User Output Channel

User Output Channel
__init__(self, Name, Function)
User AvOutput Channels:

@param Name: Solver function to use as output channel
@type Name: string
@param Function: function for the VARIABLE solver statement
Classes
@type Function: string

Add(self, amdModel)
Name(self)
AvPPTCmdExporter
The entry point for the Adams Vibration PPT interface
Modules
libsip re sys types
Classes
VibPPTCmdExporter
class VibPPTCmdExporter
Write .cmd file to create a vibration model in PPT

__init__(self, fullModelName, outFileName, amdModel, inputList, outputList, freqBegin,
freqEnd, freqSteps, doLogar)
Constructor:
@param fullModelName: Name to assigne to the model
@type fullModelName: string
@param outFileName: Name of file to write
@type outFileName: string
@param inputList: List of input channels in the model
@type inputList: list
@param outputList: List of output channels in the model
@type outputList: list
@param freqBegin: Starting frequency
@type freqBegin: double
68 Adams Vibration
Classes
@param freqEnd: Ending frequency

@type freqEnd: double
@param freqSteps: Number of steps to take
@type freqSteps: integer
@param doLogar: Spacing of steps false = linear true = log
@type doLogar: bool
computeOmegas(self)
Compute the descrete frequencies to use in the analysis
fullMarkerNameFromID(self, markerID)
Given a amerker ID, build a string represening the marker's full name
writeCmdForPPT(self, model)
Write a .cmd file to construct the vibration analysis in PPT
writeInputChannelPSD(self, ic, InList)
Output PSD input channel
writeInputChannelStateVariable(self, ic)
Output StateVariable input channel
writeInputChannelUser(self, ic)
Output User input channel
writeOutputChannelPredefined(self, oc)
Output predefined output channel
writeOutputChannelUser(self, oc)
Output User output channel
writeReplaceEigenSolution(self)
writeUserActuator(self, ic)
Output an actuator as user type
writeVibrAnalysis(self)
Create the vibration analysis
Functions
psdFunc(argList, w)
User function used to test this module
AvResFileWrite
Classes
Modules
libsip re sys types
Classes
XRFWrite
class XRFWrite

AListFromMatrix(self, mat)
ActName(self)
ErrStr(self)
Model(self)
Response(self)
WriteRes(self, MdlBaseName, iDir, oDir, ResName, FreqRange, AnaList)
WriteResToXRF(self, amdModel, Ana, ResVarName, ResLegend, AnaInpChLst,
AnaOutChLst, Res)
__init__(self, modl)
Functions
CallerName(TstName)
SetName(Name)
message_handler(msg, type, data)
Message handler for vibration
AvReview
70 Adams Vibration
Classes
Modules
libqtc re tempfile
Classes
AvReview
class AvReview

Name(self)
Run(self)
__init__(self, test, Name=None)
Data and non-method functions defined here:

__doc__ = None
__module__ = 'AvReview'
str(object) -> string
Return a nice string representation of the object.
Functions
bitBlt(...)
qAlpha(...)
qAppName(...)
qBlue(...)
qDrawPlainRect(...)
qDrawShadeLine(...)
qDrawShadeRect(...)
qDrawWinButton(...)
qDrawWinPanel(...)
qGray(...)
Classes
qGreen(...)
qRed(...)
qRgb(...)
qRgba(...)
qVersion(...)
qt_xdisplay(...)
qt_xrootwin(...)
qt_xscreen(...)
AvSuspension
Modules
libsip re sys types
Classes
AvSuspension
class AvSuspension
Adams Vibration Suspension Class

AligningTorqueCamber(self)
AligningTorqueSteer(self)
CamberAngle(self, spinAxis, Z=[0, 0, 1])
CasterAngle(self, kingPinAxis, roadVertical, roadLongitudinal)
CheckAngle(self, ang)
DiveBraking(self, BrakeRatio, TireR, TireStiffness, CGH, Weight, Wheelbase)
ForeAftWheelCenterStiffness(self)
FrontViewSwingarmLengthAngle(self)
KingPinAngel(self, L, R)
LateralForceDeflectionSteerCamberCompliance(self, TireR)
LiftSquatAcceleration(self, Dependent, SprungMass, CGH, Wheelbase, TireR, TireK,
AxleRatio, DriveRatio, Track, G)
72 Adams Vibration
Classes
PercentAntiDiveLiftAcceleration(self, Dependent, SprungMass, CGH, Wheelbase, TireR,

TireK, AxleRatio, DriveRatio, Track, G)
PercentAntiDiveLiftBraking(self, SprungMass, CGH, Wheelbase, TireR, TireK, BrakeRatio, G)
RideRate(self, TireK)
RideSteer(self, wcvl, wcvr)
RollCamberCoefficent(self, TireK, Track)
RollCasterCoefficent(self, TireK, Track)
RollCenterLocation(self, ContactPatchL, ContactPatchR, TireK)
RollRate(self, Track)
RollSteer(self, wAxisL, wAxisR, Track, TireK)
SideViewSwingArmAngleLength(self, Front=0)
ToeAngle(self, wcl, wcr)
TotalRollRate(self, TireK, Track)
WheelCenterToPatch(self, wcl, wcr)
WheelRate(self)
__init__(self, complianceMatrix)
Functions
MultiComplianceMatrixIGround(model, acf, markerId, logFile, AxAyAz=0)
MultiComplianceMatrixIJGround(model, acf, iMarkerId, jMarkerId, logFile, AxAyAz=0)
MultiComplianceMatrixIJRef(model, acf, iMarkerId, jMarkerId, rMarkerId, logFile, AxAyAz=0)
AvTest
Modules
libqtc re tempfile
Classes
AvTest
class AvTest
Classes

Build(self)
List(self)
Name(self)
PlotList(self)
Run(self)
__init__(self, build, Name=None)
Functions
bitBlt(...)
qAlpha(...)
qAppName(...)
qBlue(...)
qDrawPlainRect(...)
qDrawShadeLine(...)
qDrawShadeRect(...)
qDrawWinButton(...)
qDrawWinPanel(...)
qGray(...)
qGreen(...)
qRed(...)
qRgb(...)
qRgba(...)
qVersion(...)
qt_xdisplay(...)
qt_xrootwin(...)
qt_xscreen(...)
VibBodePlot : VibPlot2D Class

Constructors:
VibBodePlot(Title, FR, Frequency, Inputs, Outputs)
Constructor
74 Adams Vibration
Classes
Returns: object
Parameters:
string Title: plot title
AvAPI_Matrix FR: frequency response or transfer function matrix
AvAPI_Matrix Frequency: frequency vector used to calculate response
list of strings: list of input channel names
list of strings: list of output channel names
VibPlot : QWidget Class
From msc.Adams.Vibration.Plotting.VibPlot import *
void SetTitle(Title)
Set the main title for the plot
Returns: None
Parameters:
string Title: Title for plot
void SetTitleFont(Font)
Set the font used for the title
Returns: None
Parameters:
QFont Font: font to use
void SetTitleColor(Color)
Set the color used for the title
Returns: None
Parameters:
QColor Color: color to use
void SetCurrentColor(Color)
Set the default color used for plot objects
Classes
Returns: None
Parameters:
QColor Color: default color to use
VibPlot2D : VibPlot Class
Data Members:
enum eAxis
{
LEFT,
RIGHT,
BOTTOM
};
enum eScale
{
LINEAR,
LOGARITHMIC,
DB
};
enum eSymbol
{
NONE,
CIRCLE,
SQUARE,
DIAMOND,
TRIANGLE,
UTRIANGLE,
LTRIANGLE,
RTRIANGLE,
CROSS,
XCROSS,
HLINE,
VLINE
};
76 Adams Vibration
Classes

void SetAutoLegend(OnOff )
Set the state of automatic legend
Returns: None
Parameters:
bool OnOff: state of automatic legend
void SetGridMajorXPen(Pen)
Set the color and style used for the Major grid lines
Returns: None
Parameters:
QPen Pen: pen used to draw major X grid lines
void SetGridMinorXPen(Pen)
Set the color and style used for the Minor grid lines
Returns: None
Parameters:
QPen Pen: pen used to draw minor X grid lines
void SetGridMajorYPen(Pen)
Set the color and style used for the Major grid lines
Returns: None
Parameters:
QPen Pen: pen used to draw major Y grid lines
void SetGridMinorYPen(Pen)
Set the color and style used for the Minor grid lines
Returns: None
Parameters:
QPen Pen: pen used to draw minor Y grid lines
Classes
void SetAxisTitle(Axis, Title)

Set the title for the given axis
Returns: None
Parameters:
VibPlot2D::eAxis Axis: axis to set title for (LEFT, RIGHT, BOTTOM)
string Title: title text for the axis
void SetAxisTitleAngle(Axis, Angle)

Set the angle for the axis title
Returns: None
Parameters:
VibPlot2D::eAxis Axis: axis to set (LEFT, RIGHT, BOTTOM)
float Angle: angle in degrees for the text
void SetAxisTitleFont(Axis, Font)

Set the font for the axis title
Returns: None
Parameters:
void SetAxisTitleColor(Axis, Color)

Set the color for the axis title
Returns: None
Parameters:
void SetAxisScale(Axis, Scale)

Set the scale for the axis
Returns: None
Parameters:
78 Adams Vibration
Classes

VibPlot2D::eScale Scale: scale to use (LINEAR, LOGARITHMIC, dB)
void SetAxisPen(Axis, Pen)

Set the pen for the axis
Returns: None
Parameters:
QPen Pen: pen used to draw axis
void SetLegendColor(Color)
Set the color used for legend
Returns: None
Parameters:
void SetLegendFont(Font)
Set the font used for the legend
Returns: None
Parameters:
uint InsertCurve(Name, X, Y)
Add a curve to the plot
Returns:
unsigned int: curve id
Parameters:
string Name: curve name (legend text)
AvAPI_Matrix X: x data for the curve
AvAPI_Matrix Y: y data for the curve
void RemoveCurve(cID)
Classes
Delete a curve from the plot

Returns: None
Parameters:
unsigned int cid: curve id
void SetCurvePen(cid, Pen)

Set the color and style used for the curve
Returns: None
Parameters:
QPen Pen: pen used to draw the curve
void SetCurveAxis(cid, Axis)

Set the axis for for the curve
Returns: None
Parameters:
VibPlot2D::eAxis Axis: axis to plot curve (LEFT, RIGHT)
void SetCurveSymbol(cid, Symbol)

Set the symbol for for the curve
Returns: None
Parameters:
VibPlot2D::eSymbol Symbol: symbol to use for curve (NONE, CIRCLE, SQUARE, DIAMOND,
TRIANGLE, UTRIANGLE, LTRIANGLE, RTRIANGLE, CROSS, XCROSS, HLINE, VLINE)
void SetCurveSymbolSize(cid, Size)

Set the symbol size for for the curve
Returns: None
Parameters:
80 Adams Vibration
Classes
int Size: size in pixels for the symbol
void SetCurveSymbolPen(cid, Pen)

Set the color and style used for the symbol
Returns: None
Parameters:
QPen Pen: pen used to draw the symbol
void SetCurveSymbolFrequency(cid, Skip)

Set the frequency of symbols
Returns: None
Parameters:
int Skip: number of data points between symbols
void clear()
Clear the plot
Returns: None
Parameters: None
Constructors:
VibPlot2D()
Constructor
Returns: object
Parameters: None
VibPlot3D : VibPlot Class
Data Members:
enum eDRAWMODE
{
FLOWLINES,
WIREFRAME,
Classes
SHADE,
BOTH
};

void SetShadeMode(Sid, DRAWMODE)
Set surface shading mode
Returns: None
Parameters:
unsigned int Sid: surface id
VibPlot3D::eDRAWMODE DRAWMODE: surface shading mode (FLOWLINES, WIREFRAME,
SHADE, BOTH)
void SetFlow(Sid, nS, nT)

Set number of flow lines to draw
Returns: None
Parameters:
unsigned int Ns: number of lines to draw
unsigned int NT: number of lines to draw
void SetPoints(Sid, Ns, NT)

Set number of points for the flow lines
Returns: None
Parameters:
unsigned int Ns: number of points to use
unsigned int NT: number of points to use
void SetAxis(OnOff )
Set the state of axis
Returns: None
82 Adams Vibration
Classes
Parameters:
bool OnOff: state of axis
void SetTriad(OnOff )
Set the state of triad
Returns: None
Parameters:
bool OnOff: state of triad
void SetTextureMap(Sid, fName)

Set the texture map of the given surface
Returns: None
Parameters:
string fName: file name of the texture map
void SetColor(Sid, Color)

Set the color of the given surface
Returns: None
Parameters:
uint AddSurfaceData(Mat2D, orderS, orderT)

Add a surface to the plot by fitting the given data
Returns:
unsigned int sID: surface id
Parameters:
AvAPI_Matrix Mat2D: data points to fit
int orders: order to use in the S direction
int orderT: order to use in the T direction
Classes
uint AddSurface(Mat3D, orders, orderT, sKnot, tKnot)

Add a surface to the plot
Returns:
Parameters:
AvAPI_Matrix Mat3D: control points
int orders: order to use in the S direction
int orderT: order to use in the T direction
AvAPI_Matrix sKnot: knot vector
AvAPI_Matrix tKnot: knot vector
uint AddSpline(Mat2D, order, Knot)

Add a surface to the plot
Returns:
unsigned int cID: spline id
Parameters:
AvAPI_Matrix Mat2D: control points (x, y, z)
int order: order to use
AvAPI_Matrix Knot: knot vector
uint AddSplineData(Mat2D, order)

Add a spline to the plot by fitting the given data
Returns:
unsigned int cid: spline id
Parameters:
AvAPI_Matrix Mat2D: data points to fit
int order: order to use
void Remove(cid)
Delete a spline or surface from the plot
84 Adams Vibration
Utility Functions
Returns: None
Parameters:
unsigned int cid: spline or surface id
Constructors:
VibPlot3D()
Constructor
Returns: object
Parameters: None
Utility Functions
AvUtils
The entry point for the Adams Vibration Input Channel
Modules
msc.Adams.Vibration.libAvAPIc math string sys
libsip os struct traceback
Classes
AvModalEnergy
class AvModalEnergy

DissipativeEnergy(self, on)
Header(self, on)
KineticEnergy(self, on)
ModeRange(self, start, end)
NormalizedCoordinates(self, on)
Off(self)
Set(self)
StrainEnergy(self, on)
Utility Functions
Functions
AvDacFileToMatrix(filename, nPts)
AvDatFileToMatrix(filename, nPts)
AvFFTDataActuator(argList, w)
AvMakeFrequency(start, end, steps, spaceLog)
Compute the descrete frequencies to use in the analysis
start - start frequency HZ
end - end frequency HZ
steps - number of steps to take from start to end
spaceLog - if true frequencies are log spaced other wise linear spacing
Note: List returned is steps+1 long in radians/sec
AvMessageHandler(msg, type, args)
Default Message handler for vibration
AvPSDDataActuator(argList, w)
AvReadDataFile(dataFile, n=-1)
AvReadDataFileFD(filename, nPts=-1)
AvRpcFileToMatrix(filename, nPts)
Description: Implementation of rpc3file_input class member functions
for reading in data from an RPC III time history file.
Reference: MTS RPC III file format document
RPC_III saves the time history data in the following way:

ch1 --> group1 ->{frame1, frame2, ...}
...
chn --> group1 ->{frame1, frame2, ...}
...
chn --> group2 ->{frame1, frame2, ...}
...
Number of frames in group = PTS_PER_GROUP/PTS_PER_FRAME

Total number of groups = (FRAMES+1)/Number of frames in group
86 Adams Vibration
Utility Functions
Note: The last group may not be full. Full frames are only
required, not full groups. So the last group may
contain fewer than Number of frames in group.
Clarification - the group will be full but may not
contain all frames of acquired data
AvSolverSetup()
Mag(cVal)
Complex Mag and Phase
Phase(cVal)
byteSwap(CC)
formatExceptionInfo(logFile, maxTBlevel=10)
writeMatrix(matFile, Mat, title=None)
write a matrix to a file
@param matFile: File to write to
@type matFile: file object
@param Mat: Matrix to write
@type Mat: AvAPI_Matrix
@param title: String to preceed the matrix in the file
@type title: string
writeMatrix2(matFile, Mat, title=None)
write a matrix to a file
@param title: String to preceed the matrix in the file
@type title: string
writeMatrixXML(matFile, Mat, title='Matrix', space=2)
write a matrix to a XML file
@param title: Name of matrix [default: Matrix]
Utility Functions
@type title: string

@param space: Starting indentation for matrix [default: 2]
@type space: integer
@Note: Assumes the matrix is complex
writeXMLFooter(matFile)
write vibration footer for xml
writeXMLHeader(matFile)
write vibration header for xml
88 Adams Vibration
Utility Functions
Reviewing Your Model
Importing Vibration Results
You can import a previously generated results file and attach it to a vibration analysis. This enables you to
plot vibration data generated from the eigen and state matrices in the results file. The imported results file
and the vibration analysis must be from the same model.
To import vibration results:

1. From the Vibration menu, point to Review, and then select Import Vibration Results.
2. Complete the dialog box as described in Importing Vibration Results.
3. Select OK.
Displaying Eigenvalues
The Eigenvalue table displays the eigenvalue of a given analysis.
To display eigenvalues:
1. From the Vibration menu, point to Review, and then select Display Eigenvalue Table.
2. Complete the dialog box as described in Eigen Information.
3. Select OK.
Displaying Modal Information

In the Modal Information Table dialog box, you can view the Modal Coordinates, Modal Participation, or
Modal Energy table and Marker Mode Shape table. The Modal Coordinates and Modal Participation tables
are always available when a forced vibration analysis is performed. The Modal Energy table and Marker Mode
Shape table is available when modal energy computation is turned on before performing a forced vibration
or normal mode analysis.
To display modal information:

1. From the Vibration menu, point to Review, and then select Display Modal Info Table.
2. Complete the dialog box as described in Modal Information.
Note: You can display the same modal information from Adams PostProcessor by selecting the
Modal Info button in the dashboard.
116 Adams Vibration
Animating Your Results

Animating Forced Vibration Analyses
For general information on animating, see the Adams PostProcessor online help.
To animate a forced vibration analysis:

1. Display the Adams PostProcessor in Animation mode.
2. Right-click the animation window, and then select Load Vibration Animation.
3. From the Database Navigator, select the vibration analysis you want to plot.
4. Select Forced Vibration Animation.
5. Specify values as described in Animation Dashboard - Vibration Animation.
6. Select the Play tool.
Animating Normal Modes Analyses

You can animate the model to inspect and relate mode shapes with mode numbers. Remember, doing a
normal modes animation outside of Adams Vibration is called a frequency-domain animation. So, if you’re
referring to the online help for Adams PostProcessor for more information on normal modes animation, read
the sections on frequency-domain animations.
To animate a normal modes analysis:

1. Display Adams PostProcessor in Animation mode.
2. Right-click the animation window, and then select Load Vibration Animation.
3. From the Database Navigator, select the vibration analysis you want to display.
4. Select Normal Mode Animation.
5. Specify values as described in Animation Dashboard - Vibration Animation.
6. Select the Play tool .
Plotting Your Results

Plotting Adams Vibration Output in Adams PostProcessor
To perform a complete vibration analysis, you first pre-process your model using Adams View and Adams
Car. Then, you use Adams Vibration to set up and perform vibration analysis. Finally, you post-process the
results using Adams PostProcessor. Post-processing involves animating forced vibrations and plotting
frequency response functions, generating modal coordinates tables, and displaying other time and frequency
data (see table below).
Reviewing Your Model 117
Note: Doing a normal modes animation outside of Adams Vibration is called a frequency-domain
animation. So, if you’re referring to the Adams PostProcessor online help for more information on
animation, read the sections on frequency-domain animations
You can validate Adams Vibration results using Adams PostProcessor. Using Adams PostProcessor you can
plot several key pieces of data, including:
 Frequency Response
 Modal Coordinates
 Modal Participation
 Power Spectral Density (PSD)
 System Modes
 Transfer Function
 3D
The following table outlines how you can view Adams Vibration results:
Vibration Results: View as:

System Modes Complex Scatter
Normal Modes
Animation Forced
Vibration Animation
PSD Plots
Frequency Response Plots
Modal Coordinates Plots and Tables
Modal Participation Factors Plots and Tables
Transfer Function Plots
Modal Energy Distribution Tables
Vibration Animation Normal Modes
Animation Forced
Vibration Animation
For general information plotting, refer to the online help for Adams PostProcessor.
Plotting in Three Dimensions

You can generate three-dimensional plots of frequency response functions (FRF) in the Adams Vibration
postprocessing environment. This feature enables you to show multiple FRFs from a Design study in frequency
domain within the same three-dimensional plot, and better visualize the effect of a design change on the
frequency response function. The three-dimensional plots feature allows additional complex representations
118 Adams Vibration
of results. For example, plot FFTs of a time domain signal obtained with different windowing parameters and
display them in a waterfall format.
To plot frequency response in three dimensions:

1. In Adams PostProcessor, set the pulldown menu located in the menu bar below the File menu to
Plot3D.
2. In the Vibration Analysis text box, select all analyses you wish to include in your plot.
3. Select your input channels.
4. Select your output channels.
5. Select Add Surface to create the three-dimensional plot.
For more information on setting the display of three-dimensional plots, see Controlling the Display of Three-
Dimensional Plots.
Plotting Frequency Response

You can plot the frequency response, change the scale for plotting, and split the Adams PostProcessor plotting window to
compare plots of frequency response functions to see the phase shift.
To plot the frequency response:

1. Display Adams PostProcessor in Plotting mode.
2. Set Source to Frequency Response.
3. From the Vibration Analysis list, select the vibration analysis you want to plot.
4. From the Input Channels list, select the input channels you want to reference.
5. From the Output Channels list, select the output channels you want to reference.
6. Select one of the following:
• Use Individually: Computes and displays a curve for each selected input channel/output
channel pair.
• Sum All Input Channels: Computes and displays a curve for each output channel selected. The
curve is the sum of the response for all the input channels.
• Sum Selected Input Channels: Works like Sum All Input Channels, but only uses the selected
inputs.
7. Select Add Curves.
Adams PostProcessor plots the frequency response in the default scale (dB).
8. To plot the phase angle of the response, select Phase.
Learn more about Frequency Response.
To change the scale for plotting the frequency response:

1. Right-click the horizontal axis of the plot, point to Axis: haxis, and then select Select. (This selects
the horizontal axis.)
2. Set the Scale to Logar, dB, or Linear.
Note: If you change the axis limits, the upper and lower limits will have different meanings.
For example, in the logarithmic scale, the limit values are the exponent. So, if the values
are 2 and 3, the limits are 102 and 103 or 100 and 1000, respectively. In a linear scale,
values of 2 and 3 actually mean limits of 2.0 and 3.0, respectively.
3. Right-click the vertical axis of the plot, point to Axis: vaxis, and then select Select.
4. Set the Scale to either Logar, dB, or Linear.
To split the Adams PostProcessor plotting screen:
 Right-click the Page Layout tool , and select the 2 Views-over & under tool .
The plotting area of the screen splits into two plots, one containing the frequency response plot, and
the other containing a blank plot. You can then create a new plot in the blank region.
Plotting Modal Coordinates
To plot modal coordinates:

2. Set Source to Modal Coordinates.
5. Set Modal Coordinates By to one of the following:
• Mode - How the modal coordinate value changes with frequency.
• Frequency - What modal coordinates are active at a frequency.
6. Complete one of the following:
• If you selected Mode, select the mode whose coordinate value you want to plot.
• If you selected Frequency, select the frequencies at which coordinates are to be plotted.
Learn more about Modal Coordinates.
Plotting Modal Participation

Modal Participation is the absolute contribution of model modes to the transfer function for the model.
To plot modal participation:

120 Adams Vibration
2. Set Source to Modal Participation.

5. Select the mode whose participation value you want to plot.
Plotting Power Spectral Density (PSD)
To plot PSD:
2. Set Source to PSD.
Learn more about Power Spectral Density (PSD).
Plotting System Modes
To plot system modes:

2. Set Source to System Modes.
3. From the Simulation list, select the simulation you want to plot.
4. From the Eigen list, select the Eigen you are interested in examining.
5. Select Add Scatters.
To display a table of eigenvalues next to your scatter plot:
1. Split the plotting area by selecting the Page Layout: 2 Views, side by side tool .
2. Right-click the left view, and then select Load Vibration Animation.
3. Select Table of Eigenvalues.
4. Select Save to File and save as eigen.txt.
5. Right-click the right view, and then select Load Report.
6. Select eigen.txt.
Plotting Transfer Function

You can plot the transfer function, change the scale for plotting, and split the Adams PostProcessor plotting window to
compare plots of frequency response functions to see the phase shift.
To plot the transfer function:

2. Set Source to Transfer Function.
Adams PostProcessor plots the transfer function in the default scale (dB).
7. To plot the phase angle of the response, select Phase.
To change the scale for plotting the transfer function:

1. Right-click the horizontal axis of the plot, point to Axis: haxis, and then select Select. (This selects
the horizontal axis.)
2. Set the Scale to Logar, dB, or Linear.
Note: If you change the axis limits, the upper and lower limits will have different meanings.
For example, in the logarithmic scale, the limit values are the exponent. So, if the values
are 2 and 3, the limits are 102 and 103 or 100 and 1000, respectively. In a linear scale,
values of 2 and 3 actually mean limits of 2.0 and 3.0, respectively
3. Right-click the vertical axis of the plot, point to Axis: vaxis, and then select Select.
4. Set the Scale to either Logar, dB, or Linear.
To split the Adams PostProcessor plotting screen:
 Right-click the Page Layout tool , and select the 2 Views-over & under tool .
The plotting area of the screen splits into two plots, one containing the transfer function plot, and the other
containing a blank plot. You can then create a new plot in the blank region.
Nastran Modal Export

You can export modal coordinates of flexible body in MDF file format to recover stress and strain information
in MSC Nastran. You need restart run in Nastran to recover stress and strain information. In brief, first create
flexible body using Nastran, then do vibration analysis in Adams on model that use this flexible body, export
122 Adams Vibration
modal coordinates for this flexible body in MDF file format, re-start Nastran run to recover element stress
and strain information.
To export modal coordinates:

1. From the Vibration menu, point to Review, and then select Nastran Modal Export.
2. Complete the dialog box as described in Nastran Modal Export.
3. Select OK.
Improving Your Model
Design Constraints
To learn more about design constraints in general, see the Adams View online help.
To create a vibration design constraint:

1. From the Vibration menu, point to Improve, point to Vibration Design Constraint, and then select
Create.
The Create Design Constraint dialog box opens with the Definition text box set to View Variable
and Vibration Macro. Then, the Create Vibration Design Constraint Macro dialog box opens
automatically.
2. Follow the instructions in the dialog box help for Create Vibration Design Constraint Macro.
3. Select OK in the Create Vibration Design Constraint dialog box.
4. Select OK in the Create Design Constraint dialog box.
To delete a vibration design constraint:

Delete.
2. From the Database Navigator, select the design constraint macro you want to delete.
Adams Vibration deletes the macro.
To evaluate a vibration design constraint:

Evaluate.
2. From the Database Navigator, select the design objective macro you want to evaluate.
3. In the Optimize Constraint Evaluate dialog box, enter the name of the macro and the analysis with
which it is associated.
4. Select OK.
An information window appears with the details of the macro.
To modify a vibration design constraint:

Modify.
2. From the Database Navigator, select the design constraint you want to modify.
3. Enter your changes.
4. Select OK.
126 Adams Vibration
Design Evaluation Tools

You can start a parametric analysis to help you investigate the influence of design variables on model
performance. During a parametric analysis, Adams View runs a series of simulations with different values for
the design variables and gives you feedback on the effects of the changes. To learn more about parametric
analyses, see the Adams View online help.
To start a design evaluation:

1. From the Vibration menu, point to Improve, and then select Design Evaluation.
2. Complete the dialog box as described in Design Evaluation Tools.
3. Select OK.
Design Objective Macros

You can create a macro to retrieve vibration-specific data and use it when performing a Design study. To learn
more about design objectives in general, see the Adams View online help.
To create a vibration design objective macro:

1. From the Vibration menu, point to Improve, point to Vibration Design Objective, and then select
Create.
The Create Design Objective dialog box opens with the Definition text box set to View Variable and
Vibration Macro. Then, the Create Vibration Design Objective Macro dialog box opens
automatically.
2. Follow the instructions in the dialog box help for Create Vibration Design Objective Macro.
3. Select OK in the Create Vibration Design Objective dialog box.
4. Select OK in the Create Design Objective dialog box.
To delete a vibration design objective macro:

Delete.
2. From the Database Navigator, select the design objective macro you want to delete.
Adams Vibration deletes the macro.
To evaluate a vibration design objective macro:

Evaluate.
2. From the Database Navigator, select the design objective macro you want to evaluate.
3. In the Optimize Object Evaluate dialog box, enter the name of the macro and the analysis with which
it is associated.
4. Select OK.
Improving Your Model 127
An information window appears with the details of the macro.
To modify a vibration design objective macro:

Modify.
2. From the Database Navigator, select the design objective macro you want to modify.
3. Enter your changes.
4. Select OK.
128 Adams Vibration
Adams Vibration Theory 129
Adams Vibration Theory

Using Adams Vibration, you can compute system response in the frequency domain. You can perform two
types of analyses:
1. Normal-modes analysis
2. Forced response analysis
A normal modes analysis computes eigenvalues and eigenvectors of your model at any operating point you
specify. We define an operating point as the current configuration of the model. You may launch either a
normal modes analysis or a forced response analysis at any type of operating points, static or dynamic. These
analyses are effective in understanding natural modes of vibration for the model and in determining the basic
dynamic characteristics of your model.
Normal modes analysis is relevant in many scenarios. In one scenario, you may need to assess dynamic
interaction between parts in an Adams model. For example, if you are designing a washing machine, it is
necessary to determine if the operating rotational frequency of the tub is close to one or more natural
frequencies of the supporting structure and electronic components. If they are, then ordinary operation of
the washing machine may lead to damage of the supporting structure and/or premature failure of electrical
and electronic components in the machine.
If you are setting up a physical test, a normal-modes analysis is useful in determining the best location on
your systems to attach strain gauges and/or accelerometers. After the test, test results can be correlated with
the results of the normal-modes analysis.
Frequency-response analysis is an efficient method for finding the steady-state model response to sinusoidal
excitation. In this analysis, the loading is in the form of a sine wave for which you specify the frequency,
amplitude, and phase. Adams Vibration performs frequency response analysis using linearized Adams models.
Several different types of inputs can be applied to the model and force and kinematic output measured.
This document describes the theory and modeling constructs used in Adams Vibration. It is a companion to
the on-line product documentation. We assume you are familiar with using the product in its interactive or
batch environments. If not, consult the on-line product documentation for Adams Vibration before reading
this document.
The next section presents linearization theory for Adams model followed by definitions of vibration modeling
entities available in Adams Vibration. Next, we discuss acoustic pressure recovery, and finally the last section
provides a list of references you may want to consult for more details on the respective topics.
Linearization in Adams Vibration

Nonlinear Adams models are represented by implicit equations of the form:
G ( z·, z, t ) = 0 (1)
where:
130 Adams Vibration
 z = vector of states of the model.

 G = system of first-order differential and algebraic equations.
The states of the model include:
 Displacement and velocity states from mass-bearing elements PART, POINT_MASS, and
FLEX_BODY
 First-order states introduced by the DIFF, LSE, GSE, and TFSISO modeling elements
 Forces variables due to force elements (SFORCE, VFORCE and so on)
 Lagrange multipliers due to kinematic constraints (JOINT, JPRIM, MOTION, PTCV and CVCV)
 Variables defined in the model (VARIABLE).
This system of equations is linearized about an operating point z0. An operating point is defined by an initial-
conditions analysis or static or dynamic analysis [Sohoni, 1986; Negrut and Ortiz, 2005]. Using a process of
eliminating algebraic equations from the linearized representation of, ordinary differential equations along
with algebraic output equations of the following state-space form are obtained:
x· = Ax + Bu
(2)
y = Cx + Du
where:
 x = Vector of states of the linear model (a subset of vector z above)
 y = Outputs from the linear model (defined with POUTPUT statements or output channels in the
graphical interface.)
 u = Inputs to the linear model (defined with PINPUT statements or input channels in the graphical
interface.)
 A,B,C,D = Real state matrices for the linear model computed by the linearization algorithm.
Specific details of the linearization process implemented in Adams Solver (FORTRAN) are given by Sohoni
[1986]. Negrut and Ortiz [2005] have given details of linearization process implemented in Adams Solver
(C++).
States of the linear model, x in equation (2) are a subset of states of the nonlinear model, represented by z in
(1). When performing normal-modes analysis, specification of inputs and outputs is not required. Therefore,
the problem is reduced to finding a solution to the homogeneous equation:
x· = Ax (3)
Representing the solution to equation (3) as:
i
i λt
x(t) = ζ e
where:
i
 ζ = ith eigenvector
i
 λ = ith eigenvalue
Substituting in equation (3) gives:
i i i
Aζ = λ ζ (4)
Equation (4) is the classic eigenvalue problem. This problem is solved in Adams Vibration using the well-
known QR method [Press et. al., 1994] for computing eigenvalues and eigenvectors. The A matrix includes
all damping effects in the model, however the damping terms are set to zero when the user selects the no
damping option.
Note that Adams Vibration always computes λ and ζ as complex quantities (complex eigensolution). The
complete eigensolution to equation (4) includes a modal matrix (matrix of mode shapes) and a vector of
eigenvalues.
Each eigenvalue has the form:
i 2
λ ≡ ω  – ξ + i 1 – ( ξ )  = λ r + iλ i
i i i i i
where:
i i 2 i 2
 ω = ( λ r ) + ( λ i ) is the ith natural frequency.
i i i
 ξ = –λr ⁄ ω
Differences between proportional and general viscous damping – Adams Vibration implements general
viscous damping. In these cases, the internally computed damping matrix is no longer proportional to mass
and/or stiffness matrices. Adams Vibration always uses a complex eigenvalue solution.
Forced Response Analysis

Inputs and outputs to the linear model are defined by means of input and output channels in Adams
Vibration. Input channels contribute to the B matrix. Output channels contribute to the C matrix. The D
matrix represents direct interaction between input and output channels. For more details, see Modeling of
Vibration Entities.
Using Laplace transform, equation (2) can be expressed in the form [De Silva, 2000]:
sx ( s ) = Ax ( s ) + Bu ( s ) (5)
y ( s ) = Cx ( s ) + Du ( s )
where:
 s = Laplace variable
132 Adams Vibration
 x(s), u(s), y(s) are the Laplace transforms of the state vector, inputs and outputs respectively.
From equation (5), the transfer function in the state-space form is given as:
(6)
Transformation to Modal Space

Using the model eigenvectors as a basis for the solution, equation (5) is transformed to modal space using the
modal transformation:
(7)
where:
 Z = Matrix of eigenvectors
 q(s) = Array of modal coordinates
The ith column of Ζ corresponds to eigenvector ζ i of the model.

Substituting from equation (7) in equation (5) gives:
(8)
Simplifying equation (8) gives:
(9)
where:
–1
 A m = Z AZ
–1
 Bm = Z B
 C m = CZ
Therefore, the transfer function for the model in modal space is given as:
Vibration Analyses
(10)
When asking for the transfer function of a model, you specify the range of values for s and the number of
steps. At each step in the range of s, transfer function H(s) is computed from the expression in the right-hand
side of equation (10).
Transfer functions can be computed in two ways, that is, using equation (6) or equation (10). Solution of the
transfer function in the form of equation (6) is called the direct solution, while solution in the form equation
(10) is called the modal solution.
Adams Vibration uses the following steps to compute the transfer function for the model:
1. Get the given input/output channel specifications.
2. Compute state matrices in the state-space form as in equation (2).
3. Compute the complex eigensolution for the model using equation (4).
4. Transform to modal space using equation (9).
5. Compute transfer function from equation (10).
Due to degeneracy in the eigensolution, for some models, Z may not be invertible. In such cases, the transfer
function is computed using the direct solution of equation (6). The modal solution for transfer function
computation is much faster than the direct solution. If the transfer function is computed using the direct
method, it will not be possible to plot modal coordinates and participations or perform vibration animation
for the model. However, normal mode shapes can still be animated.
Vibration Analyses
Adams Vibration performs two types of vibration analyses:
 Normal Mode Analysis to compute eigenvalues and eigenvectors for a model
 Forced Vibration Analysis to compute the forced response of the model to vibratory inputs applied
using vibration input channels and actuators on the model. Eigenvalues and eigenvectors are also
available computed during the forced response analysis.
Normal Mode Analysis

The linearization of the equations of motion of a complex Adams system including coupled differential
equations, variable definitions, force definitions, controls systems and output equations is performed using
the algorithm in [Sohoni et al., 1986] when using the Adams FORTRAN Solver or the algorithm in [Negrut
et al., 2005] when using the Adams C++ Solver.
In either case, the linearized equations for the full system take the following form:
X· = AX + Bu
Y = CX + Du
134 Adams Vibration
Vibration Analyses
This linear representation is known as the minimal state-space representation or as the input/output
equations. Matrix A is called the linearization matrix and matrices B, C, and D have different names in the
technical literature. In general, vector X includes displacements, velocities and differential states of the model.
q 
 
X = z .
 
v 
Vector q includes a subset of all of the displacement states in the system while vector v is the corresponding
set of velocities. Vectors q and v are of the same size. Vector z includes all of the differential states defined in
the system. The z states are the results of DIFF, LSE, TFSISO, or GSE elements included in the model (those
elements define ordinary differential equations coupled with the mechanical system). Notice that vector q
may include a set of user-defined coordinates when using the Adams C++ Solver. The above references
describe the selection algorithm for the states in q. Adams Vibration, Adams Linear and the stand-alone
version of Adams Solver all provide tools to export the A, B, C, D matrices and the list of linearization
coordinates q, z, v, using two different file formats in ASCII form. Notice vector q includes neither Lagrange
multipliers nor force/variable definitions.
Vector u stands for inputs to the system. For the homogenous case (u=0) and no output equations, the state-
space representation reduces to:
X· = AX (11)
Simple case of no differential states

For clarity, consider first the case with no differential states in the Adams model, hence vector X takes the
form:
q 
X =   (12)
v 
In this case, the linearization matrix A takes this form:
0 I
A = (13)
–1 –1
–M K –M b
Here M, K and b are matrices that may not be symmetric. I is the identity matrix. Using Equations (12) and
(13) into Equation (11), and simplifying we obtain:
q· = v
–1 –1
v· = – M Kq – M bv
These two equations combined reduce to the well-known form:
Vibration Analyses
Mq·· + bq· + Kq = 0 (14)

Equation (14) is called the MKB representation and matrices M, b and K can be exported using Adams Linear
into different file formats. Instead of performing a modal analysis using Equation (14), Adams Vibration
solves a complex eigenvalue problem using Equations (11) as the starting point. Representing the solution as:
λt
X = φe
Equation (11) transforms into a standard eigenvalue problem:
Aφ = λφ (15)
Adams Vibration uses a complex eigenvalue solution algorithm to compute eigenvalues λ and mode shapes
φ . In general, matrix A is non-symmetric and, in many cases, it can be ill conditioned or even singular.
Hence, mode shapes are not orthogonal. See [Meyer, 2000] for a complete set of properties and theorems
related to the eigensystem shown in Equation (15).
For the simple case defined by Equations (12), (13) and (14), there is an important property related the
computed mode shapes. A typical mode shape of the simple system can be split into:
 φq 
φ =   (16)
 φv 
Putting Equation (16) and (13) into Equation (15) we obtain:
0  φq 
I  φq 
  = λ  
–M K –M b  φv   φv 
–1 –1
After making simplifications, we obtain:
φ v = λφ q (17)
2
( λ M + λb + K )φ q = 0
However, matrices M, b and K need not be symmetric, hence orthogonality properties do not apply.
General case with differential states

For the case of Adams models that do have differential states, vector X and the A matrix take the general
forms:
q 
 
X = z  (18)
 
v 
136 Adams Vibration
Vibration Analyses
0 0 I
A = –A1 –A2 –A3 (19)
–1 –1 –1
–M K –M A4 –M b
Using Equation (19) into the homogenous Equation (11) we obtain after simplifications:
q· = v
z· + A 1 q + A 2 z + A 3 q· = 0
Mq·· + Kq + A 4 z + bq· = 0
The last two equations can be rewritten as:
··  z·  A 2 A 1  z 
0 0  z  + I A3 0 
 ··  ·+   =   (20)
0 M q  0 b  q  A4 K  q  0 
or
 ··
z  z·  z 
M'   + b'   + K'   = 0 (21)
·· ·
q  q  q 
Equation (21) is the MKB representation for the general system and, as above, matrices M', b', and K' can be
computed and exported using Adams Linear.
For the general case of Equation (19) the eigensolution will compute the eigenvalues and mode shapes using
the same algorithm used for the simple model with no differential states. Similarly, the linearization matrix
A is not symmetric and the orthogonality conditions do not apply except for very special cases. Defining a
generic mode shape as:
 φq 
 
φ =  φz  (22)
 
 φv 
and using Equation (19) and (15), we obtain after some manipulations:
Vibration Analyses
φ v = λφ q (23)
 2 0 0 I A3 A A   φz 
λ +λ + 2 1   = 0
 0M 0 b A4 K   φq 
Eigensolution
Adams Vibration will compute eigenvalues of matrix A using a QR algorithm regardless of the type of model.
We emphasize that the A matrix is, in general, non-symmetric, hence all orthogonality theorems for
computed mode shapes do not apply. Moreover, the A matrix does not need to be full rank nor well
conditioned. Adams models with control systems or in singular configurations (for example, neutral static
equilibrium, bifurcation points and so on) may exhibit multiple zero value eigenvalues or large real
eigenvalues.
In the general case, the size of the A matrix is:
N = 2n q + n z (24)
Where nq is the size of the q vector (vectors q and v are of the same size) and nz is the size of the z vector. The
eigensolution will compute a set of nr real eigenvalues and 2nc complex eigenvalues (all complex eigenvalues
form a set of conjugate pairs). Therefore:
1N = 2n q + n z = 2n c + n r (25)
Notice that Adams Vibration will only display a table with nc+nr eigenvalues only (conjugate complex values
are not displayed). See Eigenvalue Table Reported in Adams View for an example output using the Adams
Vibration user interface. Notice in the example in Table 1, there are 2 real-only eigenvalues and 2 complex
eigenvalues. Hence the size of the A matrix is 2*2+2=6.
By default the eigensolution is performed on the full computed A matrix. Hence, all damping properties in
the system are taken into account. If you want to compute the eigensolution without the damping properties,
then uncheck the Damping checkbox in the Perform Vibrational Analysis dialog box.
A very important notice is due here. If you use the Adams Solver C++, and if you uncheck the Damping
checkbox, Adams Vibration will set matrix b to zero in Equation (19) to get:
0 0 I
A = –A1 –A2 – A 3 (Adams Solver C++) (26)
–1 –1
–M K –M A4 0
However, if you use the Adams Solver FORTRAN, and you uncheck the Damping checkbox, Adams
Vibration will set both matrix b and matrix A3 to zero:
138 Adams Vibration
Vibration Analyses
0 0 I
A = –A1 –A2 0 (Adams Solver FORTRAN) (27)
–1 –1
–M K –M A4 0
If you would like Adams Solver C++ to flush the A3 matrix too, set the environment variable
MSC_ADAMS_SOLVER_NODAMP_DIFF to any value. The rationale behind not flashing the A3 matrix was
based on the purely philosophical assumption that damping is a mechanical property hence the coupling
between velocities and differential states (matrix A3) should be left unchanged.
See the Adams Solver C++ documentation for the command LINEAR for more information of using user-
defined coordinates. By default, vector q in Equations (12) and (18) is a subset of the global translational
displacements and instantaneous rotations of the center of mass of each PART. If there are FLEX_BODYs in
the model, vector q includes also all the corresponding states for the modal representation of each
FLEX_BODY. However, in rotordynamic models, users may need to obtain a linearization of the system
using a different set of coordinates (for example, r) defined as:
r = r(q) (28)
In that case, Adams Vibration will linearize the system into this form:
r· = A∗ r (29)
As presented in [Negrut et al., 2005], the eigenvalues in A* and A may not be the same.
In all cases, all computed eigenvalues may be expressed as:
2
λ = α ± iβ = w ( ξ ± i 1 – ξ ) (30)
Where w is defined as the undamped natural frequency and ξ is defined as the damping ratio. Solving
Equation (30) for both the undamped natural frequency and the damping ratio, we get the following results
for real-only eigenvalues:
w = α (31)
ξ = 1
For complex eigenvalues Equation (30) results in:
2 2
w = α +β (32)
α-
ξ = ---
w
See Eigenvalue Table Reported in Adams View for an example output showing the computed undamped
natural frequency, damping ratio, real value and imaginary value of the displayed eigenvalues of the model.
Vibration Analyses
Table 1 Eigenvalue Table Reported in Adams View
Undamped Natural
Mode Number Frequency ω r Damping Ratio ξ Real λr Imaginary λi
1 0.00617426 1 -0.00617426 0
2 16.6257 1 -16.6257 0
3 0.270866 0.23569 -0.0638404 +/-0.263235
4 0.712246 0.580427 -0.413406 +/-0.57999
Eigenvalues can be plotted as a complex scatter on a real-imaginary axis, as shown in Figure 1 Complex Scatter
Plot. The real part of eigenvalues corresponds to damping in a model. The imaginary part corresponds to
stiffness in the model. A mode with an eigenvalue of negative real part is considered stable. Conversely, a
mode with eigenvalues of positive real part is unstable. As shown in Figure 1 Complex Scatter Plot, eigenvalues
lying in the left half plane are stable and those in the right half plane are unstable.
Figure 1 Complex Scatter Plot
A model with all stable eigenvalues, if perturbed, will return to its original unperturbed configuration on
removal of the perturbation. A perturbation applied to a model with unstable eigenvalue(s) may cause
unstable modes to be excited. In this case, the model will have an unbounded response to this perturbation.
For more information, see Reference 4.
Regarding computed mode shapes ( φ ) , Adams Vibration does not export the computed mode shapes.
Should you need the computed raw mode shapes from matrix A, we suggest exporting the A matrix and
140 Adams Vibration
Vibration Analyses
compute the mode shapes using an eigensolver of your choice. The A may be exported using the
LINEAR/STATEMAT Solver command or using the Adams View user interface.
For animation purposes, Adams Vibration uses the following equation:
Q = Tφ q (33)
to obtain all coordinates in the model for given a particular mode shape. Matrix T is a transformation matrix
from the minimal state-space representation to the full representation of the model. Vector Q is used to
animate the mode shapes in the post processor and to display the Normalized Coordinates in the Energy
Tables options. A similar transformation is used to compute the velocity and differential states allowing the
computation of Kinetic Energy, Strain Energy and Dissipative Energy tables.
Forced Vibration Analysis

Forced vibration analysis, forced response analysis, and frequency response analysis are synonyms in this
context. A forced response analysis (FRA) in Adams Vibration requires you to create sets of input channels
(u) and output channels (Y) as described in the Building Your Model section.
The FRA begins by first building the state-space representation:
X· = AX + Bu (34)
Y = CX + Du
As shown in the previous section, vector X stands for the minimal state-space representation, matrix A is the
linearization matrix and matrices B, C and D are the input/output matrices computed using the definitions
of the input and output channels. Adams Vibration requires you to construct a vibration analysis using the
graphical interface. A vibration analysis consists of a collection of all the input and output channels, the
operating point specification, the frequency range and number of steps in this range. Options to turn off
damping matrices and the usage of user-defined states are also available.
Figure 2 Input and Output Channels
When using the Adams Vibration user interface to create an input channel, each input channel results in an
action-only SFORCE being created in the model along with a VARIABLE. The VARIABLE is used to define
the SFORCE. The expression for the variable is set to zero in the Adams Solver model because the
Vibration Analyses
computation of the B and D matrices do not require a value for the said VARIABLE. However, the input
channel definition will be used in the FRA subsequent analysis.
When creating an output channel, each output channel results in one VARIABLE being created. Function
expression for this entity depends on the type of output channel you define. On defining a vibration analysis,
the variable corresponding to the input channels are collected into a PINPUT and variables corresponding
to the output channels are collected into a POUTPUT. The model is linearized using this PINPUT and
POUTPUT pair. As shown in Figure 2. Input and Output Channels, each input channels contributes one
column to the B matrix. Each output channel defines one row of the C matrix.
The FRA proceeds with taking the Laplace transform of Equation (34) to obtain:
sx ( s ) = Ax ( s ) + Bu ( s ) (35)
Y ( s ) = Cx ( s ) + Du ( s )
Where s is the Laplace variable and x(s), u(s) and Y(s) are the transforms of X, u and Y respectively. Solving
for Y(s) we find:
–1
Y ( s ) = ( C ( sI – A ) B + D )u ( s ) (36)
Defining the transfer function H(s) as:
–1
H ( s ) = C ( sI – A ) B + D (37)
The forced response of all output channel is then:
Y ( s ) = H ( s )u ( s ) (38)
Adams Vibration will compute the value of each Y(s) for each s specified in the Vibration Analysis definition.
If the size of vector X is N, and there are ni inputs and there are no outputs, then the sizes of the matrices in
Equation (37) are:
AN × N
BN × ni
Cn0 × N
D n0 × ni
H n0 xni
Adams Vibration user interface allows the user to set a range of values for the variable s using different formats.
Notice that for each s computing the response Y(s) requires inverting a matrix of size NxN as shown in
Equation (37). If matrix A can be diagonalized, the response for each s is obtained following the
diagonalization algorithm shown in section Transformation to Modal Space.
142 Adams Vibration
Vibration Analyses
Transfer Function
The plots for the transfer function H(s) are computed from equation (37). Adams Post Processor displays each
plot by first selecting an input channel k and then selecting an output channel j in the post-processing
window. Each plot corresponds to the entry Hjk of the H(s) matrix for all values of s.
These plots are equivalent to setting input channel k to 1 and all other input channels to zero in Equation
(38), and displaying the jth entry of the resulting matrix-vector multiplication. See Figure 3 below.
Figure 3 Transfer Function plots.
Besides displaying each entry of the transfer function matrix H(s), Adams Post Processor allows plotting the
frequency response Y(s) for each output channel. Equation (38) may be rewritten as follows:
Yk ( s ) =  Hkj ( s )uj ( s ) (39)

j
The post processor plots each individual contribution of each input channel Hkj(s) uj(s) or the total sum. The
computed value is, in general, a complex value. The plots are computed for:
s = s b, …, s e
Vibration Analyses
Here sb and se are the Begin and End frequencies respectively as set by the user in the Vibration Analysis user
interface.
PSD Response Computation

Equation (39) provides the standard frequency response of the system's outputs given a set of inputs in the
frequency domain. However, in the field of Random Vibrations, analysts have the Power Spectral Density
Sxx(s) of an input and the objective is to compute the Power Spectral Density Syy(s) of an output. In this case,
the relation between a single PSD input Sxx(s) and a single PSD output Syy(s) with transfer function h(s) is:
2
S yy ( s ) = h ( s ) S xx ( s ) = h∗ ( s )h ( s )S xx ( s )
Where h*(s) stands for the complex conjugate of h(s).
Adams Vibration can be used to define input channels with actuators of either PSD type or non-PSD type.
Actuators of the non-PSD type are standard actuators with computed Fourier Transforms obtained from
measured input signals or theoretical functions entered as symbolic expressions in the user interface.
Actuators of the PSD type define a Power Spectral Density function (the Fourier Transform of the
autocorrelation of some signal).
Regardless of the type of input channels (either PSD type or non-PSD type), Adams Vibration computes
and displays the Power Spectral Density response of each output channel, or PSD(s).
For input channels using non-PSD type actuators, a non-standard estimation of the Power Spectral Density
is computed as follows:
1 2
u j ( s ) = -------- u j ( s ) (40)
2df
Here df is the difference between End and Begin frequencies as setup in the Vibration Analysis data. Notice
this estimation of the Power Spectral Density returns complex values. Using Equation (40), the response
PSD(s) is computed using the standard equation:
PSD k ( s ) =  H∗kj ( s )Hkj ( s )uj ( s ) (non-PSD type actuators) (41)

j
Here PSDk(s) is the response Power Spectral Density function for the kth output. Hkj*(s) is the complex
conjugate of Hkj(s). The summation is implied 1 to ni. Adams Post Processor does not compute the individual
contribution of each input channel when displaying PSDk(s). Notice we assume there are no cross
correlations between the inputs.
For actuators of the PSD type there are two cases to consider. If there are no cross-power spectral actuators
between the different input channels, the PSD(s) output is computed using the standard equation:
PSD k ( s ) =  H∗kj ( s )Hkj ( s )uj ( s ) (PSD type actuators, no cross correlation) (42)
j
144 Adams Vibration
Vibration Analyses
If there is a set of cross-power spectral actuators U(s), they can be ordered in matrix form as:
U ( s ) = U ij ( s ) n × ni
(43)
i
For this second case, the Power Spectral Density response PSD(s) is computed as:
PSD k ( s ) =  H∗kj ( s )  H km ( s )u jm ( s ) (PSD type actuators with cross correlation) (44)

j m
All summations in Equation (44) are implied 1 to ni.

Adams Vibration user interface provides the tools to define the matrix of cross-spectral actuators. When
defining a PSD type input channel Uii(s), check the Cross Correlation checkbox and click the Cross
Correlation Setup button to define the cross-spectral actuators Uij(s).
When plotting PSD response, input channels with actuators of type PSD cannot be mixed with actuators of
force type in one vibration analysis.
Units of SPLINE data for PSD input data

When defining PSD input data for force input channel by using SPLINE elements, the units of the SPLINE
data must be given in:
(force units)2/(frequency units)
where force units and frequency units match the global units set in the Adams model. In other words, the
units of the PSD data must be consistent with the units of the model. Once the Adams Vibration analysis is
completed, the output signals will have consistent units as specified in the system units for the model.
Similarly, if the input channel is an acceleration input channel, then the units of a PSD actuator must be given
in:
(acceleration units)2/(frequency units)
Modal Coordinates
Equation (35) can be transformed from the standard state-space representation into a "modal" representation.
We define the "modal" states q(t) as follows:
x ( t ) = zq ( t ) (45)
Matrix Z in Equation (45) is the modal matrix composed by the mode shapes obtained from the eigensolution
of the system. Notice Equation (45) is a representation of the solution x(t) in the time domain. Transforming
Equation (45) into the frequency domain, we obtain:
x ( s ) = Zq ( s ) (46)
Using Equation (46) into Equation (35) and simplifying we obtain an equivalent representation of the
frequency response of the system in terms of the "modal" states q(s):
Vibration Analyses
sq ( s ) = A m q ( s ) + B m u ( s ) (47)
Y ( s ) = Cm q ( s ) + Dm u ( s )
Matrices Am, Bm, and Cm are obtained from:
–1
A m = Z AZ (48)
–1
Bm = Z B
C m = CZ
Adams Vibration computes and displays the frequency response of each modal state qk(s). From Equation (47)
we obtain in matrix form:
–1
q ( s ) = ( sI – A m ) B m u ( s ) = M ( s )u ( s ) (49)
Equation (49) can be interpreted as the frequency response of each modal state. Moreover, for a given input
channel j and a given entry k in the modal vector q(s), Adams Vibration computes and plots:
q k ( s ) = M kj U j ( s ) (50)
s = s b, … s e
Equation (50) is the frequency response of the kth entry in the modal vector due to the jth input channel.
Adams Post Processor displays Equation (50) for the complete range of selected frequencies s. See Figure 4
below.
Note: Currently, in the Modal Coordinates plot options, the user interface wrongly shows the
number of different eigenvalues instead of the size of the state vector q(s). The modification of
the user interface will be executed in compliance with enhancement ADMS-37553.
146 Adams Vibration
Vibration Analyses
Figure 4 State space frequency response
While Equation (50) displays the response of a single state qk(s) for the whole range of specified frequencies s,
Adams Post Processor also displays the complete response of the modal vector q(s) for a given frequency so.
Evaluating Equation (49) for s=so and for the jth input channel (all other input channels are set to zero) we
obtain:
(51)
Vector q(so) is of size N (which is the size of the state matrix A) and Adams Post Processor display the contents
of this array.
See Figure 5 for an example plot of Equation (51). Notice the horizontal axis is the mode number from 1 to N
where N is the size of the linearization matrix A (see Equation (25)).
Vibration Analyses
Figure 5 State vector for a given frequency and input.
Modal Participation
While the modal coordinates define how active a certain mode qk(s) is at a given frequency s (see Equation
(50)), the modal participation identifies how much a given input ui(s) and a given mode qk(s) contribute to
the total frequency response of a specified output Yj(s). From Equation (47) we obtain:
(52)
The options to plot the Modal Participation in the Adams Post Processor allow selecting the ith input, the kth
mode and the jth output. See Figure 6 below.
148 Adams Vibration
Vibration Analyses
Note: Currently the plotting options, in Modal Participation plot, wrongly show the number of
different eigenvalues instead of the full range of modal coordinates. Also there is an incorrect
algorithm implementation providing approximate results only. The user interface and
implemented algorithm will be corrected following enhancement ADMS-37565.
Figure 6 Plot of Modal Participations
Modal Energy Computation

i. Kinetic energy distribution – Mass bearing modeling such as PART, POINT_MASS, and FLEX_BODY
contribute to kinetic energy distribution computation. The modal kinetic energy distribution in a system is
defined with respect to degree of freedom of various modeling elements mentioned above.
The modal kinetic energy of ith mode can be calculated as
(53)
where:
Vibration Analyses
 ε i = ith column mode shape vector of system mode shape matrix Φ

 Μ = System mass matrix
To find modal energy contributions from various parts and degrees of freedom, it is convenient to
substructure this system level energy equation to part level equations. Finally, these sub-structured part level
energies will be summed to calculate the system level modal kinetic energy.
Kinetic energy contribution of PART j to individual mode i can therefore be written as,
(54)
where:
 ζij = ith column vector of matrix Ψ j , which is condensed mode shape matrix from system mode
shape matrix Φ , corresponding to six degrees of freedom of PART j
 Μ j = Mass matrix of PART j
Adams Vibration breaks this modal kinetic energy contribution of PART j in nine components to present it
in modal energy tables:
1
K1j =  mζij (1)* ζij (1) 
2
1
K 2j =  mζij (2)* ζ ij (2) 
2
1
K 3j =  mζij (3)* ζij (3) 
2 (55)
1 j *
K 4j = ζ i (4) I xx ζ ij (4) 
2
1
K 5j = ζ ij (5)* I yy ζ ij (5) 
2
1
K 6j = ζ ij (6)* I zz ζ ij (6) 
2
K 7j = − ζ ij (4)* I xy ζ ij (5) 

K 8j = − ζ ij (4)* I xz ζ ij (6) 
K 9j = − ζ ij (5)* I yz ζ ij (6) 
150 Adams Vibration
Vibration Analyses
Equation (54) now equivalently expressed as,
(56)
Total kinetic energy for mode i can then be computed as,
n
Γi = τ i j (57)
j =1
where:
 Γi = Total kinetic energy of mode i
 n = Number of parts in the model
 τ i j = Kinetic energy contribution of PART j to mode i
Percentage distribution of PART j mode i kinetic energy in direction e is defined as:
(58)
Above equation shows that the percentage kinetic energy contribution of any degree of freedom to a
particular mode is independent on natural frequency of that mode and depends on the product of the mass
or inertia and square of the mode shape amplitude (mass and inertia terms) or product of mode shape amplitudes
(product of inertia terms) of the mode in that directions. As the sum of the kinetic energy contributions of all
degree of freedoms in that mode shape (not part degrees of freedom) is made equal to 100, through the
definition in equation , it is easy to identify the relative importance of various degrees of freedoms. This will
help to identify which particular degree of freedom is contributing more or less to the overall modal kinetic
energy.
Percentage kinetic energy contributed by PART j to mode i is defined as:
(59)
where:
Vibration Analyses
 Ti j = Percentage kinetic energy contributed by PART j to mode i

Equation (59) shows that the percentage kinetic energy contribution of any part to a particular mode is
independent on natural frequency of that mode and depends on the sum of product of mass (or inertia) and
square of the mode shape amplitude (mass and inertia terms) or product of mode shape amplitudes (product of
inertia terms) of that mode in all nine directions. As the sum of the kinetic energy contributions of all parts
is made equal to 100, it is easy to identify the relative importance of various parts over each other. This will
help to identify which particular part of model is contributing more or less to the overall modal kinetic energy.
It should be noted that the large kinetic energy contribution can be due to large mass (inertia) or motion of that
degree of freedom. Therefore, the modal kinetic energy density needs to be calculated to remove this ambiguity and
make it dependent only on mode shape. The modal kinetic energy density for a given mode is defined as the ratio of
modal kinetic energy contribution of a degree of freedom to the rigid body mass of the part.
Sometimes it is advantageous to normalize the modal kinetic energy contributions with respect to generalized mass
of that mode. This will make these modal kinetic energy distributions independent of mode shape normalization.
Adams Vibration computes the kinetic, strain, and dissipative energy distribution within modes of your
model. Table 1 Modal Energy Distribution shows an example of these distribution tables. These distributions
are important indicators of which components of the model have the greatest contribution to a given mode.
As in this example, PART_2 has the greatest contribution to the kinetic energy in this mode. The Strain
energy tables indicate that SPRING_2 stores the most amount of strain energy in this mode. Similarly, from
the dissipative energy table, SPRING_2 dissipates the most amount of energy in this mode.
Table 1 Modal Energy Distribution

152 Adams Vibration
Vibration Analyses
ii. Strain energy distribution - Compliant components, such as SPRINGDAMPER, SFORCE, BUSHING,
and so on, contribute to the computation of strain energy in a mode. In addition, FLEX_BODYs in the
model contribute to strain energy computation.
Strain energy due to a compliant element p is:
(60)
where:
p
 σ i = Strain energy in complaint element p for mode i
 Κ p = Matrix of size equal to model stiffness matrix, with all zero entries except stiffness matrix
entries contributed by compliant element p.
Percentage distribution of strain energy for mode i is given as:
Vibration Analyses
p
100 × σ i
S pi = m
σ
p =1
p
i ; p=1, …,m (61)
where:
 S p i = Percentage strain energy contribution by compliant element p to mode i

 m = Number of compliant elements in the model
iii. Dissipative energy distribution is computed in a similar manner to the strain energy distribution. In
p
100 × σ i
S pi = m
equation (60) σ
p =1
p
i ; p, the damping matrix is substituted for the stiffness matrix.
Stress Recovery
With Adams Vibration you can recover stresses and strains on flexible bodies. Recovering stresses on flexible
bodies is called Modal Stress Recovery (MSR). Adams Vibration allows you to export modal-coordinates
corresponding to flexible body modes that can later be used as input to FEM software like Nastran to recover
the stresses in the flexbody.
The linear deformation (y) of the flexbody nodes can be approximated as a linear combination of M
orthogonalized mode shape vectors ( Ψ ) of that flexbody.
(62)
The basic advantage of the modal superposition is that the deformation behavior of a component with a very
large number of nodal DOF can be captured with a much smaller number of modal DOF.
Adams Vibration exports the modal coordinates ( q ) in a Modal Deformation File (MDF) format (binary).
FEM software like Nastran then does the summation to get linear deformation of flexbody nodes and then
recovers stresses and strains as follows,
(63)
where:
 γ is the strain vector

 σ is the stress vector
 B is a function matrix of the FE geometry relating strains to displacements
154 Adams Vibration
Modeling of Vibration Entities
 E is the stress-strain relationship matrix.

Note that it is necessary to create a super-element of flexbody without any constraints (free-free boundary
condition). The restart run is necessary in Nastran to recover the stresses and strains.

This section presents the formulation for modeling the following vibration entities:
 Vibration Input Channels
 Vibration Actuators
 Vibration Output Channels
 Frequency-dependent (FD) Modeling Elements
Vibration Input Channels

A vibration input channel defines the location, orientation, and type of forcing function to be applied. There
are three types of input channels you can specify in Adams Vibration:
1. Force-type input channel applies a force at the specified marker. The expression for the force is as
specified by the vibration actuator.
2. User-specified state variable applies the vibration actuator to a state variable that you may have created
in your model. This input channel is useful in applying vibratory input to models that are represented
by general dynamical elements, such as GSE/LSE/TFSISO.
3. Kinematic input channel applies displacement, velocity, or acceleration input. This form of the input
channel imposes a kinematic constraint in the frequency domain at the specified marker. This
constraint will result in removal of one degree of freedom at the marker at which it is applied.
Note: Due to this constraint, the frequency response peaks may be shifted from the frequencies of
the normal modes of the model.
Vibration Actuators
A vibration actuator defines the magnitude and phase of the applied forcing function. Vibration actuators are
required for modeling forcing function in forced response analysis. Phase angle, as defined in a vibration
actuator, is with respect to the positive direction of the marker in the vibration input channel on which this
actuator is defined.
Vibration actuators are applied at the input channel after the model is linearized. Therefore, vibration
actuators are only in effect for frequency domain analysis and have no effect on the operation point analysis
for the model.
Swept Sine Actuator

Force applied in a swept-sine actuator is defined as:
where:
 f = force magnitude
 θ = phase angle
The phase angle θ is measured with respect to positive direction of the marker axis for the input channel on
which this actuator is acting.
Rotating Mass Actuator
Force Type
The force rotating mass actuator is represented by two actuators. The Leading and Lagging actuators are
represented as:
Figure 7 Rotating Mass Actuator
where:
 Ρle (s ) = Force applied in leading actuator

 Ρla (s ) = Force applied in lagging actuator
 m = Unbalanced mass
156 Adams Vibration
 r = Radial offset
 ω = Frequency of excitation
When you want to incorporate vibratory effects due to an unbalanced mass in your vibration analysis, you
must create two vibration actuators acting on the same input channel. The first actuator must be defined as
a Leading actuator and the second as the Lagging actuator.
Moment Type
The moment type of rotating mass actuator is applicable for simulating moments due to radial, as well as
axially offset unbalanced masses. The leading and lagging actuators are represented as:
Figure 8 Rotating Mass Actuator - Moment Type
where:
 Mle = Moment applied in the leading actuator
 Mla = Moment applied in the lagging actuator
 d = Axial offset between unbalanced masses
As with the force type rotating mass actuator, to incorporate vibratory moment effects due to an unbalanced
mass in your vibration analysis, you must create two vibration actuators acting on the same input channel.
The first actuator must be defined as a Leading actuator and the second as the Lagging actuator.
PSD Actuator
The PSD actuator is for defining a spectrum that you want to apply to the model. For more information on
power spectral density, see Reference 4. The PSD actuator is specified using a spline. You can create a spline
using the Function Builder in Adams View. In Adams Vibration, you can specify the autocorrelation PSD of
an input channel to itself, as well as the cross correlation PSD to other input channels. Section 4d provides
details of how auto and cross correlations are used for computing PSD response.
PSD type actuators cannot be mixed with swept sine, rotating mass, or user-type actuators in the same
vibration analysis. Response solution for PSD actuator is different from the force vibration response analysis.
Vibration Output Channels

Vibration output channels are defined using run-time expressions. These expressions can consist of kinematic
or force expression or some combination of the state variables you define.
Frequency-dependent (FD) Modeling Elements

FD modeling elements are useful for incorporating compliant components with frequency-domain force
characteristics in your model. These force characteristics may have been measured using a bench test in a
laboratory. Several flavors of frequency-dependent modeling elements are available within Adams Vibration.
From given force versus frequency characteristics, you can use system identification tools, such as described
in article 1-KB12433 (see MSC Software Knowledge Base) for identifying parameters needed for defining FD
element.
The FD modeling element is represented by a combination of spring and dampers in series and parallel. Each
FD element adds two internal auxiliary states for each direction. These differential and output equations are
contained within customized GSE subroutines in Adams Vibration.
A GFORCE element is used to apply forces on the I- and J-bodies between which you are applying the FD
element. When you add a 3D FD element to your model, Adams Vibration automatically creates a GSE and
GFORCE element in your model and instantiates the associated customized user subroutines for evaluation
of the force in the FD element.
FD modeling elements are usable in frequency domain, as well as time domain analysis.
158 Adams Vibration
Performing Acoustic Pressure Recovery
Figure 9 Scematic of One-dimentional FD Element
Performing Acoustic Pressure Recovery
Acoustic Pressure Recovery in Adams Vibration

With Adams Vibration you can recover acoustic pressure around flexible body. Recovering pressure around
flexible bodies is called Modal Pressure Recovery (MPR). You can perform MPR outside of Adams using
Nastran.
Acoustic Pressure Recovery DMAP

A special Nastran DMAP ALTER is required to input the modal velocities from a Nastran formatted file and
recover acoustic pressure in Nastran. For instructions regarding reading Modal Deformation File (MDF),
please refer the corresponding section for MSR help.
Acoustic Pressure Recovery Theory
Acoustic Pressure Recovery Analysis

The Adams modal synthesis method and its advantages are already covered in MSR help. During Adams
simulation, we assume that the fluid loading on structure is negligible. Then we export modal deformations
Acoustic Pressure Recovery Theory
from Adams to Nastran in MDF file format. Adams provides two options to user to recover acoustic pressure
in Nastran from the modal co-ordinate data.
1. Recover acoustic pressure without fluid loading.
2. Recover acoustic pressure with fluid loading.
Recover acoustic pressure without fluid loading.

The modal co-ordinates from Adams are directly used to find modal loading on fluid portion.
The second equation in Eq. 13-65 of Nastran Reference Manual (NRM) can be rewritten in terms of modal
load vector from Adams:
2 T ad ams (64)
{ ξ } = –ω [ Z 2 ] [ a ] { ξ }
f s
By knowing right hand side vector for every frequency step from Adams, the above equation can be solved
for ξ . From here, acoustic pressure {p} can be recovered using following equation.
f
{ p} = [Φf ]{ ξ } (65)
f
Recover acoustic pressure with fluid loading.

The modal co-ordinates from Adams are used to recover the modal structural load. The fluid-structure
coupled equations are then solved to get corrected modal co-ordinates for structure and fluid.
Assemble the right hand side of Eq. 13-65 of NRM with the modal load vector from Adams:
··c ·c c ·· adams
ms 0  ξ s  + bs 0  ξ s  + ks a  ξ s =  m ·· adams b ξ + k s ξ sadams 
 ·· c   · c   c   ξ + s s  (66)
T
– a mf  ξ  0 bf  ξ  0 kf  ξ f   s s 
f f 0
By making use of Nastran Eq. 13-66 to Eq. 13-70, the fluid modal co-ordinates can be written in terms of
Adams structural modal co-ordinates.
c
{ ξ s } = [ C ] { ξ adams }
s
–1
[ C] + [I – ω2 + [Z1 ][a ][ Z2 ][ a]T ] (67)
The correction matrix [C] in above equation can be used to get judgment of fluid loading on structure. This
is useful matrix to check the validity of assumption made during Adams simulation.
Finally, the corrected fluid modal co-ordinates can be get as,
c T
{ ξ f } = – ω 2[ Z 2 ] [ a ] [ C ] { ξ sadams } (68)
By knowing right hand side vector for every frequency step from Adams, the above equation can be solved
c
for ξ . From here, acoustic pressure {p} can be recovered using following equation.
f
160 Adams Vibration
Adams Vibration References
{ p } = [ Φ f ] { ξ fc } (69)
Adams Vibration References

1. De Silva, C.W., Vibration: Fundamentals and Practice, CRC Press, Boca Raton, (2000).
2. D. J. Ewins., Modal Testing: Theory and Practice, John Willey and Sons Inc., New York, (1995).
3. Lyon, R.H., and Dejong, R.G. Theory and applications of Statistical Energy Analysis (second edition),
Butterworth-Heinemann, London, (1995).
4. Munjal, M. L., Fundamentals of vibration (Chapter 2), In Workshop on Noise, Vibration and
Harshness (NVH) for Automotive Engineering, SAE Western section, ARAI, Pune-India, (2002).
5. Negrut, D and Ortiz, J.L., On An Approach For The Linearization of The Differential Algebraic
Equations of MultiBody Dynamics, ASME/IEEE International Conference on Mechatronic and
Embedded Systems and Applications, (2005).
6. Press, W. H., Flannery, B. P., Teukolsky, S. A., and Vetterling, W. T. "QR Decomposition." §2.10
in Numerical Recipes in FORTRAN: The Art of Scientific Computing, 2nd ed. Cambridge, England:
Cambridge University Press, pp. 91-95, (1992).
7. Sohoni, V.N and Whitesell, J., Automatic Linearization of Constrained Dynamical Systems, ASME J,
of Mechanisms, Transmissions and Automation in Design, Vol.108, No. 3, pp. 300-304, (1986).
8. Meyer, C. D., Matrix Analysis and Applied Linear Algebra. SIAM, 2000.
Examples and Tutorials
The following Adams Vibration examples are available:
 Getting Started Using Adams Vibration
 Adams Vibration features
 Python Examples
You can also find many examples in your Adams Vibration installation directory (install_dir/examples). Each
folder contains all of the files required to run the example.
162 Adams Vibration
Dialog Box - F1 Help 163
Actuator Preview Plot
Dialog Box - F1 Help

Actuator Preview Plot
Vibration -> Build -> Input Channel -> Modify -> Plot Actuator
Plot your actuator without running a simulation.
For the option: Do the following:

Tips on Entering Object Names in Text Boxes
Input Channel Name Enter the name of the input channel you want to create or modify.
Logarithmic Spacing of Steps Select if you want the frequency steps spaced logarithmically. If not
selected, the steps are spaced linearly.
Begin Enter the beginning value for the frequency range.
End Enter the ending value for the frequency range.
Steps Enter the number of steps in the frequency range.
Actuator Value To Plot Select one of the following:
 Magnitude - Plots the magnitude of the actuator.

 Phase - Plots the phase of the actuator.
 PSD - Plots the Power Spectral Density of the actuator.
Horizontal Axis Scale Select one of the following:
 Linear
 Logarithmic
Close Action Select one of the following:
 Delete Plot - When you close this dialog box, Adams Vibration
deletes the plot.
 Save Plot - When you close this dialog box, Adams Vibration
saves the plot in the database and creates a page for it in Adams
PostProcessor.
If you set Close Action to Save Plot, Adams Vibration displays the following option:
Name Enter the name for the plot object that will be stored in the database.
164 Adams Vibration
Create Design Variable from File
Create Design Variable from File

Vibration -> Test -> Vibration Analysis -> User-Specified Frequencies -> Create Design Variable from File
Creates a design variable from the values in a specified file.

Tips on Entering File Names in Text Boxes
Filename Enter the name of an ASCII file that contains the design variable values. The
design variable is used to define the frequencies at which the vibration analysis is
performed.
To accommodate a wide variety of formats used by third-party software, the

format of the file to be read is intentionally general. Adams Vibration only reads
the lines that begin with a number. All other lines are considered comments and
are ignored. Using this command, output files generated from finite element,
modal analysis, or custom programs can be read into Adams Vibration.
Design Variable Name Enter the name of the design variable you want to create.
Create Vibration Design Constraint Macro

Vibration -> Improve -> Vibration Design Constraint -> New/Modify or
Simulate -> Design Constraint -> New/Modify -> View Variable and Vibration Macro

Macro Name Specify the name of the macro you are creating.
Return Value Variable Specify the name of the variable you want to use in your design study.
Target Vibration Data Select one of the following options:
 Freq. Resp. Magnitude Limit: 1 Input, 1 Output - The frequency

response of the specified output channel to the specified input
channel.
 Freq. Resp. Magnitude Limit: All Inputs, 1 Output - The
frequency response of the specified output channel to the all input
channels.
 Modal Energy: Kinetic Energy - The modal energy kinetic energy
value for a specified object.
 Modal Energy: Strain Energy - The modal energy strain energy
value for a specified object.
Create Vibration Design Objective Macro

Depending on how you set Target Vibration Data, Adams Vibration may display the following options:
Limit Value Specify a value below which the Target Vibration Data (see option above)
must be for the constraint to be satisfied.
Input Channel Enter the input channel you want to use in your macro.
Output Channel Enter the output channel you want to use in your macro.
Frequency Range Select one of the following:
 All Frequencies - Use all frequencies from your frequency response

calculation.
 Specific Range - Enter a range of frequencies.
Mode Number Enter the mode number of interest.
Object Type Select an object type.
Object Name Enter the name of the object of interest.
Body Name Enter the name of the body of interest.
Component Select an object component.

Vibration -> Improve -> Vibration Design Object -> New/Modify or
Simulate -> Design Objective -> New/Modify -> View Variable and Vibration Macro
Creates a macro capable of retrieving vibration-specific data. You can then use it when performing a design
study.
166 Adams Vibration

Macro Name Specify the name of the macro you are creating.
Return Value Variable Specify the name of the variable you want to use in your design study.
Target Vibration Data Select one of the following options:
This option: Returns:
Frequency Response: 1 Input, A minimum or maximum value of the frequency
1 Output response curve.
Frequency Response: All A minimum or maximum value of the frequency
Inputs, 1 Output response curve.
Freq. Resp. Magnitude of A minimum or maximum value of the frequency
sums: 1 Input, Multiple response curve for each pairing of the input
Outputs channel with the multiple output channels.
The minimum or maximum values are summed,

and used as the return value for the design
objective macro.
See Example: Freq. Resp. Magnitude of sums: 1

Input, Multiple Outputs
Freq. Resp. Magnitude of Same as above, except all input channels are used
sums: All Inputs, Multiple together (you do not specify the input channels
Outputs themselves).
See Example: Freq. Resp. Magnitude of sums: All

Inputs, Multiple Outputs
Freq. Response Area: 1 Input, The sum of the areas beneath the frequency
Multiple Outputs response curves for each pairing of the input
channel with the output channels.
See Example: Freq. Response Area: 1 Input,

Multiple Outputs

Freq. Response Area: All Same as above, except all input channels are used
Inputs, Multiple Outputs together (you do not specify the input channels
themselves).
See Example: Freq. Response Area: All Inputs,

Multiple Outputs
Frequency Response Error: 1 The sum, maximum, or average error between
Input, 1 Output the test data you provide and a one input / one
output Frequency Response calculation.
Frequency Response Error: The sum, maximum, or average error between
All Inputs, 1 Output the test data you provide and an output frequency
response calculation.
PSD: 1 Output A minimum or maximum value of the frequency
response curve.
Modal Participation: 1 Input, A minimum or maximum value of the frequency
1 Output response curve.
Eigen Natural Frequency The amount of error between the test value you
Error provide and the natural frequency value for a
particular mode number in the eigen solution.
Eigen Real Part The eigen solution's real part for a specified
mode.
Eigen Imaginary Part The eigen solution's imaginary part for a
specified mode.
Eigen Damping Ratio The eigen solution's damping ratio for a specified
mode.
Modal Energy: Normalized The modal energy normalized coordinates value
Coordinates for a specified object.
Modal Energy: Kinetic The modal energy kinetic energy value for a
Energy specified object.
Modal Energy: Strain Energy The modal energy strain energy value for a
specified object.
Modal Energy: Dissipative The modal energy dissipative energy value for a
Energy specified object.
Depending on how you set Target Vibration Data, Adams Vibration may display the following options:
Input Channel Enter the input channel you want to use in your macro.
Output Channel Enter the output channel you want to use in your macro.
168 Adams Vibration

Value Type Specify one of the following:
 Minimum (Sum of Minimums) - Uses minimum (sum of minimum)

values.
 Maximum (Sum of Maximums) - Uses maximum (sum of maximum)
values.
Frequency Range Select one of the following:
 All Frequencies - Use all frequencies from your frequency response

calculation.
 Specific Range - Enter a range of frequencies.
Test Data Enter a result set component that represents your test data. This data may have
been created by the file testdata read or other actions that can create results set
components. The number of values you provide should be the same as the
number of frequencies used for the frequency response calculation.
Error Type Specify how you want the error value to be computed. The basic process is to take
the frequency response curve that is obtained using the Input Channel and
Output Channel values and then see how it differs from the curve obtained from
the Test Data.
Select one of the following:
 Sum - The absolute values of the differences between the curves at each
of their points are added together to yield the error value.
 Maximum - The maximum difference between the curves represents the
error value.
 Average - The absolute values of the differences between the curves at
each of their points are added together and then averaged to yield the
error value.
Mode Number Enter the mode number of interest.
Test Value Enter the target value. The absolute value of the difference between the test value
and the natural frequency for the specified mode will be the return value for the
macro.
Object Type Select an object type.
Object Name Enter the name of the object of interest.
Create Vibration Multi-Run Script

Component/State Depending on the Object Type you selected, Adams Vibration will display the
Component pull-down menu or the State text box:
 Component - Select an object component.

 State - Enter an integer for the state of interest.
Body Name Enter the name of the body of interest.
Component Select an object component.
Create Vibration Multi-Run Script

Vibration -> Test -> Vibration Analysis -> Create Multi-Run Script or
Vibration -> Test -> Create Multi-Run Script
Creates a simulation Script that you can use during multi-run simulations (such as Design study, Design of
experiments (DOE), and so on).

Sim Script Name Enter the name of the simulation script you want to create.
Vibration Analysis Name Enter the name of your new or existing analysis.
Operating Point Specify one of the following:
 Static - Performs an equilibrium analysis (after assembling the

system).
 Assembly - Assembles the system into its input configuration.
 Script - Executes a user-specified script. If the internal solver
is selected in the simulation settings, this script can only
contain Adams View commands. For the external solver, the
script can only contain Adams Solver commands. Learn more
with Solver Settings - Executable dialog box.
If you set Operating Point to Script, Adams Vibration displays the following option:
Simulation Script Name Specify the name of your simulation script.
Damping Check to include damping effects in the analysis. If not checked,
damping effects are not included in the analysis.
Linear States Options (Valid Only Select to specify linear state options. This is only available for users
with Adams Solver (C++)) running Adams Solver (C++).
 Plant State
 Reference Marker
170 Adams Vibration
Create/Modify FD 3D Damper

Frequency Range/User-Specified Select the type of frequency you want to use.
Frequencies
If you select Frequency Range, Adams Vibration displays the following options:
Begin Enter the beginning value for the frequency range.
End Enter the ending value for the frequency range.
Steps Enter the number of steps in the frequency range.
Logarithmic Space of Steps Select if you want the frequency steps spaced logarithmically. If not
selected, the steps are spaced linearly.
If you select User-Specified Frequencies, Adams Vibration displays the following options:
Frequencies Enter the frequency values for the analysis.
Create Design Variables from Select to open the Create Design Variable from File dialog box, where you
Values in File can enter the file name that contains the design variable you want to
use.
Create/Modify FD 3D Damper
Vibration -> Build -> FD 3D Damper -> New/Modify
Define the parameters for a 3D frequency-dependent damper.

Name Enter the name of the 3D FD damper you want to create or modify.
I Marker Enter the name of the I marker on which the 3D FD damper will act.
Reference Marker Enter the name of the J marker on which the 3D FD damper will react.
Desired Select the directions along which you want the 3D FD damper to apply forces and
Components torques.
Type Select one of the following:
 Pfeffer Linear - Contains two linear dampers and two linear springs.
 Simple FD - Contains one linear damper and two linear springs.
 Simple FD-Bushing - Contains one linear damper and two linear springs.
 General
Depending on the setting of Type, Adams Vibration displays one or more of the following options:
Create/Modify FD Damper

C 1/2/3 Enter the damping value(s) for the damper.
K 1/2/3 Enter the stiffness value(s) for the damper.
Preload Enter the value of the preload in the component.
Create/Modify FD Damper
Vibration -> Build -> FD Damper -> New/Modify
Define the parameters for a Frequency Domain (FD) Damper.

Name Enter the name of the FD damper you want to create or modify.
I Marker Enter the name of the I marker on which the FD damper will act.
J Marker Enter the name of the J marker on which the FD damper will react.
Type Select one of the following:
 Pfeffer Linear - Contains two linear dampers (Damping 2 and 3) and two
linear springs (Stiffness 1 and 3).
 Simple FD - Contains one linear damper (Damping 3) and two linear springs
(Stiffness 1 and 2).
 Simple FD-Bushing - Contains one linear damper (Damping 3) and two
linear springs (Stiffness 2 and 3).
 General - Contains three linear dampers (Damping 1, 2, and 3) and three
springs (Stiffness 1, 2, and 3).
Depending on the setting of Type, Adams Vibration displays one or more of the following options:
C 1/2/3 Enter the damping value(s) for the damper.
K 1/2/3 Enter the stiffness value(s) for the damper.
Preload Enter the value of the preload in the component.
Create/Modify Vibration Actuators

Define the parameters for a vibration actuator.
See how To access the Create/Modify Vibration Actuator dialog box.
172 Adams Vibration
Create/Modify Vibration Input Channel

Vibration Actuator Name Enter the name of the vibration actuator you want to create or modify.
Associated Input Channel Enter the input channel to which you want to assign this actuator.
Actuator Type Select one of the following:
 Swept Sine.
 Rotating Mass.
 PSD. See Power Spectral Density.
 User. See User-Defined Function.
Force Magnitude Enter the force magnitude.
Phase Angle (deg) Enter the phase angle (in degrees).
Create/Modify Vibration Input Channel

Vibration -> Build -> Input Channel -> New/Modify
Define the parameters for Input Channels. In these dialog boxes, you can also assign and modify vibration
actuators.

Tips on Entering Object Names in Text Boxes.
Input Channel Name Enter the name of the input channel whose actuator you want to plot.
Pull-down list to select the input Select one of the following:
channel type
 Force
 User-specified state variable
 Kinematic
If you select Force or Kinematic, Adams Vibration displays the following options:
Input Marker Enter the location of the input marker.
Translational/Rotational Select one of the following:
 Translational - Applies a force.

 Rotational - Applies a torque.
Create/Modify Vibration Output Channel

Global/Local Select one of the following coordinate systems:
 Global - Selects the global coordinate system.

 Local - Selects the Input Point marker as the coordinate
system.
Force Direction/Torque Axis Select an axis (x, y, or z), about which the force or torque will be
applied.
Displacement/Velocity/ Select a kinematic input. Applies to kinematic types only.
Acceleration
If you select User-Specified State Variable, Adams Vibration displays the following option:
State Variable Enter the state variable you want to use. The state variable input
channel allows you to apply input channels to LSE/GSE/TFSISO
elements in an Adams model. Therefore, frequency domain inputs
can be applied using vibration actuators to general dynamical systems
modeling elements represented by LSE/GSE/TFSISO elements.
New/Existing Actuator Select one of the following:
 Actuator Parameters - Creates a new vibration actuator.

 Existing Actuator - Enter the name of an existing vibration
actuator to associate with this input channel.
Note: If you are using a Kinematic input channel, you cannot
specify an existing actuator.
Actuator Type Select one of the following:
 Swept Sine. See Entering Swept Sine Function for available

options.
 Rotating Mass (not available for Kinematic). See Entering
Rotating Mass for the available options.
 PSD (Power Spectral Density). See Entering PSD Function for
the available options.
 User (User-Defined Function). See Entering a User-Defined
function for the available options.
Plot Actuator Select to open the Actuator Preview Plot dialog box where you can see the
plot of your actuator without running a simulation.
Only available when modifying an input channel.
Create/Modify Vibration Output Channel

Define the parameters for Output Channels.
174 Adams Vibration
Eigen Information
Vibration -> Build -> Output Channel -> New/Modify

Output Channel Name Enter the name of the output channel you want to create or modify.
Output Function Type Select one of the following:
 Predefined - Adams Vibration constructs the Adams Solver

function for you, based on the information you enter in this dialog
box.
 User - You construct and enter the output channel function in the
Output Channel Function text box. To use Adams Solver
functions, see the online help for Adams Solver.
If you set Output Function Type to Predefined, Adams Vibration displays the following options:
Output Marker Enter the location of the output marker.
Global Component Specify the type of coordinate system for your output channel.
Axis Specify the axis for your output channel.
If you set Output Function type to User, Adams Vibration displays the following option:
Output Channel Function Specify the function for your output channel. To create the function in the
Function Builder, select .
Eigen Information
Vibration -> Review -> Display Eigenvalue Table
Displays a table of eigen values for an analysis.

Eigen Displays the name of the eigensolution.
+/- Use these buttons to navigate between eigensolutions. Press the + button to
go to the next eigensolution; use the - button to go to the previous
eigensolution.
(Table area) Displays each mode number with its corresponding undamped natural
frequency, damping ratio, real value, and imaginary value.
Highlight Unstable Modes Select to display real values greater than the Unstable Mode Threshold (see
next option) in a different color.
ISO Ride Index

Unstable Mode Threshold Enter the value of the unstable mode above which you want to display in a
Value different color in the eigen table (you must also select Highlight Unstable
Modes above). For example, if you enter 5.0, all modes with Real values
greater than 5.0 will be displayed in a different color.
Base Font Size Select the font size for the text in the table.
File Format Select the type of file to which you want to save the eigen information.
Write Table to File Select if you want to save the eigen information to a file. You can then specify
the filename and location of the file.
ISO Ride Index

Ride -> Full-Vehicle Vibration Analysis -> ISO Ride Index
Define the parameters for ISO Ride Index.

Ride Index This is read only field. Adams Car Ride will display the calculated output
Overall/Point Vibration Total Value here.
Output Select the appropriate output you want to calculate: OVTV, Feet PVTV,
Seat PVTV and Back PVTV.
Analysis Select the appropriate vibration analysis for calculating its Ride Index.
Depending on your output option selection, the following four tabs will be disabled or enabled. The Overall tab
is enabled only for calculating OVTV output.
Define output channels,  Specify the output channel for X, Y and Z directions at
scaling factors and ISO driver/passenger Feet, Seat and Back locations.
weighting curves (for  Specify the directional and overall scaling factors for each of these
driver/passenger Feet, Seat location and direction.
and Back locations)
 Specify the ISO frequency weighting curves for each of these
locations and directions.
Importing Vibration Results

Vibration -> Review -> Import Vibration Results
Allows you to import a previously generated results file and attach it to a vibration analysis. This enables you
to plot vibration data generated from the eigen and state matrices in the results file. The imported results file
and the vibration analysis must be from the same model.
176 Adams Vibration
Modal Info Computation

Results File Enter the name of the Adams Vibration results file.
Vibration Analysis Enter the name of the vibration analysis to which you want your results
attached.
(Attach option) Select one of the following:
 Attach results to existing Vibration Analysis - Attaches the results to

the current vibration analysis.
 Attach results to a copy of the Vibration Analysis - Makes a copy of
the current vibration analysis, names it as specified below, and attaches
the results to it.
If you select Attach results to a copy of the Vibration Analysis, Adams Vibration displays the following option:
New Vibration Analysis Enter the name for the new vibration analysis to which you want the results
attached.
Modal Info Computation

Vibration -> Test -> Vibration Analysis -> Modal Energy Computation
Specifies options for computing modal energy during your vibration analysis.

Compute Modal Energy If you want to compute modal energy during your vibration analysis, select
this option.
Normalized Coordinates If you want normalized coordinates of the mode to be computed, select this
option.
Kinetic Energy If you want to compute kinetic energy distribution, select this option.
Strain Energy If you want to compute strain energy distribution, select this option.
Dissipative Energy If you want to compute dissipative energy, select this option.
Marker Modes If you want to compute marker modes, select this option and provide marker
names in the given textbox.
Mode Range Enter the range of modes you want to use in the calculation. If you leave these
text boxes blank, Adams Vibration will use all modes.
Modal Information

Frequency Range Specify the frequency range in which in which Adams Linear provides energy
table results. If you leave these text boxes blank, Adams Vibration will use all
frequency range.
Names If selected, this will list the energy contribution results by Adams View object
name instead of Adams Solver ID.
Table Precision Specify the number of decimal places to be used in the energy table output.
Modal Information
Vibration -> Review -> Display Modal Info Table
Displays Modal Coordinates, modal participation, or modal energy for an analysis.

(Modal Info Type) Select the type of modal information you want to display:
 Modal Coordinates - This table lists the relative and absolute values
of modal coordinates at a specified excitation frequency.
 Modal Participation - This table lists the modal participation of
modes in the output channels. Highlights modes with the largest
contributions.
 Modal Energy - This table lists the normalized coordinates and
distribution of kinetic, strain, and dissipative energies in modes.
Highlights modeling entities with the largest contributions. It also
lists Marker Mode Shapes.
Vibration Analysis Enter the name of the vibration analysis whose modal information you want
to display.
Frequency Enter the frequency at which you want to view the modal information.
Display Phase Values Select to display the phase values for each mode.
Base Font Size Select the font size for the text in the table.
File Format Select the type of file to which you want to save the modal information.
178 Adams Vibration

Write Table to File Select if you want to save the modal information to a file. You can then
specify the filename and location of the file.
If you select Modal Coordinates, Adams Vibration displays the following option:
Magnitude Representation Select one of the following:
 Relative - Displays the relative values in the table.

 Absolute - Displays the absolute values in the table.

Tools > Plugin Manager > Vibration > Nastran_modal_export
Exports modal coordinates of flex-body to Nastran in MDF file format.

Flexible Body Enter the name of flexible body for which you want to export modal coordinates.
Output File Enter the name of output file. Default extension is .MDF
Vibration Analysis Enter the name of Vibration Analysis for which you want to export modal
coordinates.
Output Freq: Start Enter the Start frequency to output the modal coordinates.
End Enter the End frequency to output the modal coordinates.
If Start and End frequencies are not entered, Adams Vibration defaults to begin and end frequencies specified in
Vibration Analysis.
Nodal Info
Tools > Plugin Manager > Vibrartion > Build > nodal Info > New > Nodal Info
To plot stress and strain frequency response functions of selected nodes on flexible body in Adams
PostProcessor.

Nodal Info Name Enter the name for Nodal Info object.
Flexible Body Enter the name of flexible body.
Node IDs Enter the node numbers (IDs) on above selected flexible body to which Stress/Strain
FRF information you want to plot in Adams PostProcessor.
Criterion Select the Type of Stress/Strain.
PSD Cross Correlation
PSD Cross Correlation

Vibration -> Build -> Input Channel -> Modify -> Cross Correlation
Define the parameters for PSD cross correlation.

Actuators Enter the name of the PSD actuator you want to use.
Input Channels Enter the name of the input channel that you want to correlate to the PSD actuator.
More Select if you want to insert new combinations of actuators and input channels.
Fewer Select if you want to delete the last row of actuator/input channel associations.
Perform Vibration Analysis

Vibration -> Test -> Vibration Analysis
Creates and runs a vibration analysis (see Vibration Analysis Calculation Methods to learn more).

Analysis Selection Specify whether you are creating a new analysis or running an existing one.
Analysis Name Enter the name of your new or existing analysis.
Operating Point Specify one of the following:
 Static - Performs an equilibrium analysis (after assembling the

system).
 Assembly - Assembles the system into its input configuration.
 Script - Executes a user-specified script. If the integrated solver is
selected in the simulation settings, this script may only contain view
commands. For the external solver, the script can only contain solver
commands. If selected, specify the name of your simulation script in
the Simulation Script Name text box.
Import Settings From Select to display the Database Navigator, where you can choose an existing
Existing Vibration Analysis vibration analysis whose settings you want to use in your current analysis.
Adams Vibration updates the Perform Vibration Analysis dialog box with the
appropriate input and output channels.
180 Adams Vibration

Analysis Type Select the type of analysis you want to perform.
 Forced Vibration Analysis. See Creating and Running a Forced Vibration

Analysis.
 Normal Mode Analysis. See Creating and Running a Normal Modes
Analysis.
Damping Check to include damping effects in the analysis. If not checked, damping
effects are not included in the analysis.
Linear States Options Select to specify linear state options. This is only available if you are running
(Valid Only with Adams Adams Solver (C++).
Solver (C++))
If you select Linear States Options, Adams Vibration displays the following two options:
Plant State Select the plant state you want to use in the linearization of the model. Learn
more about the PSTATE statement.
Reference Marker Specify the marker you want to use in generating plant states for
linearization.
Frequency Range/User- Select the type of frequency you want to use.
Specified Frequencies
 Frequency Range - Specify the begin and end values and the
number of steps in the frequency range. Also, select Logarithmic
Space of Steps if you want the frequency steps spaced
logarithmically (if not selected, the steps are spaced linearly).
 User-Specified Frequencies - Enter the frequency values for the
analysis. You can also select Create Design Variables from Values in
File to open the Create Design Variable from File dialog box, where you
can enter the filename that contains the design variable you want to
use.
Modal Energy Select to open the Modal Info Computation dialog box.
Computation
Create Multi-Run Script Select to specify multi-run script specifications. Displays the Create Vibration
Multi-Run Script dialog box.
If you set Analysis Type to Forced Vibration Analysis, Adams Vibration displays the following options:
Input Channels Enter the name of the input channels you want to use in this vibration
analysis.
Note: You cannot select input channels with actuators of PSD type and
input channels with actuators of non-PSD type in the same
analysis.

Output Channels Enter the name of the output channels you want to use in this vibration
analysis.
If you are modifying an existing forced vibration analysis with results, Adams Vibration displays the following
option:
Reuse Existing State Matrix If you select this option, you can specify the modes for the Forced Vibration
Analysis.
 All Modes - Include all modes in the forced vibration analysis.

 Selected Modes - Specify the modes to include. Learn how to
Include or exclude modes.
Note: Changes made in text boxes that are grayed out are not included in
the subsequent analysis.
182 Adams Vibration
Appendix
Bode Plot
Plot of magnitude and phase response of a system for a unit sinusoid applied at an input channel and
measured at an output channel.
Decibel
A unit of measurement for attenuation or amplification of a signal, given as 20*log (input/output).
Eigensolution
An analysis that uses a model, along with an existing transient analysis step or static analysis, to compute the
frequency domain behavior of the system. The results are a collection of eigenvalues describing the natural
modes, and eigenvectors describing the normal mode shapes of the system components.
Entering a User-Defined function

f(omega) Enter a function of the independent variable omega.
Entering File Names in Text Boxes

To enter file names in text boxes, you can do either of the following:
 Enter the file name directly in the text box.
 Clear the text box and then double-click to open a selection window.
 Right-click to either:
• Search a database
• Browse a database
190 Adams Vibration
Entering PSD Function
Entering PSD Function

Spline Name Enter the name of the spline for your actuator.
Interpolation Type Enter the type of interpolation to use with your PSD actuator. Select one of the
following:
 akima
 cspline
 cubic
 linear
Note: The detail definitions are in Design-Time Functions in Adams View.
If you're modifying an existing input channel, Adams Vibration displays the following option:
Cross Correlation Select if you want to specify cross correlation options. Opens the PSD Cross
Correlation dialog box.
Entering Rotating Mass

Force/Moment Select one of the following:
 Force
 Moment
Leading/Lagging Select one of the following:
 Leading
 Lagging
Mass Enter the unbalanced mass.
Radial Offset (in plane) Enter the radial distance of the unbalanced mass from the axis of rotation.
Offset Normal to Plane Enter the offset along the axis of rotation.
Appendix 191
Entering Swept Sine Function
Entering Swept Sine Function

Force Magnitude Enter the force magnitude.
Entering Object Names in Text Boxes

To enter object names in text boxes, you can do either of the following:
 Enter the object name directly in the text box.
 Clear the text box and then double-click to open the Database Navigator.
 Right-click to either:
• Pick an object shown on the screen.
• Browse a complete list of available objects.
• Choose from a product-generated list of guesses.
Example: Freq. Resp. Magnitude of sums: 1 Input,

Multiple Outputs
Input channel= IC1
Output channels = OC1, OC2, OC3
 Frequency response curves are computed for IC1/OC1, IC1/OC2, IC1/OC3
 Maximum is computed for each curve: IC1/OC1 ->max1, IC1/OC2->max2, IC1/OC3->max3
 Maximum values are summed: sum = max1+max2+max3
Example: Freq. Resp. Magnitude of sums: All Inputs,

Multiple Outputs
 Frequency response curves are computed for ALL Input Channels/OC1, ALL Input Channels/OC2,
ALL Input Channels/OC3
 Maximum is computed for each curve: ALL Input Channels/OC1 ->max1, ALL Input
Channels/OC2->max2, ALL Input Channels/OC3->max3
 Maximum values are summed: sum = max1+max2+max3
Example: Freq. Response Area: 1 Input, Multiple Outputs

Input channel = IC1
192 Adams Vibration
Example: Freq. Response Area: All Inputs, Multiple Outputs
 Frequency response curves are computed for IC1/OC1, IC1/OC2, IC1/OC3

 Area beneath each curve is computed (that is, the curve is integrated): IC1/OC1 ->area1, IC1/OC2-
>area2, IC1/OC3->area3
 Areas are summed: sum = area1+area2+area3
Example: Freq. Response Area: All Inputs, Multiple

Outputs
 Frequency response curves are computed for ALL Input Channels/OC1, ALL Input Channels/OC2,
ALL Input Channels/OC3
 Area beneath each curve is computed (that is, the curve is integrated): ALL Input Channels/OC1 -
>area1, ALL Input Channels/OC2->area2, ALL Input Channels/OC3->area3
 Areas are summed: sum = area1+area2+area3
Flexible Body Modes

Component modes produced by an FEA simulation, such as Nastran or ANSYS.
Forced Vibration Analysis

An analysis that uses a list of omegas, vibration actuators, and a generalized linear solution to produce two
tables: Modal Coordinates and Frequency Responses.
Frequency
The rate of oscillation of harmonic motion.
Frequency Domain (FD) Damper

All FD modeling elements are derived from the following representation:
Appendix 193
Include or exclude modes
 General: All K and C s are non-zero

 Pfeffer: C1=0; K2=0
 Simple FD: C1=0; C2=0; K3=0
 Simple FD-Bushing: C1=0; K1=0; C2=0
Include or exclude modes

To include a mode in the analysis:
1. Highlight the mode number you want to include.
Note: You can hold down the <Ctrl> key as you click to select multiple nodes.
2. Select Include Selected Modes.

The modes selected have a number in the Use column, indicating that they're included in the analysis.
To exclude a mode from the analysis:

1. Highlight the mode number you want to exclude.
Note: You can hold down the <Ctrl> key as you click to select multiple modes.
2. Select Exclude Selected Modes.

The modes excluded no longer have a number in the Use column, indicating that they're not included
in the analysis.
Input Channel
A driver in the model, providing stimulus for the vibrational analysis.
Linear System Modes

See Normal Modes.
Modal Participation Factor

Describes a particular mode's contribution to the overall vibrational behavior of a system at a given omega.
Natural Modes
See Normal Modes.
194 Adams Vibration
Normal Mode
Normal Mode
A frequency at which a given system resonates in a particular way.
Normal Mode Number

The index of the Normal Mode.
Normal Mode Shape

The displacements and rotations of a system component resulting from excitation at that normal mode's
frequency.
Normal Modes
The modes that Adams Vibration produces. Often called principle modes or linear system modes in structural
dynamics texts. Normal modes are the results of an eigensolution. This is to differentiate them from
component modes that can be computed by other means.
Number of Modes
If you do not specify the number of modes you want to compute, Adams Vibration automatically chooses a
suitable number of modes based on the model size.
Operating Point
A point at which Adams linearizes a model. Because, traditionally, Adams models involve nonlinear elements,
you need to specify an operating point. To have an appropriate operating point, your system must meet the
following two conditions:
 It must have more than one degree of freedom, so that it is capable of oscillation.
 The Jacobian matrix for the system must be time invariant.
Output Channel
Instrumentation on the model that records some quantity of interest.
Principle Modes
See Normal Modes.
Resonance
A condition where the vibration actuator drives the normal mode of the system.
Appendix 195
Rigid Body Mode
Rigid Body Mode

A mode where the frequency is zero.
Steady State Solution

See Forced Vibration Analysis.
To access the Create/Modify Vibration Actuator dialog

box
1. From the Vibration menu, point to Build, point to Input Channel, and then select New or Modify.
It does not matter which option you select.

2. Using the pull-down menu in the dialog box, select Use Existing Actuator.
3. Perform one of the following:
 To modify an existing actuator, right-click in the Vibration Actuator Name text box, point to the
actuator name, and then select Modify.
 To create a new actuator, right-click in the Vibration Actuator Name text box, point to
Vibration_Actuator, and then select Create.
4. Refer to Create/Modify Vibration Actuators for information on how to complete the Create/Modify
Vibration Actuator dialog box.
196 Adams Vibration
To access the Create/Modify Vibration Actuator dialog box

Adams_2020_Adams_Vibration_User_Guide

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Adams_2020_Adams_Vibration_User_Guide

Uploaded by

Copyright:

Available Formats

Adams 2020

Adams Vibration User's Guide

Introduction to Adams Vibration

Using Adams Vibration, you can:

Adams Vibration Process

How You Benefit from Using Adams Vibration

Loading and Unloading Adams Vibration

To load Adams Vibration:

To unload Adams Vibration:

Starting Adams Vibration

To start Adams View and import your model:

2. Select Import a File.

To create or modify an FD damper:

To create an input channel:

To delete an input channel:

To modify an input channel:

• Enter the name of the vibration actuator you want to reference.

To create an output channel:

To delete an output channel:

To modify an output channel:

Power Spectral Density

 t ( ω ) is the moment due to unbalanced mass with offset

Macro for Removing Vibration Objects

Creating and Running a Forced Vibration Analysis

Creating and Running a Normal Modes Analysis

Modifying Existing Analyses

4. Make changes as necessary.

Vibration Analysis Calculation Methods

Power Spectral Density (PSD)

Creating a Multi-Run Script

To create a multi-run script:

Specifying Solver Settings

To specify the solver settings:

Batch Mode Analysis

Overview of Batch Mode Analysis

Example directory: Instructions file: Description of example:

math string traceback

Methods defined here:

Methods defined here:

Methods inherited from AvActuator:

Methods defined here:

Methods inherited from AvActuator:

Methods inherited from AvActuator:

Methods defined here:

Methods inherited from AvActuator:

Adams_OBJECT CreateMarker(partId, dir)

dir - char direction to align Z axis

Adams_OBJECT CreateSForce(iMarkId, jMarkId, action, type, func)

Adams_OBJECT CreatePOutput(const int*) const;

double DM(iMarkID, jMarkID)

jMarkID - Adams ID of the J marker

Adams_OBJECT CreateDiff(id, func, IC)

Adams_OBJECT CreateMatrix(nRow, nCol, order, data)

Adams_OBJECT CreateArray(which, data)

Adams_OBJECT CreateGSE(nIn, nOut, xArray, uArray, yArray, icArray,

yArray - int Adams ID of the Y array

Adams_OBJECT CreateGForce( const int iMarkId, const int jMarkId,

Adams_OBJECT ReadResultsFile(analysisName, fileName)

AvAPI_Matrix StateMatrix(smObject, which)

smObject - Adams_OBJECT key to the state matrix object

Get the objects Node ID of a marker

Get a list of dependants for the given object

Adams_OBJECT FixedJointMarker(Fixed, IorJ)

Adams_OBJECT GForceMarker(GF, IorJ)