Vibration 2017.1

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
2 Adams Vibration
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.
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
3
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, 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:
4 Adams Vibration
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 2017.1, and then
select Adams View.
The Welcome dialog box appears in the Adams View main window.
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
8 Adams Vibration
Building Your Model
system. A vibration actuator applies an input force to vibrate the system. A vibration actuator can contain
expressions 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.
9
Building Your Model
If you want to create a new vibration actuator, select Existing Actuator, and perform one of the
following:
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.
10 Adams Vibration
Building Your Model
3. Modify the output channel, as needed, as described in Create/Modify Vibration Output Channel.
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
displacement 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 offset from an 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
11
Building Your Model
r is the radial distance of the unbalanced mass from the axis of rotation
Similarly, a rotating mass placed at a distance offset 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 distance of the unbalanced mass perpendicular to the plane
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.
12 Adams Vibration
Building Your Model
f ( ) = F [ cos ( ) + j sin ( ) ]
where:
f is the forcing function
F is the magnitude of the force
is the phase angle

is the frequency
User-Defined Function
You can define any function of the independent variable omega:
f( ) = g( )
where:
is the frequency
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.
Testing Your Model
16 Adams Vibration
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.
4. Make changes as necessary.
5. Select OK to run your analysis.
Testing Your Model 17
Vibration Analysis Calculation Methods

Vibration analysis is a frequency domain simulation of Adams models. This simulation can be a normal
modes analysis in which the Eigenvalues and mode shapes for the model are computed. The frequency
domain simulation can also be a forced response analysis using the input and output channels along with
the vibration actuators.
Frequency Response
Modal Coordinates
Power Spectral Density (PSD)
Transfer Function
Frequency Response
Frequency response is the magnitude and phase response produced by a given input channel, at a given
omega, for a given output channel.
For frequency response computation, the linearized model is represented as:
sx(s) = Ax(s) + Bu(s)
y(s) = Cx(s) + Du(s)
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
For a given vibration analysis, the system frequency response is given as:
y ( s ) = H ( s )u ( s )
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 )
18 Adams Vibration

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) = Ax(s) + Bu(s)
y(s) = Cx(s) + Du(s)
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.
20 Adams Vibration
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:
adams2017.1 python my_model.py
On Linux, in a Linux shell:
adams2017.1 -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.
Batch Mode 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.
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.
22 Adams Vibration
Classes
Classes
Actuator
#############################################################################
#############################################################################
#############################################################################
#
# Copyright (C) 2004 by MSC Software, Inc., Santa Ana, CA, USA
# All Rights Reserved. This code may not be copied or reproduced in
# any form, in part or in whole, without the explicit permission of
# the copyright owner.
#
# Intent+: Python Qt interface for Adams Vibration
# Intent-:
#
# Caveats+:
# Caveats-:
#
#############################################################################
#
#############################################################################
#
#
# Intent-:
#
# Caveats+:
# Caveats-:
#
######################################################################
Modules
msc.Adams.Vibration.libAvAPIc os struct types
libsip re sys
math string traceback
Functions
Actuator(self, ActInfo)
Data
MEDissipativeEnergy = 0
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MENormalizedCoordinates = 0
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '11 Dec. 2003'
__file__ = './Actuator.pyc'
Classes
__name__ = 'Actuator'
Av2Nastran
#############################################################################
#############################################################################
#############################################################################
#
#
# Intent+: Python interface for Adams Vibration
# Intent-:
#
# Caveats+:
# Caveats-:
#
#############################################################################
Modules
fileinput libsip string traceback
msc.Adams.Vibration.libAvAMDc math struct types
msc.Adams.Vibration.libAvAPIc os sys
msc.Adams.Vibration.libAvASOLc re tempfile
Classes
Av2Nastran
AvBdfFile
AvBdfFileEigen
AvBdfFileFrf
AvRes2Nastran
AvStates
MKC
class Av2Nastran
Create a linear system model from an Adams non-linear system.
Methods defined here:

A(self)
Return the system A matrix
AcfToScript(self, iFile)
AddState(self, j, states, Ns)
24 Adams Vibration
Classes
B(self)
Return the system B matrix
BDFBushing(self, bdfFile, bush, gId, nId, comment)
BDFConectionList(self, bdfFile)
BDFJoint(self, bdfFile, joint, gId, nId, comment)
BDFSpringDamper(self, bdfFile, spdp, gId, nId, comment)
C(self)
Return the system C matrix
CheckAMat(self, rList)
CheckCMat(self, cList)
CleanDepList(self, p)
D(self)
Return the system D matrix
Eigen(self, fName, Continuation='+AV0001')
FRF(self, fName, st, ed, nStep, logSpace, Continuation='+AV0001')
Input(self, FDList)
InputChannels(self)
Return the system inputs
MakeOutputChannelList(self, FlexList)
Ok(self)
OutputChannels(self)
Return the system outputs
RemoveStates(self, rList)
Simulate(self, simScript, damping, fList, sName)
SubSystem(self)
Time(self)
__init__(self, amdModel, inputList, flexList, FDList, simScript, damping, solverLib,
mFunc=<function Adm2NasMessage>)
# def __init__(self, amdModel, inputList, outputList, FDList, simScript, damping, fList, dList, C
onList, sName):
Data and non-method functions defined here:

__doc__ = 'Create a linear system model from an Adams non-linear system.'
str(object) -> string
Return a nice string representation of the object.
Classes
If the argument is a string, the return value is the same object.

__module__ = 'Av2Nastran'
class AvBdfFile

AdvanceLine(self)
BulkMatrix(self, Name, mat, Symetric, Offset)
Close(self)
Continuation(self, continuation)
FilterLine(self, line)
FilterLineE(self, line)
__init__(self, fName, continuation)
write(self, line)

__doc__ = None
class AvBdfFileEigen(AvBdfFile)

Bulk(self, M, B, K, Offset=1)
Case(self, Name)
Exec(self, Name)
__init__(self, fName, continuation='+AV0001')

__doc__ = None
26 Adams Vibration
Classes

Methods inherited from AvBdfFile:

AdvanceLine(self)
Close(self)
write(self, line)
class AvBdfFileFrf(AvBdfFile)

Actuator2Table(self, act, fr)
Bulk(self, st, ed, nStep, logSpace, M, B, K, lB, C, D, actList, ND, NS, offsetS, offsetG, gLoc,
P2G)
Bulk2(self, st, ed, nStep, logSpace, M, B, K, lB, C, D, actList, ND, NS, offset)
BulkCMatrix(self, NameK, matK, NameC, matD, matC, ND, NS, offsetS, offsetG)
BulkCMatrix2(self, NameK, matK, NameC, matD, matC, ND, NS, offsetS, offsetG)
BulkVector(self, Name, vec, offset)
Case(self, Name, nOut, Offset=1)
Case2(self, Name, nOut, Offset)
Exec(self, Name)
MapRow(self, r, ND, NS)
__init__(self, fName, continuation='+AV0001')

__doc__ = None
Methods inherited from AvBdfFile:

AdvanceLine(self)
Classes

Close(self)
write(self, line)
class AvRes2Nastran

Eigen(self, fNameBase, Continuation='+AV0001')
FRF(self, fNameBase, st, ed, nStep, logSpace, Continuation='+AV0001', actList=[])
Ok(self)
__init__(self, amdModel, kRes, mFunc=<function Adm2NasMessage>)
# def __init__(self, amdModel, inputList, outputList, FDList, simScript, damping, fList, dList, C
onList, sName):

class AvStates
# LEVEL = ['INFO :', 'WARNING: ', 'ERROR :', 'FAULT :']
# if msg and len(msg):
# if level <4:
# print '%s %s'%(LEVEL[level], msg)
# else:
# print 'Level(%d): %s'%(level,msg)
#
###############################################################
#########################
28 Adams Vibration
Classes

Displacement(self, type, id, coord)
NumDisplacement(self)
NumStates(self)
State(self, type, id, coord)
__init__(self, S)
__doc__ = None
class MKC

Matrix(self, which)
NumDisplacement(self)
NumStates(self)
__init__(self, A, S)

__doc__ = None
Functions
Adm2NasMessage(level, msg)
HandleStep(Type, EventInput=0, EventOutput=0)
PrintEigen(Mat)
PrintPatern(lab, mat)
PrintSubSystem(A, B, C, D, S)
Data
Classes
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '1 Sept. 2004'
__file__ = './Av2Nastran.py'
__name__ = 'Av2Nastran'
AvActuator
This the entry point for the Actuators
Modules
libsip re sys
Classes
AvActuator
AvActuatorPSDFunction
AvActuatorRotatingMass
AvActuatorSweptSine
AvActuatorUserFunction
class AvActuator

CrossActuator(id)
DVAType(self)
EvalPSD(self, w)
Evaluate(self, w)
HasCrossActuator(id)
Name(self)
PSD(self)
__init__(self, Name)
30 Adams Vibration
Classes

__doc__ = None
__module__ = 'AvActuator'
class AvActuatorPSDFunction(AvActuator)

Actuator(self)
WritePy(self, oFile, space)
WriteXML(self, oFile, space)
PSD Function
__init__(self, Name, Type, Func, Args, CrossList)

__doc__ = None
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
Classes

Rotating Mass
__init__(self, Name, Type, Leading, Mass, Offset, Normal=None)

__doc__ = 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)

__doc__ = None
32 Adams Vibration
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)

__doc__ = None

CrossActuator(id)
DVAType(self)
EvalPSD(self, w)
Evaluate(self, w)
Name(self)
PSD(self)
Data
MEEndMode = -99
MEHeader = 0
Classes
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__file__ = './AvActuator.pyc'
__name__ = 'AvActuator'
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
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
34 Adams Vibration
Classes
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
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
Classes
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
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
36 Adams Vibration
Classes
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
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
Classes
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:
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
38 Adams Vibration
Classes
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
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
Classes
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
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,
40 Adams Vibration
Classes
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)
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
a: Constructors:
Classes
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
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:
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
42 Adams Vibration
Classes
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:
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
list crossList - list of cross correlation actuators
b. 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]
Classes
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
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:
doubler - real part
double i - imaginary part
44 Adams Vibration
Classes
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 - for values
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
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
Classes
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)

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 mat[row,0]
Returns:double- Value of the matrix location[row,0]
Parameters:int row- Location to get the value
double Value(row, col)
Value at location
Returns:double- Value of the matrix location[row,col]
Parameters:
46 Adams Vibration
Classes
int row- Location to get the value

int col - Location to get the value
double Value(slot, row, col)
Value at location
Returns:double- Value of the matrix location[slot,row,col]
Parameters:
int slot- Location to get the value
AvAPI_Complex ValueC(row, col)
Value at location
Returns:AvAPI_Complex- Value of the matrix location[row,col]
Parameters:
AvAPI_Complex ValueC(slot, row, col)
Value at location
Returns:AvAPI_Complex- Value of the matrix location[slot,row,col]
Parameters:
int slot - Location to get the value
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
Classes
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
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
48 Adams Vibration
Classes
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_MatrixOmega vector of frequencies
AvAPI_MatrixFrequencyResponse (Omega)
Frequency Response
Returns:AvAPI_Matrix- system frequency response3D complex matrix of the
AvAPI_MatrixMCT (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
Classes
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_MatrixPSD values
Parameters:
doublefrequency - frequency for evaluation
double Time()
Get the time of linearization
Returns:double Time given
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
50 Adams Vibration
Classes
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
Parameters: None
AvAPI_Matrix TransferFunction(Omega)
Transfer Function
Returns:AvAPI_Matrix - system transfer function3D complex matrix of the
AvAPI_Matrix FrequencyResponse (Omega)
Frequency Response
Returns:AvAPI_Matrix - system frequency response3D complex matrix of the
AvAPI_Matrix MCT (Omega, scaleMCT)
modal coordinate table
Returns:AvAPI_Matrix - modal coordinate table
Parameters:
bool scaleMCT - ifTrue MCT matrix is scaled by the input actuators
Classes
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_Matrix Omega vector of frequencies
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
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
52 Adams Vibration
Classes
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
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)
Classes
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()
Constructor
Returns: object
Parameters: None
54 Adams Vibration
Classes
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)

__doc__ = None
__module__ = 'AvBuild'
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)

__doc__ = 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)

__doc__ = None
56 Adams Vibration
Classes

class AvBuildFDInstance

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

__doc__ = None
class AvBuildInputChannel

List(self)
Marker(self, Name, Marker_Adams_ID, FunctionType, Global, Direction, Actuator)
Name(self)
Names(self)
StateVariable(self, Name, StateVarID, Actuator)

__doc__ = None
Classes
class AvBuildOutputChannel

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

__doc__ = None
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)

__doc__ = None
58 Adams Vibration
Classes
class AvBuildTest

List(self)(self)
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)

__doc__ = None
Functions
bitBlt(...)
qAlpha(...)
qAppName(...)
qBlue(...)
qDrawPlainRect(...)
qDrawShadeLine(...)
qDrawShadePanel(...)
qDrawShadeRect(...)
qDrawWinButton(...)
qDrawWinPanel(...)
qGray(...)
qGreen(...)
qRed(...)
qRgb(...)
qRgba(...)
qVersion(...)
qt_xdisplay(...)
qt_xrootwin(...)
Classes
qt_xscreen(...)
Data
IO_AbortError = 6
IO_Append = 4
IO_Async = 128
IO_Combined = 768
IO_ConnectError = 5
IO_Direct = 256
IO_FatalError = 3
IO_ModeMask = 255
IO_Ok = 0
IO_Open = 4096
IO_OpenError = 5
IO_Raw = 64
IO_ReadError = 1
IO_ReadOnly = 1
IO_ReadWrite = 3
IO_ResourceError = 4
IO_Sequential = 512
IO_StateMask = 61440
IO_TimeOutError = 7
IO_Translate = 16
IO_Truncate = 8
IO_TypeMask = 3840
IO_UnspecifiedError = 8
IO_WriteError = 2
IO_WriteOnly = 2
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
PYQT_BUILD = 34
PYQT_VERSION = '3.3'
QCOORD_MAX = 2147483647
QCOORD_MIN = -2147483648
QT_VERSION = 304
QT_VERSION_STR = '3.0.4'
__file__ = './AvBuild.pyc'
__name__ = 'AvBuild'
qApp = <qt.QApplication instance>
60 Adams Vibration
Classes
AvFDElement
This the entry point for the FD Element
Modules
libsip re sys
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)

__doc__ = None
__module__ = 'AvFDElement'
Classes
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__file__ = './AvFDElement.pyc'
__name__ = 'AvFDElement'
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)
Add3D(self, amdModel)
FDElement(self)
IMarker(self)
JMarker(self)
Name(self)
Preload(self)
FD Emement
__init__(self, Name, Type, Imark, Jmark, FdElement, preload)
62 Adams Vibration
Classes

__doc__ = None
__module__ = 'AvFDInstance'
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__file__ = './AvFDInstance.pyc'
__name__ = 'AvFDInstance'
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)
Classes
OutDir(self)
ResList(self, AnaObj=None)
__init__(self, Name, Model_base_name, Freq_range, iDir, oDir)
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)

__doc__ = 'Adams Vibration class for computing mechanical transfer functions'
__module__ = 'AvFreqRespSol'
class Sol

ActName(self)
CleanUp(self)
CreateIOChannels(self)
ErrStr(self)
Initialize(self, Model, InpMarkerList, OutMarkerList)
InpChLst(self)
Model(self)
64 Adams Vibration
Classes
OutChLst(self)
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
__init__(self)

__doc__ = None
__module__ = 'AvFreqRespSol'
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '11 Dec. 2003'
__file__ = './AvFreqRespSol.pyc'
__name__ = 'AvFreqRespSol'
AvHelp
#############################################################################
#############################################################################
#############################################################################
#
#
# Intent-:
#
# Caveats+:
# Caveats-:
#
Classes
#############################################################################
Modules
os string sys
Classes
AvHelp
class AvHelp

__init__(self, File=None)
browser(self, File)

__doc__ = None
__module__ = 'AvHelp'
Data
__author__ =
__date__ = '1 Sept. 2002'
__file__ = './AvHelp.pyc'
__name__ = 'AvHelp'
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
66 Adams Vibration
Classes
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
@type Actuator: object
@return: the object
@rtype: Object

__doc__ = 'Adams Vibration Input Channel Base Class'
__module__ = 'AvInputChannel'
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)
Classes

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>
@type FunctionType: string
@param Global: <Global, Local>
@type Global: string
@param Direction: <X, Y, Z>
@type Direction: string
@return: the object
@rtype: Object

__doc__ = '/n Marker Input Channel/n '
68 Adams Vibration
Classes

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

__doc__ = '/n State Variable Input Channel/n '
Classes

Methods inherited from AvInputChannel:
Actuator(self)
Name(self)
Functions
EvalFunc(argList, w)
User function used to test this module
Data
__author__ =
__date__ = '1 Sept. 2002'
__file__ = './AvInputChannel.pyc'
__name__ = 'AvInputChannel'
AvIOC
#############################################################################
#############################################################################
#############################################################################
#
#
# Intent-:
#
# Caveats+:
# Caveats-:
#
#############################################################################
#
Modules
libsip re sys

70 Adams Vibration
Classes
Functions
InputChannel(ChName, MrkInfo, ActObj)
OutputChannel(ChName, MrkInfo)
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '11 Dec. 2003'
__file__ = './AvIOC.pyc'
__name__ = 'AvIOC'
AvLinearize
#############################################################################
#############################################################################
#############################################################################
#
#
# Intent-:
#
# Caveats+:
# Caveats-:
#
#############################################################################
Modules
libsip re sys
Classes
AvLinearize
class AvLinearize

A(self)
Classes
Return the system A matrix

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
72 Adams Vibration
Classes

__module__ = 'AvLinearize'
Functions
AvLinearModel(modelFile, inputList, outputList, simScript, damping, outName, mList)
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
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
Classes
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '1 Sept. 2002'
__file__ = './AvLinearize.pyc'
__name__ = 'AvLinearize'
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)
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
74 Adams Vibration
Classes
@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

__doc__ = 'Adams Vibration class for specifying marker info'
__module__ = 'AvMarkerSpec'
Data
__author__ =
__date__ = '11 Dec. 2003'
__file__ = './AvMarkerSpec.pyc'
__name__ = 'AvMarkerSpec'
AvMechTFs
Modules
libsip re sys types
Functions
CreateModel(BaseName, FreqRange, iDir, oDir)
Classes
DoVibrAnalysis(Ac, modl)
GetActionList(Ac)
RegisterAnalysis(AnaObj)
message_handler(msg, type, data)
Message handler for vibration
Data
AcList = []
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__file__ = './AvMechTFs.pyc'
__name__ = 'AvMechTFs'
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
76 Adams Vibration
Classes
class Accelerance(msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)
# Accelerance

__init__(self, Model, InpMarkerList, OutMarkerList)

__doc__ = None
__module__ = 'AvMTF'
Methods inherited from

href="avfreqrespsol.html#Sol">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)
class Compliance
(href="avfreqrespsol.html#Sol">msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)
# Compliance

Classes

__doc__ = None

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
# Dynamic Inertia


__doc__ = None
78 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
# Dynamic Stiffness


__doc__ = None

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


__doc__ = None

ActName(self)
CleanUp(self)
ErrStr(self)
InpChLst(self)
Model(self)
OutChLst(self)
80 Adams Vibration
Classes
PlotLegend(self)
Resp(self)
Response(self)
Results(self)
VarName(self)
__del__(self)
class Impedence
# Impedence


__doc__ = None

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 Mobility
# Mobility


__doc__ = None

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 MotionTransmissibility
(href="avfreqrespsol.html#Sol"> Adams Vibration.InstrumentPacks.AvFreqRespSol.Sol)
# Motion Transmissiblity
82 Adams Vibration
Classes


__doc__ = None

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)
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '11 Dec. 2003'
__file__ = './AvMTF.pyc'
__name__ = 'AvMTF'
Classes
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
class Nibble(msc.Adams.Vibration.InstrumentPacks.AvFreqRespSol.Sol)

__init__(self, Model, InpMarkerList, OutMarkerList, UnBalMass)

__doc__ = None
__module__ = 'AvNibble'
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)
84 Adams Vibration
Classes
Results(self)
VarName(self)
__del__(self)
Data
AcList = []
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__file__ = './AvNibble.pyc'
__name__ = 'AvNibble'
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

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
Classes
@type Name: string

@param MarkerID: Adams Marker ID
@type MarkerID: integer

__doc__ = 'Adams Vibration Output Channel Base Class'
__module__ = 'AvOutputChannel'
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:

__doc__ = 'Adams Vibration Predefined Output Channel'
86 Adams Vibration
Classes
Methods inherited from AvOutputChannel:

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

JMarkerID(self)
MarkerID(self)
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

__doc__ = 'Adams Vibration Predefined Output Channel'
of the argument is a string, the return value is the same object.
Classes

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
@type Function: string

__doc__ = 'Adams Vibration User Output Channel'

Add(self, amdModel)
Name(self)
88 Adams Vibration
Classes
Data
__author__ =
__date__ = '1 Sept. 2002'
__file__ = './AvOutputChannel.pyc'
__name__ = 'AvOutputChannel'
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
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

__doc__ = 'Write .cmd file to create a vibration model in PPT'
__module__ = 'AvPPTCmdExporter'
90 Adams Vibration
Classes

Functions
psdFunc(argList, w)
User function used to test this module
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '29 Oct. 2002'
__file__ = './AvPPTCmdExporter.pyc'
__name__ = 'AvPPTCmdExporter'
AvResFileWrite
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)
Classes
WriteResToXRF(self, amdModel, Ana, ResVarName, ResLegend, AnaInpChLst,

AnaOutChLst, Res)
__init__(self, modl)

__doc__ = None
__module__ = 'AvResFileWrite'
Functions
CallerName(TstName)
SetName(Name)
message_handler(msg, type, data)
Message handler for vibration
Data
AcList = []
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__file__ = './AvResFileWrite.pyc'
__name__ = 'AvResFileWrite'
AvReview
Modules
libqtc re tempfile
92 Adams Vibration
Classes
Classes
AvReview
class AvReview

Name(self)
Run(self)
__init__(self, test, Name=None)

__doc__ = None
__module__ = 'AvReview'
Functions
bitBlt(...)
qAlpha(...)
qAppName(...)
qBlue(...)
qDrawPlainRect(...)
qDrawShadeLine(...)
qDrawShadeRect(...)
qDrawWinButton(...)
qDrawWinPanel(...)
qGray(...)
qGreen(...)
qRed(...)
qRgb(...)
qRgba(...)
qVersion(...)
qt_xdisplay(...)
qt_xrootwin(...)
Classes
qt_xscreen(...)
Data
IO_AbortError = 6
IO_Append = 4
IO_Async = 128
IO_Combined = 768
IO_ConnectError = 5
IO_Direct = 256
IO_FatalError = 3
IO_ModeMask = 255
IO_Ok = 0
IO_Open = 4096
IO_OpenError = 5
IO_Raw = 64
IO_ReadError = 1
IO_ReadOnly = 1
IO_ReadWrite = 3
IO_Sequential = 512
IO_TimeOutError = 7
IO_Translate = 16
IO_Truncate = 8
IO_TypeMask = 3840
IO_WriteError = 2
IO_WriteOnly = 2
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
PYQT_BUILD = 34
QCOORD_MAX = 2147483647
QCOORD_MIN = -2147483648
QT_VERSION = 304
__file__ = './AvReview.pyc'
__name__ = 'AvReview'
AvSuspension
######################################################################################
# This file contains an example model for performing multiple compliance matrix
# calculations in Adams Vibration v.2005.
#
# This example assumes the user has existing .adm and .acf files for this model.
# After executing this analysis this file writes simulation data to a .xml file
#
94 Adams Vibration
Classes
# To run this file issue the following command in an Linux shell.

# adams05 -c python multicompliance.py [model.adm model.acf marker_id]
#
# or in a Windows command prompt in a DOS shell
# adams05 python multicompliance.py
#
#
#
######################################################################################
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)
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)
Classes
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)

__doc__ = 'Adams Vibration Suspension Class'
__module__ = 'AvSuspension'
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)
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__file__ = './AvSuspension.pyc'
__name__ = 'AvSuspension'
96 Adams Vibration
Classes
AvTest
Modules
libqtc re tempfile
Classes
AvTest
class AvTest

Build(self)
List(self)
Name(self)
PlotList(self)
Run(self)
__init__(self, build, Name=None)

__doc__ = None
__module__ = 'AvTest'
Functions
bitBlt(...)
qAlpha(...)
qAppName(...)
qBlue(...)
qDrawPlainRect(...)
qDrawShadeLine(...)
Classes
qDrawShadeRect(...)
qDrawWinButton(...)
qDrawWinPanel(...)
qGray(...)
qGreen(...)
qRed(...)
qRgb(...)
qRgba(...)
qVersion(...)
qt_xdisplay(...)
qt_xrootwin(...)
qt_xscreen(...)
Data
IO_AbortError = 6
IO_Append = 4
IO_Async = 128
IO_Combined = 768
IO_ConnectError = 5
IO_Direct = 256
IO_FatalError = 3
IO_ModeMask = 255
IO_Ok = 0
IO_Open = 4096
IO_OpenError = 5
IO_Raw = 64
IO_ReadError = 1
IO_ReadOnly = 1
IO_ReadWrite = 3
IO_Sequential = 512
IO_TimeOutError = 7
IO_Translate = 16
IO_Truncate = 8
IO_TypeMask = 3840
IO_WriteError = 2
IO_WriteOnly = 2
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
98 Adams Vibration
Classes
MEStrainEnergy = 0
PYQT_BUILD = 34
QCOORD_MAX = 2147483647
QCOORD_MIN = -2147483648
QT_VERSION = 304
__file__ = './AvTest.pyc'
__name__ = 'AvTest'
VibBodePlot : VibPlot2D Class

Constructors:
VibBodePlot(Title, FR, Frequency, Inputs, Outputs)
Constructor
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
Classes
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
Returns: None
Parameters:
QColor Color: default color to use
VibPlot2D : VibPlot Class

Data Members:
enum eAxis
{
LEFT,
RIGHT,
BOTTOM
};
enum eScale
{
LINEAR,
100 Adams Vibration
Classes
LOGARITHMIC,
DB
};
enum eSymbol
{
NONE,
CIRCLE,
SQUARE,
DIAMOND,
TRIANGLE,
UTRIANGLE,
LTRIANGLE,
RTRIANGLE,
CROSS,
XCROSS,
HLINE,
VLINE
};

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
Classes
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
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)

102 Adams Vibration
Classes
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:
VibPlot2D::eScale Scale: scale to use (LINEAR, LOGARITHMIC, dB)
void SetAxisPen(Axis, Pen)

Set the pen for the axis
Classes
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)
Delete a curve from the plot
Returns: None
104 Adams Vibration
Classes
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:
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
106 Adams Vibration
Classes
VibPlot3D : VibPlot Class

Data Members:
enum eDRAWMODE
{
FLOWLINES,
WIREFRAME,
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
Classes
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
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
108 Adams Vibration
Classes
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
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
Classes
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
Returns: None
Parameters:
unsigned int cid: spline or surface id
Constructors:
VibPlot3D()
Constructor
Returns: object
Parameters: None
110 Adams Vibration
Utility Functions
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)

__doc__ = None
__module__ = 'AvUtils'
If the argument is a string, the return value
is the same object.
Functions
AvDacFileToMatrix(filename, nPts)
AvDatFileToMatrix(filename, nPts)
AvFFTDataActuator(argList, w)
AvMakeFrequency(start, end, steps, spaceLog)
Utility Functions
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
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
112 Adams Vibration
Utility Functions
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]
@type title: string
@param space: Starting indentation for matrix [default: 2]
@type space: integer
@Note: Assumes the matrix is complex
writeXMLFooter(matFile)
Utility Functions
write vibration footer for xml

writeXMLHeader(matFile)
write vibration header for xml
Data
MEEndMode = -99
MEHeader = 0
MEKineticEnergy = 0
MEStartMode = -1
MEStrainEnergy = 0
__author__ =
__date__ = '1 Dec. 2002'
__file__ = './AvUtils.pyc'
__name__ = 'AvUtils'
114 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
youre 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
Reviewing Your Model 117
plotting frequency response functions, generating modal coordinates tables, and displaying other time
and frequency data (see table below).
Note: Doing a normal modes animation outside of Adams Vibration is called a frequency-domain
animation. So, if youre 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
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.
118 Adams Vibration
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 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.
120 Adams Vibration
Plotting Modal Participation

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

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
122 Adams Vibration
flexible body, export 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:

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

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

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

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

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

select 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

130 Adams Vibration

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 eigen-values and eigenvectors of your model at an operating point
you specify. This analysis is effective in understanding natural modes of vibration for the model and to
determine the basic dynamic characteristics of your model. Although the result of an eigenvalue analysis
is independent of specific excitation, they are useful in predicting the effects of applying dynamic loads
on 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 to be used as
a companion to the on-line product documentation. It is assumed that 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. This is followed by definition of
vibration modeling entities available in Adams Vibration. Solutions types available in Adams Vibration
are described in Section 4. The last section, Section 5, gives 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:
z = vector of states of the model.
G = system of first-order differential and algebraic equations.
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
Lagrange multipliers due to kinematic constraints (JOINT, JPRIM, MOTION, PTCV and CVCV) also
contribute to the vector of states.
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
y = Outputs from the linear model
u = Inputs to the linear model
[A,B,C,D] = State matrices for the linear model
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:
132 Adams Vibration
i
i t
x(t) = e
where:
= ith eigenvector
= 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 eigen-values and eigen-vectors.
Note that Adams Vibration always computes and as complex quantities. The complete eigen-solution
to equation (3) can be expressed in the form [Ewins, 1995],
0
= *
0
* (5)
Q= * *

where:
System mode shape matrix .
the ith diagonal element of diagonal system eigenvalue matrix is
i 2
+ i 1 ( ) = r + i i
i i i i i

i i 2 i 2
= ( r ) + ( i ) , the ith natural frequency.
i i i
= r
* indicates the complex conjugate
Differences between proportional and general viscous damping Adams Vibration implements
general viscous damping. In these cases, damping matrix is no longer guaranty to be proportional to mass
and/or stiffness matrices. Following ways are generally referred in modal space to identify a presence of
non-proportional damping in the Adams Vibration model:
The real-valued modal matrix of the un-damped model no-more diagonals the damping
matrix.
For fixed k, the phase is no-more constant for all i=l,...,n.
The real and imaginary parts of the kth eigenvector are now linearly independent.
The modal matrix cannot be normalized to become real-valued.
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]:
(6)
where:
s = Laplace variable
From equation (6), transfer function in the state-space form is given as:
(7)
Transformation to Modal Space

Using the model eigenvectors as a basis for the solution, equation (6) is transformed to modal space using
the modal transformation:
(8)
where:
= Matrix of eigenvectors
134 Adams Vibration
q ( s ) = Array of modal coordinates
The ith column of corresponds to eigenvector i of the model.
Substituting from equation (8) in equation (6) gives:
(9)
Simplifying equation (9) gives:
(10)
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:
(11)
When you ask for the transfer function of a model to be computed, 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
expression in the right-hand side of equation (11).
Transfer function can be computed in two forms, that is, using equation (7) or equation (11). Solution of
the transfer function in the form of equation (7) is called the direct solution, while solution in the form
equation (11) is called the modal solution.
Adams Vibration uses the following steps to compute the transfer function for the model:
1. From the given input/output channel specification,
2. Compute state matrices in the state space forms as in equation (2).
3. Compute eigen-solution for the model using equation (4).
4. Transform to modal space using equation (10).

5. Compute transfer function from equation (11).
Due to degeneracy in the eigen-solution, for some models, Z may not be invertible. In such cases, the
transfer function is computed using the direct solution of equation (7). 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.
136 Adams Vibration
Vibration Analyses
Vibration Analyses
Adams Vibration performs two types of vibration analyses:
Normal Mode Analysis to compute eigen-values 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. Eigen-values 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
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. Vector z includes all of the differential states defined in the 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 (12)
Vibration Analyses
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 = (13)
v
In this case, the linearization matrix A takes this form:
0 I
A = (14)
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 (13)
and (14) into Equation (12), and simplifying we obtain:
q = v
1 1
v = M K q M bv
These two equations combined reduce to the well-known form:
Mq + bq + Kq = 0 (15)
Equation (15) 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 (15), Adams
Vibration solves a complex eigenvalue problem using Equations (12) as the starting point. Representing
the solution as:
t
X = e
Equation (12) transforms into a standard eigenvalue problem:
A = (16)
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 (16).
For the simple case defined by Equations (13), (14) and (15), there is an important property related the
computed mode shapes. A typical mode shape of the simple system can be split into:
138 Adams Vibration
Vibration Analyses
q
= (17)
v
Putting Equation (17) and (14) into Equation (16) we obtain:
0 q I q
=
M K M b v v
1 1
After making simplifications, we obtain:
v = q (18)
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 (19)

v
0 0 I
A = A1 A2 A3 (20)
1 1 1
M K M A4 M b
Using Equation (20) into the homogenous Equation (12) 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:
Vibration Analyses
z A 2 A 1 z
0 0 z + I A3 0
+ = (21)
0 M q 0 b q A4 K q 0
or

z z z
M' + b' + K' = 0 (22)

q q q
Equation (22) 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 (20) 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 (23)

v
and using Equation (20) and (16), we obtain after some manipulations:
v = q (24)
2 0 0 I A3 A2 A1 z
+ + = 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 (25)
140 Adams Vibration
Vibration Analyses
Where nq is the size of the q vector 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:
N = 2n q + n z = 2n c + n r (26)
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 (20) to get:
0 0 I
A = A1 A2 A 3 (Adams Solver C++) (27)
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:
0 0 I
A = A1 A2 0 (Adams Solver FORTRAN) (28)
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 (13) and (19) 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) (29)
Vibration Analyses
In that case, Adams Vibration will linearize the system into this form:
r = A r (30)
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 ) (31)
Where w is defined as the undamped natural frequency and is defined as the damping ratio. Solving
Equation (31) for both the undamped natural frequency and the damping ratio, we get the following
results for real-only eigenvalues:
w = (32)
= 1
For complex eigenvalues Equation (31) results in:
2 2
w = + (33)
-
= ---
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.
Table 1 Eigenvalue Table Reported in Adams View
Mode Undamped Natural Damping

Number Frequency r 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
Eigen-values can be plotted as a complex scatter on a real-imaginary axis, as shown in Figure 1 Complex
Scatter Plot. The real part of eigen-values 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 eigen-values of positive real part is unstable. As shown in Figure 1
Complex Scatter Plot, eigen-values lying in the left half plane are stable and those in the right half plane
are unstable.
142 Adams Vibration
Vibration Analyses
Figure 1 Complex Scatter Plot
A model with all stable eigen-values, 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
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 (34)
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.
Vibration Analyses
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 (35)
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. 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 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 (35) to obtain:
sx ( s ) = Ax ( s ) + Bu ( s ) (36)
Y ( s ) = Cx ( s ) + Du ( s )
144 Adams Vibration
Vibration Analyses
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 ) (37)
Defining the transfer function H(s) as:
1
H ( s ) = C ( sI A ) B + D (38)
The forced response of all output channel is then:
Y ( s ) = H ( s )u ( s ) (39)
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 (38) are:
AN N
B N ni
C n0 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 (38). If matrix A can be diagonalized, the response for each s is obtained following
the diagonalization algorithm shown in section Transformation to Modal Space.
Transfer Function
The plots for the transfer function H(s) are computed from equation (38). 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
(39), and displaying the jth entry of the resulting matrix-vector multiplication. See Figure 3 below.
Vibration Analyses
Figure 3 Transfer Function plots.
Besides displaying each entry of the transfer function matrix H(s), Adams Postprocessor allows plotting
the frequency response Y(s) for each output channel. Equation (39) may be rewritten as follows:
Yk ( s ) = Hkj ( s )uj ( s ) (40)

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
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 (40) 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
146 Adams Vibration
Vibration Analyses
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 ) (41)
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 (41), the
response PSD(s) is computed using the standard equation:
PSD k ( s ) = Hkj ( s )Hkj ( s )uj ( s ) (non-PSD type actuators) (42)

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 ) = Hkj ( s )Hkj ( s )uj ( s ) (PSD type actuators, no cross correlation) (43)
j
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
(44)
i
Vibration Analyses
For this second case, the Power Spectral Density response PSD(s) is computed as:
PSD k ( s ) = Hkj ( s ) H km ( s )u jm ( s ) (PSD type actuators with cross correlation) (45)

j m
All summations in Equation (45) 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.
Modal Coordinates
Equation (36) 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 ) (46)
Matrix Z in Equation (46) is the modal matrix composed by the mode shapes obtained from the
eigensolution of the system. Notice Equation (46) is a representation of the solution x(t) in the time
domain. Transforming Equation (46) into the frequency domain, we obtain:
x ( s ) = Zq ( s ) (47)
Using Equation (47) into Equation (36) and simplifying we obtain an equivalent representation of the
frequency response of the system in terms of the "modal" states q(s):
sq ( s ) = A m q ( s ) + B m u ( s ) (48)
Y ( s ) = C m Zq ( s ) + Du ( s )
Matrices Am, Bm, and Cm are obtained from:
1
A m = Z AZ (49)
1
Bm = Z B
C m = CZ
Adams Vibration computes and displays the frequency response of each modal state qk(s). From Equation
(48) we obtain in matrix form:
1
q ( s ) = ( sI A m ) B m u ( s ) = M ( s )u ( s ) (50)
148 Adams Vibration
Vibration Analyses
Equation (50) 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 ) (51)
s = s b, s e
Equation (51) is the frequency response of the kth entry in the modal vector due to the jth input channel.
Adams Post processor displays Equation (51) 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.
Figure 4 State space frequency response
While Equation (51) 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
Vibration Analyses
given frequency so. Evaluating Equation (50) for s=so and for the jth input channel (all other input
channels are set to zero) we obtain:
(52)
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.
Note: Currently, in the Modal Coordinates plot, the user interface only plots a subset of vector
q(so). The user interface will be corrected following the specifications in enhancement
ADMS-37554.
See Figure 5 for an example plot of Equation (52).

150 Adams Vibration
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 (51)), 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 (48) we obtain:
(53)
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.
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
(54)
where:
152 Adams Vibration
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,
(55)
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 (56)
1 j *
K 4j = (4) I xx ij (4)
2 i
1
K 5j = ij (5)* I yy ij (5)
2
1
K 6j = ij (6)* I zz ij (6)
2
Vibration Analyses
K 7j = ij (4)* I xy ij (5)
K 8j = ij (4)* I xz ij (6)
K 9j = ij (5)* I yz ij (6)
Equation (55) now equivalently expressed as,
(57)
Total kinetic energy for mode i can then be computed as,
n
i = i j (58)
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:
(59)
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:
154 Adams Vibration
Vibration Analyses
(60)
where:
Ti j = Percentage kinetic energy contributed by PART j to mode i

Equation (60) 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.
Vibration Analyses
Table 1 Modal Energy Distribution
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:
(61)
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.
156 Adams Vibration
Vibration Analyses
Percentage distribution of strain energy for mode i is given as:
p
100 i
S pi = m

p =1
p
i ; p=1, ,m (62)
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 (61)
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.
(63)
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,
(64)
where:
is the strain vector

Vibration Analyses
is the stress vector

B is a function matrix of the FE geometry relating strains to displacements
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.
158 Adams Vibration
Modeling of Vibration Entities

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
r = Radial offset
= Frequency of excitation
160 Adams Vibration
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.
162 Adams Vibration
Figure 9 Scematic of One-dimentional FD Element

Performing Acoustic Pressure Recovery
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 MD 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.
164 Adams Vibration
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 from Adams to MD 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.
1. 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 (65)
{ } = [ 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]{ } (66)

f
2. 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 (67)
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 ] (68)
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 } (69)
By knowing right hand side vector for every frequency step from Adams, the above equation can be
solved for fc . From here, acoustic pressure {p} can be recovered using following equation.
{ p } = [ f ] { fc } (70)
166 Adams Vibration
Adams Vibration References
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
Dialog Box - F1 Help

164 Adams Vibration
Actuator Preview Plot
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:
Phase - Plots the phase of the actuator.

Magnitude - Plots the magnitude 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.
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.
166 Adams Vibration
Create Vibration Design Constraint Macro
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.
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.
Create Vibration Design Objective Macro

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.

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 A minimum or maximum value of the
Input, 1 Output frequency response curve.
Frequency Response: All A minimum or maximum value of the
Inputs, 1 Output frequency response curve.
Freq. Resp. Magnitude of A minimum or maximum value of the
sums: 1 Input, Multiple frequency response curve for each pairing of
Outputs the input 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
sums: All Inputs, Multiple used together (you do not specify the input
Outputs channels themselves).
See Example: Freq. Resp. Magnitude of sums:

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

Multiple Outputs
168 Adams Vibration

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

Multiple Outputs
Frequency Response Error: The sum, maximum, or average error between
1 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
1 Output frequency 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
Coordinates value for a specified object.
Modal Energy: Kinetic The modal energy kinetic energy value for a
Energy specified object.
Modal Energy: Strain The modal energy strain energy value for a
Energy specified object.
Modal Energy: Dissipative The modal energy dissipative energy value for
Energy a 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.

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.
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.
170 Adams Vibration

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 Select to specify linear state options. This is only available for users
Only with Adams Solver (C++)) running Adams Solver (C++).
Plant State
Reference Marker
Frequency Range/User- Select the type of frequency you want to use.
Specified 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.
172 Adams Vibration

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,
Values in File where you can enter the file name that contains the design variable
you want to use.
Create/Modify FD 3D Damper
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 Enter the name of the J marker on which the 3D FD damper will react.
Marker
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:
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.
174 Adams Vibration
Create/Modify FD Damper
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
Create/Modify Vibration Actuators

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

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).
176 Adams Vibration
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 Enter the name of the input channel whose actuator you want to
plot.
Logarithmic Spacing of Steps Select one of the following:
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.
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.

178 Adams Vibration
Create/Modify Vibration Output Channel
Create/Modify Vibration Output Channel

Define the parameters for Output Channels.
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
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.
Unstable Mode Threshold Enter the value of the unstable mode above which you want to display in
Value a 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.
180 Adams Vibration
ISO Ride Index
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
driver/passenger Feet, Seat these location and direction.
and Back locations)
Specify the ISO frequency weighting curves for each of these
locations and directions.

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.

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 existing 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.
182 Adams Vibration
Modal Info Computation
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.
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
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.
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.
184 Adams Vibration

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 Enter the name of Vibration Analysis for which you want to export modal
Analysis 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
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.
186 Adams Vibration
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 Vibration existing vibration analysis whose settings you want to use in your current
Analysis analysis. Adams Vibration updates the Perform Vibration Analysis dialog
box with the appropriate input and output channels.
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
(Valid Only with Adams running 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.
188 Adams Vibration

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 If you select this option, you can specify the modes for the Forced
Matrix 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.
Appendix
190 Adams Vibration
Bode Plot
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.
Appendix 191
Decibel
Decibel
A unit of measurement for attenuation or amplification of a signal, given as 20*log (input/output).
192 Adams Vibration
Eigensolution
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.
Appendix 193
Entering a User-Defined function
Entering a User-Defined function

f(omega) Enter a function of the independent variable omega.
194 Adams Vibration
Entering File Names in Text Boxes
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
Appendix 195
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.
196 Adams Vibration
Entering Rotating Mass
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.
Appendix 197
Entering Swept Sine Function
Entering Swept Sine Function

Force Magnitude Enter the force magnitude.
198 Adams Vibration
Entering Object Names in Text Boxes
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.
Appendix 199
Example: Freq. Resp. Magnitude of sums: 1 Input, Multiple Outputs
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
200 Adams Vibration
Example: Freq. Resp. Magnitude of sums: All Inputs, Multiple Outputs
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
Appendix 201
Example: Freq. Response Area: 1 Input, Multiple Outputs
Example: Freq. Response Area: 1 Input, Multiple

Outputs
Input channel = IC1
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
202 Adams Vibration
Example: Freq. Response Area: All Inputs, Multiple Outputs
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
Appendix 203
Flexible Body Modes
Flexible Body Modes

Component modes produced by an FEA simulation, such as Nastran or ANSYS.
204 Adams Vibration

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

All FD modeling elements are derived from the following representation:
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
Appendix 207
Include or exclude modes
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.
208 Adams Vibration
Input Channel
Input Channel
A driver in the model, providing stimulus for the vibrational analysis.
Appendix 209
Linear System Modes
Linear System Modes

See Normal Modes.
210 Adams Vibration
Modal Participation Factor
Modal Participation Factor

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

The index of the Normal Mode.
214 Adams Vibration
Normal Mode Shape
Normal Mode Shape

The displacements and rotations of a system component resulting from excitation at that normal mode's
frequency.
Appendix 215
Normal Modes
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.
216 Adams Vibration
Number of Modes
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.
Appendix 217
Operating Point
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.
218 Adams Vibration
Output Channel
Output Channel
Instrumentation on the model that records some quantity of interest.
Appendix 219
Principle Modes
Principle Modes
See Normal Modes.
220 Adams Vibration
Resonance
Resonance
A condition where the vibration actuator drives the normal mode of the system.
Appendix 221
Rigid Body Mode
Rigid Body Mode

A mode where the frequency is zero.
222 Adams Vibration
Steady State Solution
Steady State Solution

See Forced Vibration Analysis.
Appendix 223
To access the Create/Modify Vibration Actuator dialog box
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.
224 Adams Vibration
To access the Create/Modify Vibration Actuator dialog box
225
Numerics
3D plotting 131
A
Actuator
about 11
input/output channels 8
plot 2
Adams/PostProcessor
plotting output 129
using 129
Adams/Vibration
benefits 3
loading 4
process 3
starting 4
unloading 4
uses for 2
Adams/Vibration, importing results from 19
Animating
forced vibration analysis 129
normal modes analysis 129
output 129
AvActuator 41
AvAMD Class 45
AvAPI Class 52
AvAPI_Actuator Class 53
AvAPI_Complex Class 55
AvAPI_Matrix Class 56
AvAPI_System Class 59
AvAPI_SystemSS Class 61
AvAPI_ToolBox 64
AvFDElement Class 72
AvFDInstance Class 73
AvHelp Class 76
AvInputChannel Class 77
AvIOC 81
AvLinearize 82
AvMarkerSpec 85
AvMechTFs 86
226 Adams/Vibration
AvMTF 87
AvNibble 95
AvOutputChannel Class 96
B
Batch mode analysis
about 32
example 33
overview 32
C
Cross correlation dialog box 24
D
Damper
frequency-dependent (FD) 12
frequency-dependent (FD) 3D 11
Design objective macro
creating 139
dialog box 5
F
FD 3D damper dialog box 11
FD damper dialog box 12
Forced vibration analysis
animating 129
creating/running 28
Frequency response
about 29
plotting 131
frequency-dependent damper 12
frequency-dependent damper 3D 11
I
Importing your model 4
Input channels
about 8
creating procedure 9
dialog box 14
modifying procedure 9
vibration actuators 8
L
Loading Adams/Vibration 4
227
M
Macro
creating 5
creating design objective 139
Modal coordinates
about 29
plotting 132
Modal energy computation dialog box 20
Modal participation
plotting 133
N
Normal modes analysis
animating 129
creating/running 28
O
Output
animating 129
plotting 129
Output channels
about 10
dialog box 16
modifying procedure 10
P
Plotting
3D 131
about 129
actuator 2
frequency response 131
modal coordinates 132
modal participation 133
output 129
PSD 133
system modes 133
transfer function 134
Plugin manager 4
about 11
computation 30
228 Adams/Vibration
plotting 133
PSD
crcross correlation dialog box 24
Python API classes
AvActuator 41
AvAMD Class 45
AvAPI Class 52
AvAPI_Actuator Class 53
AvAPI_Complex Class 55
AvAPI_Matrix Class 56
AvAPI_System Class 59
AvAPI_SystemSS Class 61
AvAPI_ToolBox 64
AvFDElement Class 72
AvFDInstance Class 73
AvHelp Class 76
VibBodePlot VibPlot2D Class 110
VibPlot QWidget Class 110
VibPlot2D VibPlot Class 111
WriteMatrix 124
WriteMatrixXML 124
WriteXMLFooter 124
WriteXMLHeader(matFile) 125
R
Results, importing Adams/Vibration 19
Rotating mass 11
S
Starting Adams/Vibration 4
Starting Adams/View 4
Swept sine 12
System modes, plotting 133
T
Transfer function
about 30
plotting 134
U
Unloading Adams/Vibration 4
User-Defined Function 13
229
V
VibBodePlot VibPlot2D Class 110
VibPlot QWidget Class 110
Vibration actuators
dialog box 13
Vibration analysis
about 29
creating/running forced 28
dialog box
Create Design Variable from File Dialog Box 3
Create Vibration Multi-Run Script 9
Perform Vibration Analysis 25
modifying 28
normal modes 28
Viewing results 129
W
WriteMatrix class 124
WriteMatrixXML class 124
WriteXMLFooter class 124
WriteXMLHeader(matFile) 125
230 Adams/Vibration

Vibration 2017.1

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Vibration 2017.1

Transféré par

Droits d'auteur :

Formats disponibles

Welcome to Adams Vibration

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:

The Pfeffer model has a specific representation (see Reference 2 below).

To create or modify an FD damper:

To create an input channel:

To delete an input channel:

To modify an input channel:

To create an output channel:

To delete an output channel:

To modify an output channel:

Power Spectral Density

Learn about computing Power Spectral Density (PSD).

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

is the phase angle

Macro for Removing Vibration Objects

Analyses and Scripts

Creating and Running a Forced Vibration Analysis

Creating and Running a Normal Modes Analysis

Modifying Existing Analyses

Vibration Analysis Calculation Methods

The system transfer function can be represented as:

Power Spectral Density (PSD)

The system transfer function can be represented as:

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

Note: All example directories are located in install_dir/vibration/examples, where install_dir is

Example directory: Instructions file: Description of example:

msc.Adams.Vibration.libAvAMDc math struct types

Methods defined here:

Data and non-method functions defined here:

If the argument is a string, the return value is the same object.

Methods defined here:

Data and non-method functions defined here:

Methods defined here:

Data and non-method functions defined here:

Return a nice string representation of the object.

Methods inherited from AvBdfFile:

Methods defined here:

Data and non-method functions defined here:

Methods inherited from AvBdfFile:

BulkMatrix(self, Name, mat, Symetric, Offset)

Methods defined here:

Data and non-method functions defined here:

Methods defined here:

Methods defined here:

Data and non-method functions defined here:

math string traceback

Methods defined here:

Data and non-method functions defined here:

Methods defined here:

Data and non-method functions defined here:

Methods inherited from AvActuator: