C++ Commands Reference

1
C++Commands
C++ Commands
You use commands to control the simulation. Commands allow you to modify statements, invoke and
control the simulations, and display simulation output and status information.
Below are the Adams/Solver (C++) commands grouped according to their function. Detailed information
on each command can be found by following the links.
a
Type of command: Command name:
Inertia and material data PART
bordered MARKER
FLEX_BODY
Constraints J OINT
MOTION
GCON
Forces ACCGRAV
BEAM
BUSHING
FIELD
FRICTION
GFORCE
SFORCE
SPRINGDAMPER
VFORCE
VTORQUE
Reference data ARRAY
SPLINE
STRING
VARIABLE
Analysis parameters DEBUG
EQUILIBRIUM
IC
INTEGRATOR
KINEMATICS
LSOLVER
SENSOR
Output OUTPUT
REQUEST
Adams/Solver
C++Commands
2
Simulation ACTIVATE
CONTROL
DEACTIVATE
ENVIRONMENT
FILE
LINEAR
PREFERENCES
RELOAD
SAVE
SIMULATE
STOP
Information HELP
INFO
MENU
SHOW
TIME
Type of command: Command name:
3 ACCGRAV
C++Commands
ACCGRAV
The ACCGRAV command redefines and/or lists the data for a ACCGRAV statement.
Format

Arguments
Examples
ACCGRAV/ LI ST
This ACCGRAV command lists all the data for the ACCGRAV statement in the dataset.
See other Forces available.
IGRAV=r Respecifies the x component of gravitational acceleration with respect to the ground
coordinate system (GCS).
JGRAV=r Respecifies the y component of gravitational acceleration with respect to the ground
KGRAV=r Respecifies the z component of gravitational acceleration with respect to the ground
LIST Lists the current values of the data in the ACCGRAV statement.
Adams/Solver
C++Commands
4
ACTIVATE
The ACTIVATE command activates a statement that was previously turned off by the DEACTIVATE
command.
Format

Arguments
BEAM Specifies that Adams/Solver (C++) is to activate BEAM statements.
CONTACT Specifies that Adams/Solver (C++) is to activate CONTACT statements.
CLEARANCE Specifies that Adams/Solver (C++) is to activate CLEARANCE statements.
COUPLER Specifies that Adams/Solver (C++) is to activate COUPLER statements.
BUSHING Specifies that Adams/Solver (C++) is to activate BUSHING statements.
FIELD Specifies that Adams/Solver (C++) is to activate FIELD statements.
GCON Specifies that Adams/Solver (C++) is to activate the GCON statements.
GFORCE Specifies that Adams/Solver (C++) is to activate GFORCE statements.
ID=id1[,...,id30] Lists up to 30 statement identifiers for statements that Adams/Solver (C++)
activates. You may use the ID argument in conjunction with the RANGE
argument.
JOINT Specifies that Adams/Solver is to activate JOINT statements.
5 ACTIVATE
C++Commands
Extended Defintion
The ACTIVATE command, used in conjunction with the DEACTIVATE command, switches
Adams/Solver (C++) elements on and off. All Adams/Solver (C++) elements are active by default in the
input dataset, but can be deactivated using the DEACTIVATE command. For simulation purposes, when
Adams/Solver (C++) activates a statement, the statement appears as though it was always in the dataset.
When Adams/Solver (C++) deactivates a statement, the statement effectively disappears from the model.
Both the ACTIVATE and DEACTIVATE commands take effect when you issue the next SIMULATE
command.
After the activation of any element, Adams/Solver (C++) reprocesses the model at the next SIMULATE
command, as if it had just been read in from the dataset. During the reprocessing, Adams/Solver (C++)
checks the entire model for consistency, reinitializes user subroutines, and recomputes initial conditions.
While checking the entire model, Adams/Solver (C++) verifies that the model is still valid when the
newly activated elements are included. For example, if an activated JOINT overconstrains a model
resulting in an immobile system, Adams/Solver (C++) issues an error message. Adams/Solver (C++) also
reinitializes all user subroutines to re-establish functional dependencies. For each element that refers to
a user-written subroutine, Adams/Solver (C++) calls the user-written subroutine with IFLAG set to true.
Prior to the actual simulation, Adams/Solver (C++) computes initial conditions for the model. If this is
the first simulation, Adams/Solver (C++) begins with the positions and velocities specified in the dataset,
and maintains any user-supplied joint initial-conditions and part positions specified as EXACT. If you
ran a previous simulation, Adams/Solver (C++) begins with the final displacements and velocities.
JPRIM Specifies that Adams/Solver (C++) is to activate JPRIM statements.
LIST Indicates that Adams/Solver (C++) is to display a list of all the existing elements
of the specified type, along with their current activity status.
MOTION Specifies that Adams/Solver (C++) is to activate MOTION statements.
RANGE=id1,id2 Defines a range of statement identifiers for statements that Adams/Solver (C++)
is to activate. Adams/Solver (C++) activates all statements with identifiers that
are numerically between the given identifiers, inclusively. The range may
contain unused identifiers. You may use the RANGE argument in conjunction
with the ID argument.
Range: id1 < id2
SENSOR Specifies that Adams/Solver (C++) is to activate SENSOR statements.
SFORCE Specifies that Adams/Solver (C++) is to activate SFORCE statements.
SPRINGDAMPER Specifies that Adams/Solver (C++) is to activate SPRINGDAMPER statements.
VFORCE Specifies that Adams/Solver (C++) is to activate VFORCE statements.
VTORQUE Specifies that Adams/Solver (C++) is to activate VTORQUE statements.
Adams/Solver
C++Commands
6
Adams/Solver (C++) then adjusts the initial conditions to ensure that they are consistent with the model
constraints.
Examples
ACTI VATE/ SFORCE, I D=201, 202
This ACTIVATE command activates SFORCEs 201 and 202.
ACTI VATE/ J PRI M, RANGE=400, 499
This ACTIVATE command activates JPRIMs 400 and 499, and all JPRIMs with identifiers between 400
and 499.
See other Simulation available.
Tip: Use the ACTIVATE and DEACTIVATE commands after a FILE or RELOAD command to
set up the model for a particular loadcase or configuration.
7 ARRAY
C++Commands
ARRAY
The ARRAY command redefines and/or lists the array of up to 1,200 real numbers for an IC-type ARRAY
statement.
Format
ARRAY/id [,NUMBERS=r1 [,r2,...]] [,LIST]
Arguments
Example
ARRAY/ 12, NUMBERS=0. 5, 0. 12, LI ST
See other Reference data available.
[ ] Optionally select the item
LIST Lists the number(s) in storage.
[,NUMBERS=r1 [,r2,...]] Respecifies at least one real number to be stored.
Caution: You can use the ARRAY command on only an IC-type ARRAY statement (the default
type). Adams/Solver (C++) issues an error message if you specify an X-, U-, or Y-type
ARRAY statement.
Adams/Solver
C++Commands
8
BEAM
The BEAM command redefines and/or lists the data for a BEAM statement. Although you cannot redefine
the I and the J markers, you can redefine any of the other BEAM arguments.
Format
Click the argument for a description.

Arguments
AREA=r Respecifies the uniform area of the beam cross-section. The centroidal axis
must be orthogonal to this cross-section.
ASY=r Respecifies the correction factor for shear deflection in the y direction for
Timoshenko beams.
ASZ=r Respecifies the correction factor for shear deflection in the z direction for
Timoshenko beams.
CMATRIX=r1,...,r21 Respecifies the six-by-six damping matrix for the beam. Because this matrix
is symmetric, you need to specify only one-half of it, that is, twenty-one
entries. The units for the translational and rotational components of
CMATRIX should be force-time per displacement unit and torque-time per
radian, respectively.
CRATIO=r Respecifies the ratio for calculating the structural damping matrix for the
beam. Adams/Solver (C++) multiplies the stiffness matrix by the value of
CRATIO to obtain the damping matrix.
EMODULUS=r Respecifies Youngs modulus of elasticity for the beam material.
GMODULUS=r Respecifies the shear modulus of elasticity for the beam material.
9 BEAM
C++Commands
IXX=r Denotes the torsional constant. This is sometimes referred to as the torsional
shape factor or torsional stiffness coefficient. It is expressed as unit length to
the fourth power. For a solid circular section, Ixx is identical to the polar
moment of inertia where r is the radius of the cross-section. For thin-
walled sections, open sections, and noncircular sections, you should consult a
handbook.
IYY=r,IZZ=r Denotes the area moments of inertia about the neutral axes of the beam cross
sectional area (y-y and z-z). These are sometimes referred to as the second
moment of area about a given axis. They are expressed as unit length to the
fourth power. For a solid circular section, Iyy=Izz= where r is the radius
of the cross-section. For a thin-walled sections, open sections, and noncircular
sections, the user should consult a handbook.
LENGTH Respecifies the undeformed length of the beam along the x-axis of the J
marker.
LIST Lists the current values of the data in the BEAM statement.
Adams/Solver
C++Commands
10
BUSHING
The BUSHING command redefines and/or lists the data for a BUSHING statement. Although you cannot
define the I and J markers defining the bushing, you can redefine other characteristics of the bushing.
Format

Arguments
C=r1,r2,r3 Respecifies three viscous damping coefficients for the force transferred by the
bushing.
CT=r1,r2,r3 Respecifies three viscous damping coefficients for the torque transferred by the
bushing.
FORCE=r1,r2,r3 Respecifies three constant force (preload) values.
K=r1,r2,r3 Respecifies three stiffness coefficients for the force transferred by the bushing.
KT=r1,r2,r3 Respecifies three stiffness coefficients for the torque transferred by the bushing.
LIST Lists the current values of the data in the BUSHING statement.
TORQUE=r1,r2,r3 Respecifies three constant torque (preload) values.
Caution: For the rotational constitutive equations to be accurate, at least two of the rotations (a, b,
and c) must be small. That is, two of the three values must remain smaller than 10 degrees.
In addition, if a becomes greater than 90 degrees, b becomes erratic. If b becomes greater
than 90 degrees, a becomes erratic. Only c can become greater than 90 degrees without
causing problems. For these reasons, it is best to define your BUSHING such that angles a
and b (not a and c and not b and c) remain small.
11 CONTROL
C++Commands
CONTROL
The CONTROL command branches program control to the driver subroutine CONSUB (see the
CONSUB subroutine). Adams/Solver (C++) passes parameter arguments to the command as an array.
Upon completion of CONSUB, Adams/Solver (C++) prompts you for another command.
Format
CONTROL/[FUNCTION=USER(r1[,...,r30])[\]][ROUTINE=libname::subname]
Arguments
[[ ]] Optionally select an item combination
[ ] Optionally select the item.
FUNCTION=USER(r1[,...,r30]) Specifies and passes up to thirty constants to a CONSUB driver
subroutine to regulate and control one or more Adams/Solver (C++)
simulations. Follow FUNCTION with an equal sign, the character
string USER, and the real values (r1[,...,r30]) to be passed to
CONSUB.
ROUTINE=libname::subname Specifies an alternative library and name for the user subroutine
CONSUB.
See ROUTINE Argument for more information.
Caution: Adams/Solver (C++) issues an error message and ignores the entire command if a
CONTROL command is issued when no CONSUB driver subroutine is linked with
Adams/Solver (C++).
Tip: A CONSUB driver subroutine can be thought of as an Adams command file programmed
in the FORTRAN programming language. The FORTRAN facilities for control and logic
may be used in conjunction with Adams utility subroutines to drive the Adams simulation.
In particular, the MODIFY utility subroutine can be used to issue Adams commands.
Adams/Solver
C++Commands
12
DEACTIVATE
The DEACTIVATE command turns off a statement that was previously turned on by the ACTIVATE
command, or that was active by default.
Format

Arguments
BEAM Indicates that Adams/Solver (C++) is to deactivate BEAM statements.
BUSHING Indicates that Adams/Solver (C++) is to deactivate BUSHING statements.
CLEARANCE Indicates that Adams/Solver (C++) is to deactivate CLEARANCE statements.
CONTACT Indicates that Adams/Solver (C++) is to deactivate CONTACT statements.
COUPLER Specifies that Adams/Solver (C++) is to deactivate COUPLER statements.
FIELD Indicates that Adams/Solver (C++) is to deactivate FIELD statements.
GCON Indicates that Adams/Solver (C++) is to deactivate GCON statements.
GFORCE Indicates that Adams/Solver (C++) is to deactivate GFORCE statements.
ID=id1[,...,id30] Lists up to 30 statement identifiers for statements that Adams/Solver (C++) is to
deactivate. You may use the ID argument in conjunction with the RANGE
argument.
JOINT Indicates that Adams/Solver (C++) is to deactivate JOINT statements.
13 DEACTIVATE
C++Commands
Extended Definition
The DEACTIVATE command, used in conjunction with the ACTIVATE command, switches
Adams/Solver (C++) elements off and on. All Adams/Solver (C++) elements are active by default in the
input dataset, but some may be deactivated using the DEACTIVATE command. For simulation purposes,
when Adams/Solver (C++) deactivates a statement, the statement effectively disappears from the model.
When a statement is activated, the statement appears as though it were always in the dataset. Both the
DEACTIVATE and ACTIVATE commands take effect when you issue the next SIMULATE command.
Once deactivated, a statement remains inactive until it is activated using an ACTIVATE command.
After the deactivation of any element, Adams/Solver (C++) reprocesses the model at the next
SIMULATE command as if it had just been read in from the dataset. During the reprocessing,
Adams/Solver (C++) checks the entire model for consistency, reinitializes user subroutines, and
recomputes initial conditions.
Adams/Solver (C++) reports zero forces for the inactive element if a force request or force graphic refers
to an inactive element. Additionally, references to deactivated elements in function expressions evaluate
to zero.
Adams/Solver (C++) also reinitializes all user subroutines to re-establish functional dependencies. For
each element that refers to a user-written subroutine, Adams/Solver (C++) calls the user-written
subroutine with IFLAG set to true.
the first simulation, Adams/Solver (C++) begins with the positions and velocities specified in the dataset.
If you ran a previous simulation, Adams/Solver (C++) begins with the final displacements and velocities.
JPRIM Indicates that Adams/Solver (C++) is to deactivate JPRIM statements.
LIST Indicates that Adams/Solver (C++) is to display a list of all the existing elements
of the specified type, along with their current activity status.
MOTION Indicates that Adams/Solver (C++) is to deactivate MOTION statements.
RANGE=id1, id2 Indicates a range of statement identifiers for statements that Adams/Solver
(C++) is to deactivate. Adams/Solver (C++) deactivates all statements with
identifiers that are numerically between the given identifiers, inclusively. The
range may contain unused identifiers. You may use the RANGE argument in
conjunction with the ID argument.
Range: id1 < id2
SENSOR Indicates that Adams/Solver (C++) is to deactivate SENSOR statements.
SFORCE Indicates that Adams/Solver is to deactivate SFORCE statements.
SPRINGDAMPER Indicates that Adams/Solver (C++) is to deactivate SPRINGDAMPER
statements.
VFORCE Indicates that Adams/Solver (C++) is to deactivate VFORCE statements.
VTORQUE Indicates that Adams/Solver (C++) is to deactivate VTORQUE statements.
Adams/Solver
C++Commands
14
constraints. If this is the first simulation, Adams/Solver (C++) also maintains any user-supplied joint
initial-conditions and part positions specified as EXACT.
Adams/Solver (C++) reports zero values in all output files for any forces associated with inactive
elements, including both applied forces and joint reaction forces. This includes force requests, force
graphics, and forces in the Results File.
Examples
DEACTI VATE/ J OI NT, I D=71, 72, 73
This DEACTIVATE command deactivates JOINTs 71, 72, and 73.
DEACTI VATE/ SENSOR, RANGE=5, 10
This DEACTIVATE command deactivates all SENSORs with identifiers between 5 and 10, including 5
and 10.
You can turn off contact forces in your model during a simulation by using the DEACTIVATE command
in the .acf file.
SI MULATE/ TRANSI ENT, END=1. 0, STEPS=100
DEACTI VATE/ CONTACT, I D=1, 3, LI ST
SI MULATE/ TRANSI ENT, DURATI ON=1. 0, STEPS=100
This simulates four active contact elements for one second, disabling two out of four contacts, then
continuing the simulation for another second. The LIST argument is useful for obtaining feedback in the
.msg file on the status of active elements. When deactivation has taken place, you will see a similar
message:
CONTACT/ 1, I NACTI VE CONTACT/ 2, ACTI VE CONTACT/ 3, I NACTI VE CONTACT/ 4,
ACTI VE
Tip: Typically, you use DEACTIVATE and ACTIVATE to set up the model for a particular
loadcase or configuration after a FILE or RELOAD command.
Caution: Deactivating elements may produce strong discontinuities in the model causing
convergence difficulties and reduced integrator performance. It is important that you use
these commands carefully to avoid discontinuities.
15 DEBUG
C++Commands
DEBUG
The DEBUG command redefines and/or lists the data for a DEBUG statement. See the DEBUG statement
for more information.
Format
Adams/Solver
C++Commands
16
Arguments
DUMP Writes the current representation of a dataset to the Message File. This facility essentially saves
the system at the current time and also provides numeric values for functions and orientations.
Default: Off
EPRINT Prints a block of information for each kinematic, static, or dynamic step. This information helps
you monitor the simulation process and to locate the source of the error if there is a problem. Each
step consists of two phases: 1) a forward step in time (the predictor for dynamics) and 2) the
solution of the equations of motion (the corrector for dynamics). For the first phase, Adams/Solver
prints out the following information:
The step number. This is a running count of the number of steps taken and can be used as a
measure of how hard Adams/Solver is working.
The order of the predictor for dynamics. This corresponds to the order of the polynomial
Adams/Solver uses to predict the solution at the end of the integration step.
The value of time at the beginning of the step.
The size of the step.
For the second phase, Adams/Solver prints out the cumulative number of iterations and a table of
information about the iterations. The cumulative number of iterations is a running count of the
iterations needed to solve the equations of motion and can be used as a measure of how many
computations Adams/Solver is performing. The table contains information about the maximum
equation error and maximum variable change for each iteration. For each iteration, Adams/Solver
prints out the following information:
The iteration number. This is one at the beginning of each step and increments by one until
Adams/Solver converges to a solution or exceeds the maximum allowable number of
iterations.
The largest (in absolute value) equation residual. Each equation should have an error value
close to zero. This number is an indicator of how far Adams/Solver is from a solution. This
number should decrease after every iteration.
The dataset element associated with the largest equation residual error.
The equation that has the largest equation residual error for the above dataset element.
The absolute value of the largest change in a variable. The final iteration should not need to
change variables very much. This number is an indicator of how far Adams/Solver needs to
change variables to approach a solution. This number should decrease after every iteration.
The dataset element associated with the absolute value of the largest change in a variable.
The variable with the largest change for the above dataset element.
If Adams/Solver has updated the Jacobian, YES appears under the new Jacobian header.
Default: NOEPRINT
17 DEBUG
C++Commands
Extended Definition
Of all the arguments in the DEBUG command, EPRINT is perhaps the most useful. This section explains
the EPRINT argument in detail.
JMDUMP Enables the dumping the Jacobian matrix at each iteration.
Default: NOJMDUMP
LIST Lists the current values of the data in the DEBUG statement.
NOEPRINT Suppresses the printing of three numbers at each integration step and five numbers at each
corrector iteration during an integration.
Default: NOEPRINT
NOJMDUMP Disables the dumping of the Jacobian matrix at each iteration.
Default: NOJMDUMP
NOREQDUMP Disables the dumping of REQUEST and MREQUEST statement output at each iteration.
Default: NOREQDUMP
NORHSDUMP Disables the dumping of the YY array (state vector), the RHS array (error terms), and the DELTA
array (increment to state vector) at each iteration.
Default: NORHSDUMP
NOVERBOSE Deactivates the output of explanations and possible remedies and the output of the names of
subroutines from which Adams/Solver sends diagnostics.
Default: NOVERBOSE
REQDUMP Enables the dumping of the REQUEST and the MREQUEST statement output at each iteration.
Default: NOREQDUMP
RHSDUMP Enables the dumping of the YY array (state vector), RHS array (error terms), and DELTA array
(increment to state vector) at each iteration.
Default: NORHSDUMP
VERBOSE Outputs to the screen such additional information as the name of the subroutine from which
Adams/Solver sends each diagnostic, explanations, and possible remedies (when available). If you
do not include the VERBOSE argument, Adams/Solver outputs to the screen only basic error
messages. Whether or not you include the VERBOSE argument, Adams/Solver outputs
VERBOSE information to the Message File.
Default: NOVERBOSE
Adams/Solver
C++Commands
18
The kinematic, dynamic, and quasi-static analyses in Adams/Solver involve the solution of the governing
equations of motion. Static analysis is the solution of the equilibrium and the initial conditions analysis
solves the assembly equations at a particular point in time.
The equations to be solved, for all these analyses, are non-linear algebraic or differential-algebraic
equations. The solution of these equations is an iterative process. The EPRINT argument enables
Adams/Solver to write out the information pertaining to the solution process in a succinct and
understandable format. All analyses that march through time consist of two distinct phases: predictor
phase and corrector phase.
Predictor Phase
In order to proceed efficiently from one time to the next, Adams/Solver uses a predictor. The predictor is
simply a means of estimating the values of the system state by looking at the past values of the state and
extrapolating the data based on a simple curve fitting algorithm.
Consider a series of values y
i
defined at discrete times t
i

where i=1...n. A simple first order predictor that may be used to predict the value y
n+1
at t
n+1
is:
where superscript p implies a predicted value. This is shown graphically in Figure 1.
Figure 1 First Order Predictor
You can easily surmise from Figure 1, a first order predictor simply consists of connecting the points y
n-
1
and y
n
with a straight line and extending it to time t
n+1
.
19 DEBUG
C++Commands
A second order predictor, similarly, can be thought of as constructing a parabola between the points (t
n-
2
, y
n-2
), (t
n-1
, y
n-1
) and (t
n
, y
n
) and extending the parabola to time tn+1. The predicted value of y at t
n+1

is the intersection of the vertical line t=t
n+1
with this parabola. Predictors are typically polynomials
(linear, quadratic, cubic, etc.) and the order of the polynomial is frequently called the order of the solution
method.
For kinematic analyses, Adams/Solver employs a first or second order predictor. For quasi-statics, a first
order predictor is used. For dynamic analyses much higher order predictors are used. The BDF methods
(GSTIFF and WSTIFF) use up to six order predictors. ABAM on the other hand can use up to a 12th
order predictor. Sophisticated numerical analysis is employed to determine the most appropriate order of
prediction to use at any given step.
Furthermore, sophisticated curve fitting methods like Newton-Divided Difference tables are usually
employed to efficiently predict the system state. Figure 2 shows the format of the output produced by the
EPRINT argument and explains the data pertinent to the predictor phase of a dynamic analysis step.
The predictor polynomials used for the dynamic analyses interpolate previous values and the slope of the
variable at the current time to estimate the solution at the next time. Therefore, in Figure 5, a second order
polynomial that fits the solution at times t
4
and t
5
and the slope of the solution at time t
5
is used to predict
the value of the solution at time t
6
.
Figure 2 A Successful Integration Step
Corrector Phase
Adams/Solver
C++Commands
20
Since all predictors simply look at past values to estimate the solution at the next time, the predicted
values almost never satisfy the governing equations. They simply constitute a good initial guess for the
solution. The refining of the predicted solution to one that satisfies the governing equations is called the
correction. Since the governing equations are usually non-linear, an iterative scheme like Newton-
Raphson iterations are used.
This methodology is explained for the simplest case of one non-linear algebraic equation in one variable.
Let f(x) be a smooth function of a single variable x. Given an initial guess x=x
0
, a solution x=x
c
that
satisfies f(x)=0 is desired for this simple example. The Newton-Raphson iterations may be expressed as:
for i=0 ... max_no_iterations. is a small user-defined number that specifies the convergence criterion.
1. Evaluate r
i
= f(x
i
)
2. If || err(x
i
) || < return x
i
as the solution
where err(x
i
) is the error measure being maintained during Newton Raphson iterations
3. Evaluate
4. Calculate
5. Set
6. Set i = i+1 and go to Step 1.
The quantity r
i
is frequently called the residual and is a measure of the accuracy of the solution. The
quantity J
i
is the partial derivative of f with respect to x, evaluated at x=x
i
and is commonly known as
c
c
J
i
x c
cf
x x
i
=
=
x A
i
J
i
1
r
i
=
x
i
x
i
x A
i
+ =
21 DEBUG
C++Commands
the Jacobian. The graph on the left side of Figure 3 illustrates the Newton-Raphson iterations for the one-
dimensional example discussed above.
Figure 3 The Newton-Raphson Algorithm for a Single Nonlinear Equation
J
0
is the slope of the curve f(x) at x=x
0
. Through simple trigonometry it can be seen that x
0
-x
1
= r
0
/J
0

(i.e., x
1
= x
0
- r
0
/J
0
).
Adams/Solver
C++Commands
22
Similarly,
The corrector in Adams/Solver involves the solution of many variables simultaneously. The algorithm
for one dimension is easily extended to n dimensions as follows:
Let x = {x
1
, x
2
,... x
n
} be a set of n variables and f = {f
1
(x), f
2
(x),... f
n
(x)} be a set of n non-linear equations
in the variables x.
Define:
J = ,
where i=1,...,n and j=1,...,n. Then the Newton-Raphson iterations for the n-dimensional case becomes:
given an initial guess x = x
0
= {x
01
, x
02
,... x
0n
} for i=0,...,max_no_interations. is a small user-defined
number that specifies the convergence criterion.
1. Evaluate r
i
= f(x
i
)
2. If || r
i
|| < return x = x
i
as the solution
3. Calculate , where j=1,...,n and k=1,...,n
4. Evaluate
5. Set ,
6. Set i = i+1 and go to Step 1.
For the n-dimensional case, evaluating the Jacobian J
i
and its inverse at each iteration can be quite
expensive and is the most expensive part of the iteration process. In order to decrease the computational
overhead, the Jacobian J
i
is not evaluated at each iteration. It is only updated periodically. This technique
can dramatically increase the overall speed of the corrector iterations and is termed Modified Newton-
Raphson iterations.
The graph on the right side of Figure 3 demonstrates the use of the Modified Newton-Raphson iterations
to solve the one-dimensional problem f(x)=0. In this example, the initial Jacobian f(x
0
) is re-used for the
first 4 corrections before it is re-evaluated for iteration 5. The data are shown in Figure 4 for the modified
23 DEBUG
C++Commands
Newton-Raphson iterations in a dynamic analysis. The numbers on the left are the values of the
maximum residuals at each iteration. The maximum corrections are on the right. In practice, the
convergence rate of the iterations is used to determine whether a Jacobian evaluation is to be performed
or not.
Figure 4 The Modified Newton-Raphson Algorithm for a System of Non-linear Equations
Figure 5 Predictor Polynomial and Corrected Value
The DEBUG/EPRINT option generates a table of data on the action of Adams/Solver for each of the
iterative algorithms in the various analyses. The iterative algorithm, or corrector, is used to evaluate the
variables governed by the system of non-linear equations. Table 1 contains the DEBUG/EPRINT
information for the variables associated with the mass-bearing elements (parts, point masses, and flexible
bodies) and for the corresponding equations. A combination of several equations is needed to define each
Adams/Solver
C++Commands
24
joint and joint primitive. Table 2 includes the variables for the various joint constraints and the
corresponding equations.
Adams/Solver uses a combination of equations to represent the different types of forces. While certain
equations are specific to a particular force, others are generic to all types. The combination of variables
and corresponding equations for the forces are included in Table 3. The DEBUG/EPRINT information
for the variables and corresponding equations that define the Adams system elements is contained in
Table 4. Finally, Table 5 includes the information on the variables and equations for the remaining
miscellaneous elements in an Adams system.
Table 1 Mass Bearing Elements Debug Descriptions
EQUATIONS VARIABLES
Element
type: Code: Explanation: Code: Explanation:
Parts Translational force,
x-direction, GCS
Translational coordinate,
x-direction, GCS
Translational force,
y-direction, GCS
y-direction, GCS
z-direction, GCS
z-direction, GCS
Algebraic equation for the
component of the
angular momentum
Rotational rate, first component, 3-
1-3 Euler angles, GCS
component of the
angular momentum
Rotational rate, second component,
3-1-3 Euler angles, GCS
component of the
angular momentum
Rotational rate, third component, 3-
1-3 Euler angles, GCS
Torque, the component component of the angular
momentum
momentum
momentum
v
x
Velocity equation,
x-coordinate, GCS
x Translational coordinate,
x-direction, GCS
v
y
Velocity equation,
y-coordinate, GCS
y Translational coordinate,
y-direction, GCS
v
z
Velocity equation,
z-coordinate, GCS
z Translational coordinate,
z-direction, GCS
mx
my
mz
p
u
u
u
p
|
|
|
u
u p
u
u
p
|
| p
|
|
25 DEBUG
C++Commands
Equation for the time-
derivative of the
coordinate
Rotational coordinate, first
component, 3-1-3 Euler angles,
GCS
derivative of the
coordinate
Rotational coordinate, second
GCS
derivative of the
coordinate
Rotational coordinate, third
GCS
Flexible
Bodies
x-direction, GCS
x-direction, GCS
y-direction, GCS
y-direction, GCS
z-direction, GCS
z-direction, GCS
First of three equations of
motion for torque
Time-derivative of the
coordinate
Second of three equations
of motion for torque
coordinate
Third of three equations of
motion for torque
coordinate
Inertial equations for
modal coordinates for 1
j number of flexible
modes
Time-derivatives of modal
coordinates for 1 j number of
flexible modes
v
x
Velocity equation,
x-coordinate, GCS
x Translational coordinate,
x-direction, GCS
v
y
Velocity equation,
y-coordinate, GCS
y Translational coordinate,
y-direction, GCS
v
z
Velocity equation,
z-coordinate, GCS
z Translational coordinate,
z-direction, GCS
derivative of the
coordinate
Rotational coordinate, first
GCS
derivative of the
coordinate
Rotational coordinate, second
GCS
EQUATIONS VARIABLES
Element
+
u
u
|
|
|
mx
my
mz
u
u
u
e
|
|
|
M q
j
s
s
q
j
s s
+
u
u
Adams/Solver
C++Commands
26
Table 2 J oint and J oint Primitive Debug Descriptions
derivative of the
coordinate
Rotational coordinate, third
GCS
derivatives of modal
coordinates for 1 j
number of flexible modes
Modal coordinates for 1 j
number of flexible modes
Point
Masses
x-direction, GCS
Translational velocity,
x-direction, GCS
y-direction, GCS
y-direction, GCS
z-direction, GCS
z-direction, GCS
EQUATIONS VARIABLES
Element
type: Code: Explanation: Code: Explanation: Notes:
Joint Initial
Condition,
x At Point Constraint
(x) x
i
x
j
= 0
Reaction Force (x) 1
Translational y At Point Constraint
(y) y
i
y
j
= 0
y Force Reaction Force (y) 1
z At Point Constraint
(z) z
i
z
j
= 0
z Force Reaction Force (z) 1
Joint Initial
Condition,
x
i
- y
j
Angular Constraint (x
i
,
y
j
) x
i
- y
j
= 0
xy Torque Reaction Torque (x
i
,
y
j
)
2
Rotational z
i
- x
j
Angular Constraint (z
i
,
x
j
) z
i
- x
j
= 0
zx Torque Reaction Torque (z
i
,
x
j
)
2
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
zy Torque Reaction Torque (z
i
,
y
j
)
2
Cylindrical
Joint
z
i
- x
j
i
,
x
j
) z
i
- x
j
= 0
i
,
x
j
)
2
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
i
,
y
j
)
2
EQUATIONS VARIABLES
Element
|
|
|
q
j
s s
q
j
s s
mx
my
mz
27 DEBUG
C++Commands
s - x
j
Sliding Constraint (s,
x
j
) s - x
j
= 0
sx Force Reaction Force (s,
x
j
)
3
s - y
j
Sliding Constraint(s,
y
j
) s - y
j
= 0
sy Force Reaction Force (s,
y
j
)
3
Convel Joint x At Point Constraint
(x) x
i
x
j
= 0
x Force Reaction Force (x) 2
y At Point Constraint
(y) y
i
y
j
= 0
(z) z
i
z
j
= 0
x
i
- y
j
i
,
y
j
) x
i
- y
j
= 0
i
,
y
j
)
3
Fixed Joint x At Point Constraint
(x) x
i
x
j
= 0
y At Point
Constraint(y) y
i
y
j

= 0
(z) z
i
z
j
= 0
x
i
- y
j
i
,
y
j
) x
i
- y
j
= 0
i
,
y
j
)
2
z
i
- x
j
i
,
x
j
) z
i
- x
j
= 0
i
,
x
j
)
2
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
i
,
y
j
)
2
Hooke Joint x At Point
Constraint(x) x
i
x
j

= 0
(y) y
i
y
j
= 0
(z) z
i
z
j
= 0
x
i
- y
j
i
,
y
j
) x
i
- y
j
= 0
i
,
y
j
)
3
Planar Joint z
i
- x
j
i
,
x
j
) z
i
- x
j
= 0
i
,
x
j
)
2
EQUATIONS VARIABLES
Element
Adams/Solver
C++Commands
28
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
i
,
y
j
)
2
s - z
j
z
j
) s - z
j
= 0
sz Force Reaction Force (s,
z
j
)
3
Rack-&-
Pinion Joint
o - P Rotation/Translation
Dependency
ap Force Reaction Force ( ) 4
Revolute
Joint
(x) x
i
x
j
= 0
(y) y
i
y
j
= 0
(z) z
i
z
j
= 0
z
i
- x
j
i
,
x
j
) z
i
- x
j
= 0
i
,
x
j
)
2
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
i
,
y
j
)
2
Screw Joint o - P Rotation/Translation
Dependency
ap Force Reaction Force ( ) 4
Spherical
Joint
(x) x
i
x
j
= 0
(y) y
i
y
j
= 0
(z) z
i
z
j
= 0
Translational
Joint
z
i
- x
j
i
,
x
j
) z
i
- x
j
= 0
i
,
x
j
)
2
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
i
,
y
j
)
2
x
i
- y
j
i
,
y
j
) x
i
- y
j
= 0
i
,
y
j
)
2
s - x
j
x
j
) s - x
j
= 0
sx Force Reaction Force (s,
x
j
)
3
s - y
j
y
j
) s - y
j
= 0
sy Force Reaction Force (s,
y
j
)
3
Universal
Joint
(x) x
i
x
j
= 0
EQUATIONS VARIABLES
Element
29 DEBUG
C++Commands
Notes
(y) y
i
y
j
= 0
(z) z
i
z
j
= 0
z
i
- z
j
i
,
z
j
) z
i
- z
j
= 0
zz Torque Reaction Torque (z
i
,
z
j
)
2
Atpoint Joint
Primitive
(x) x
i
x
j
= 0
(y) y
i
y
j
= 0
(z) z
i
z
j
= 0
Inline Joint
Primitive
x
ij
Equivalent to Sliding
Constraint (s, x
j
) s - x
j
=
0
x Force Reaction Force (s,
x
j
)
3
y
ij
Constraint (s, y
j
) s - y
j
= 0
y Force Reaction Force (s,
y
j
)
3
Inplane Joint
Primitive
z
ij
Constraint (s, z
j
)
z Force Reaction Force (s,
z
j
)
3
Orientation
Joint
Primitive
z
i
- x
j
i
,
x
j
) z
i
- x
j
= 0
i
,
x
j
)
2
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
i
,
y
j
)
2
x
i
- y
j
i
,
y
j
) x
i
- y
j
= 0
i
,
y
j
)
2
Parallel Joint
Primitive
z
i
- x
j
i
,
x
j
) z
i
- x
j
= 0
i
,
x
j
)
2
z
i
- y
j
i
,
y
j
) z
i
- y
j
= 0
i
,
y
j
)
2
Perpendicular
Joint
Primitive
z
i
- z
j
i
,
z
j
) z
i
- z
j
= 0
zz Torque Reaction Torque (z
i
,
z
j
)
2
EQUATIONS VARIABLES
Element
Adams/Solver
C++Commands
30
1. An At Point Constraint ensures that the origins of the two markers connected by this constraint
remain spatially collocated during the simulation. This constraint is made up of 3 equations for
the displacement between the two markers in the global X, Y and Z directions, respectively. For
each of the equations, a corresponding variable is introduced to represent the constraint reaction
in the X, Y and Z directions, respectively. In Table 3 a at point constraint equation in the n1
direction is denoted by At_point_constraint(n1) and the corresponding reaction force by
Reaction_force(n1).
The three At Point Constraint equations are: x
i
- x
j
= 0, y
i
- y
j
= 0, and z
i
- z
j
= 0.
2. An Angular Constraint ensures that two vectors fixed in separate mass bearing elements (PARTs,
POINT_MASSes, or FLEX_BODY) (MBE) remain mutually perpendicular during the
simulation. This constraint is represented by 1 equation. This equation requires the dot product of
the two vectors to be zero. Corresponding to this equation, a variable is introduced to represent
the constraint reaction torque. In Table 3, this constraint is denoted as Angular Constraint(v1,v2)
and its reaction torque as Reaction Torque(v
1
,v
2
).
An Angular Constraint is given as .
3. A Sliding constraint is a constraint between a spanning vector and a direction fixed in a MBE. A
spanning vector is defined as the spatial vector from the origin of marker i to the origin of marker
j. A sliding constraint ensures that a spanning vector remains perpendicular to the vector fixed in
a MBE. This constraint is enforced by 1 equation that sets the dot product between the spanning
vector and the fixed vector to zero. Introduction of this equation in a model causes a variable in
the form of a constraint reaction force to be included in the model. In Table 3, the equation for
this constraint is denoted as Sliding_constraint(s,v1) and the reaction force by
Reaction_force(s,v1).
A Sliding constraint is given as .
4. A Rotation/Translation Dependency Constraint requires the angular displacement between two
markers with common z-axes to be a constant (pitch) times the translational displacement
between the origins of these markers. This constraint is represented by one equation and has a
corresponding reaction force. In Table 3, this constraint is represented as Rotation/Translation
Dependency and the reaction force as Reaction Force(). Equation for a Rotation/Translation
Dependency Constraint is given as , where s is the distance travelled along the z-
axis, o is the angle of rotation, and p is the user specified pitch.
Table 3 Force Debug Descriptions
EQUATIONS VARIABLES
Element
FIELD,
BEAM,
Dx x-displacement equation Dx Element x-displacement 7
BUSHIN
G
Dy y-displacement equation Dy Element y-displacement 7
Dz z-displacement equation Dz Element z-displacement 7
31 DEBUG
C++Commands
Theta x Equation for rotational
displacement about x-
axis
Theta x Rotational displacement
about x-axis
7
Theta y Equation for rotational
displacement about y-
axis
Theta y Rotational displacement
about y-axis
7
Theta z Equation for rotational
displacement about z-
axis
Theta z Rotational displacement
about z-axis
7
Fx x-direction force
equation
Fx Force in the global-x
direction
5
Fy y-direction force
equation
Fy Force in the global-y
direction
5
Fz z-direction force
equation
Fz Force in the global-z
direction
5
Tx x-axis torque equation Tx Torque about the global x-
axis
6
Ty y-axis torque equation Ty Torque about the global y-
axis
6
Tz z-axis torque equation Tz Torque about the global z-
axis
6
GFORCE Fx x-force equation Fx Force in the x direction 5
Fy y-force equation Fy Force in the y direction 5
Fz z-force equation Fz Force in the z direction 5
Tx x-torque equation Tx Torque in the x direction 6
Ty y-torque equation Ty Torque in the y direction 6
Tz z-torque equation Tz Torque in the z direction 6
NFORCE Fx x-force equation Fx Force in x direction 5
Fy y-force equation Fy Force in y direction 5
Fz z-force equation Fz Force in z direction 5
Tx x-torque equation Tx Torque about x-axis 6
Ty y-torque equation Ty Torque about y-axis 6
Tz z-torque equation Tz Torque about z-axis 6
EQUATIONS VARIABLES
Element
Adams/Solver
C++Commands
32
Notes
5. Force equations and variables: forces are defined via explicit force equations. These equations
take the general form of:
Force_variable - Force_expression = 0
Translatio
nal
SFORCE
Length Equation for distance
between I and J markers
Length Distance between I and J
markers
7
Force Equation for element
force
Force Force in element 7
Fx x-force equation Fx Force in x direction 5
Rotational
SFORCE
Torque Element torque equation Torque Torque in element 6
Translatio
nal
Springda
mper
Length Equation for distance
between I and J markers
Length Distance between I and J
markers
7
L Vel Equation for velocity in
element
L Vel Element velocity 7
Fx x-force equation Fx Force in x direction 5
Rotational
Springda
mper
Torque Element torque equation Torque Torque in element 6
VFORCE Fx x-force equation Fx Force about the x-direction
Fy y-force equation Fy Force about the y-direction
Fz z-force equation Fz Force about the z-direction
VTORQU
E
Tx x-torque equation Tx Torque about the x-axis
Ty y-torque equation Ty Torque about the y-axis
Tz z-torque equation Tz Torque about the z-axis
EQUATIONS VARIABLES
Element
33 DEBUG
C++Commands
where:
Force_variable denotes the force in the x, y or z direction, respectively.
Force_expression is an expression defining the force in terms of state variables and user
defined coefficients.
6. Torque equations are defined in a manner similar to force equations. These equations take the
form of:
Torque_variable - Torque_expression = 0
where:
Torque_variable denotes the torque in the element in the x, y, or z direction, respectively.
Torque_expression defines the torque in term of state variables and user defined coefficients.
7. In addition to force and torque equations, element-specific equations and variables can be used to
define force elements. Typically these equations are to define intermediate kinematic quantities
used in force and torque computation.
Table 4 System Elements Debug Descriptions
EQUATIONS VARIABLES
Element
DIFF Differential
Equation
Equation for the ODE User
Variable
Variable for the solution of
the ODE
GSE States General, first order state
equations for 1 j number
of states
State x
j
Variables for the solution
to the differential
equations.
Outputs y
j
Algebraic equations for 1 j
number of outputs
Outputs y
j
Variables for the values of
the output equations.
LSE States First order linear state
equations for 1 j number
of states
State x
j
Variables for the solution
to the differential
equations.
Outputs y
j
Linear algebraic equations for
1 j number of outputs
Outputs y
j
Variables for the values of
the linear equations.
TFSISO State Linear, first order, differential
equations for the single-input,
single-output transfer
function = Ax + Bu for
1 j number of states.
State Values of the states for the
single-input, single-output
transfer function.
x
j
s s
s
s
x
j
s s
s s
x
j
x
s s
x
j
Adams/Solver
C++Commands
34
Table 5 Miscellaneous Elements Debug Descriptions
Output y Linear equation y = Cx + Du
in terms of the states x and the
input u.
Output y Values of the output for the
transfer function.
VARIABLE Algebraic
Equation
Equation for the variable Algebraic
Variable
Value of the variable
EQUATIONS VARIABLES
Elemen
t type: Code: Explanation: Code: Explanation: Notes:
COUPL
ER
f(
1
,
2
,
3
)=0
Constraint relating joint
displacements
l Reaction force
CVCV x At point constraint (x) x Force Reaction force (x) 2
y At point constraint (y) y Force Reaction force (y) 2
z At point constraint (z) z Force Reaction force (z) 2
T
i
- N
j
Constraint to force the tangent to
curve 1 to be perpendicular to
normal to curve 2
TN
Torque
Constraint torque
variable
Perpendicular constraint for curve
1
F-o Constraint force on
curve 1
Perpendicular constraint for curve
2
F-| Constraint force on
curve 2
a Equation for the parameter for
curve 1
a Parameter for
curve 1
b Equation for the parameter for
curve 2
b Parameter for
curve 2
Equation for the first derivative of
the first curve parameter
First derivative of
the first parameter
Equation for the first derivative of
the second curve parameter
Second derivative
of the first
parameter
Equation for the second derivative
of the first curve parameter
First derivative of
the second
parameter
EQUATIONS VARIABLES
Element
o
35 DEBUG
C++Commands
See other Analysis parameters available.
Equation for the second derivative
of the second curve parameter
Second derivative
of the second
parameter
GEAR f(
1
,
2
)=0 Constraint relating displacements
() in two joints
l Reaction force
MOTIO
N
-f(t)=0 Joint displacement specified as a
function of time
l Reaction force
PTCV x At point constraint (x) x Force Reaction force (x) 2
y At point constraint (y) y Force Reaction force (y) 2
z At point constraint (z) z Force Reaction force (z) 2
Perpendicular constraint F-o Constraint force
a Equation for the curve a Curve parameter
Equation for the first derivative Derivative of the
curve parameter
Equation for the second derivative Second derivative
UCON f(Q)=0 Constraint on system states Q l Associated
reaction force
EQUATIONS VARIABLES
Elemen
t type: Code: Explanation: Code: Explanation: Notes:
|
Adams/Solver
C++Commands
36
ENVIRONMENT
Using the ENVIRONMENT command is an alternative way of setting an Adams/Solver (C++) runtime
environment variable. For example, rather than using the set env command when working with the
Linux operating system, one may use the ENVIRONMENT command instead.
One feature of the ENVIRONMENT command is the following, the execution of this command does not
modify the operating system environment; it only affects the Adams/Solver (C++) runtime environment
for the model being run. When the simulations are finished, the original operating system environment
is left intact.
A second feature is related to the collection of environment variables one may set. Only environment
variables related to the Adams/Solver (C++) may be set. For example, you may not use this command to
set an environment variable used by other products.
Format
Arguments
Extended Definition
The operating system environment stands for a set of environment variables. Each of these environment
variables has a name, and it may have an associated value. Both name and value are character strings set
by the user using tools provided by the operating system.
The use of environment variables provides a simple mechanism to let users communicate preferences to
a running computer program. The use of environment variables is a practical way to trigger the execution
of undocumented features, workarounds, experimental methods, etc. without the need to modify the
AMD/ACF language layers of the Adams/Solver (C++).
When the execution of Adams/Solver (C++) starts, all the environment variables are scanned and the
Adams/Solver (C++) runtime environment is created. The Adams/Solver (C++) runtime environment is
initialized with all the environment variables that the Adams/Solver (C++) recognizes. Environment
NAME=c Specifies a character string for the name of the Adams/Solver (C++) runtime environment
variable being set.
VALUE=c Specifies a character string for the value of the Adams/Solver (C++) runtime environment
variable being set. Some variables do not need a value to be specified.
The character string may be enclosed between double quotes.
UNSET Specifies the removal of the variable from the Adams/Solver (C++) runtime environment.
LIST Lists all Adams/Solver (C++) runtime environment variables found.
ENVIRONMENT NAME c LIST , | |
ENVIRONMENT NAME c VALUE , = c LIST , | |
ENVIRONMENT NAME c UNSET LIST , | | , =
=
=
37 ENVIRONMENT
C++Commands
variables used by vertical applications or other products are not included in the Adams/Solver (C++)
runtime environment.
Next, when the model is being read, all of the ENVIRONMENT statements are processed one by one in
the same order they are found in the ADM dataset file. The ENVIRONMENT statements will update or
modify the Adams/Solver (C++) runtime environment. If there is at least one ENVIRONMENT
statement in the dataset file, Adams/Solver (C++) prints a report of all the Adams/Solver (C++) runtime
environment variables and their corresponding values (if any) along with a description of the feature the
variable is used for.
You may change the value of an Adams/Solver (C++) runtime environment variable using the
ENVIRONMENT command.
The advantages of having the ENVIRONMENT statement and command are:
It allows setting preferences at the model level rather than at the operating system level.
It helps reduce the pollution in the operating system environment and better manage the settings.
Examples
1. Let's assume you define the following environment variable from a Linux shell:
%set env MSC_ADAMS_SOLVER_BEAM_MODEL=LI NEAR
Let's assume the ADM dataset file has no ENVIRONMENT statements and that the ACF
command file has the following commands:
ENV/ NAME=MSC_ADAMS_SOLVER_BEAM_MODEL, VALUE=NONLI NEAR
FI LE/ MODEL=beam_model
ENV/ NAME=MSC_ADAMS_STATI CS_NO_RESTORE_VELOCI TI ES
SI M/ STA
Running the model, Adams/Solver (C++) will print the following messages:
OS- envi r onment var i abl e
MSC_ADAMS_SOLVER_BEAM_MODEL=LI NEAR
Enf or ces Adams/ Sol ver C++ t o use a di f f er ent beammodel .
Opt i ons ar e LI NEAR, STRI NG, NONLI NEAR.
command: FI LE/ COMMAND=beam_model
command:
command: ENVI RONMENT/ NAME=MSC_ADAMS_SOLVER_BEAM_MODEL,
VALUE=STRI NG
User - envi r onment var i abl e
MSC_ADAMS_SOLVER_BEAM_MODEL=STRI NG
Enf or ces Adams/ Sol ver C++ t o use a di f f er ent beammodel .
Opt i ons ar e LI NEAR, STRI NG, NONLI NEAR.
* Over wr i t es a pr evi ous def i ni t i on.
command:
command: f i l e/ model =beam_model
Adams/Solver
C++Commands
38
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
| Model Ti t l e |
| ==============================================================|
| |
| Beammodel |
| |
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
command:
command: env/ name = MSC_ADAMS_STATI CS_NO_RESTORE_VELOCI TI ES
User - envi r onment var i abl e
MSC_ADAMS_STATI CS_NO_RESTORE_VELOCI TI ES
Enf or ces Adams/ Sol ver C++ not t o r est or e i ni t i al vel oci t i es af t er
a STATI C anal ysi s at t i me t =0.
Observe Adams/Solver prints two messages regarding the
MSC_ADAMS_SOLVER_BEAM_MODEL variable. The first one is printed when processing
the operating system environment. The second one is printed when processing the
ENVIRONMENT command. Notice the message "Overwrites a previous definition" indicating
that the ENVIRONMENT command overwrote the value of the environment variable set in the
operating system.
2. In this example the ENVIRONMENT command generates an error message. Let's assume the
ACF command file is the following:
FI LE/ MODEL=beam_model
ENVI RONMENT/ NAME=MSC_ADAMS_SOLVER_BEAM_MODEL, VALUE=NONLI NEAR
SI M/ STA
Running the above ACF command file, the following message is printed:
command: envi r onment / name=MSC_ADAMS_SOLVER_BEAM_MODEL,
val ue=STRI NG
- - - - START: ERROR - - - -
Envi r onment var i abl e MSC_ADAMS_SOLVER_BEAM_MODEL must be set
bef or e t he model i s const r uct ed.
Command wi l l be i gnor ed.
To avoi d t hi s pr obl ems do one of t hese:
( 1) Set t he env var i abl e i n t he oper at i ng syst em.
( 2) Set t he env var i abl e i n t he *. admf i l e.
( 3) I ssue t he ENV/ command bef or e t he FI LE/ MODEL command.
- - - - END: ERROR - - - -
39 ENVIRONMENT
C++Commands
Adams/Solver (C++) prints an error message and ignores the setting of the the
MSC_ADAMS_SOLVER_BEAM_MODEL because the model has already been constructed.
See other Simulation command available.
Caution: Environment variables are typically intended for experimentation and testing of
undocumented features. They may be removed in a future release without notice. Please
bear this in mind when using the ENVIRONMENT statement and command.
Adams/Solver
C++Commands
40
EQUILIBRIUM
An EQUILIBRIUM command redefines and/or lists the data for an EQUILIBRIUM statement. If an
EQUILIBRIUM statement is not included in the Adams/Solver model and an EQUILIBRIUM command
is not issued before a static or quasi-static simulation, Adams/Solver (C++) uses the default values for
ALIMIT, ERROR, IMBALANCE, MAXIT, PATTERN, STABILITY, and TLIMIT for the analysis.
Format
EQUILIBRIUM/
ALIMIT = r
ERROR = r ,
IMBALANCE = r ,
MAXIT = i ,
PATTERN = c1 [:...: c10] ,
STABILITY = r ,
TLIMIT = r ,
METHOD =i ,
ATOL = r ,
RTOL = r ,
MAXITL = i ,
ETAMAX = r ,
ETA = r ,
)

`

DEFAULT
LIST , | |

{ } Select one item
| | | | Optionally select an item combination
41 EQUILIBRIUM
C++Commands
Arguments
ALIMIT=r Specifies the maximum angular increment allowed per iteration during a
static or quasi-static equilibrium analysis. The default units for ALIMIT are
radians. To specify ALIMIT in degrees, add a D after the value.
Range: ALIMIT > 0
DEFAULT Resets all options to the default values specified in the EQUILIBRIUM
statement, namely:
ALI MI T = 10D
ERROR = 1. 0E- 4
I MBALANCE = 1. 0E- 4
MAXI T = 25
PATTERN = T: T: T: T: T: T: T: T: T: T
STABI LI TY = 1. 0E- 5
TLI MI T = 20
ERROR=r Specifies the relative correction convergence-threshold. The iterative process
carried out during the equilibrium analysis can not converge prior to all
relevant relative corrections being smaller than this value.
Range: ERROR > 0
IMBALANCE=r Specifies the equation imbalance convergence threshold. The iterative
process carried out during the equilibrium analysis can not converge prior to
each equation imbalance being smaller than this value.
Range: IMBALANCE > 0
LIST Lists the current values of the data in the EQUILIBRIUM statment.
MAXIT=i Specifies the maximum number of iterations allowed for finding static
equilibrium.
Range: MAXIT > 0
PATTERN=c1[:...:c10] Specifies as many as ten character strings that together establish the pattern
for evaluating the Jacobian matrix during the modified Newton-Raphson
iteration. For each iteration, T or TRUE indicates that Adams/Solver (C++)
evaluates the Jacobian and F or FALSE indicates that Adams/Solver (C++)
does not evaluate the Jacobian. Thus, cj determines whether or not
Adams/Solver (C++) evaluates the Jacobian at the jth iteration. If necessary,
Adams/Solver (C++) repeats the pattern of evaluations until it reaches the
maximum number of iterations (MAXIT). The number of Ts or TRUEs and
Fs or FALSEs together must be at least one and no more than ten.
Adams/Solver
C++Commands
42
STABILITY=r Specifies the fraction of the mass and damping matrices (subsets of the
equilibrium Jacobian matrix) Adams/Solver (C++) adds to the stiffness
matrix (a subset of the equilibrium Jacobian matrix) during static simulations
performed using static analyses. Adding a fraction of the mass and damping
matrices to the stiffness matrix can stabilize the iteration process and prevent
the iteration from diverging. Often the stiffness matrix is singular for a system
because the system is neutrally stable (for example, the system moves in
certain directions without affecting the potential energy). Adding a fraction of
the mass and damping matrices to the stiffness matrix removes this
singularity and makes it possible to solve for equilibrium positions. The value
of STABILITY does not affect the accuracy of the solution, but it does affect
the rate of convergence of the iteration process.>
Range: STABILITY >0
TLIMIT=r Specifies the maximum translational increment allowed per iteration.
Range: TLIMIT > 0
43 EQUILIBRIUM
C++Commands
METHOD=i Specifies the option which determines the static solver method to be used for
equilibrium solution.
1. ORIGINAL, for running only the ORIGINAL Solver
2. ADVANCED, runs, in order, the following methods until one shows
progress:
a. ORIGINAL
b. ORIGINAL+Krylov
c. ORIGINAL+UMF
d. Newton+Krylov
e. Tensor-Krylov block-3
f. Tensor-Krylov block-2+
3. AGGRESSIVE, runs, in order, the following methods until one
shows progress:
a. ORIGINAL
b. ORIGINAL+Krylov
c. ORIGINAL+UMF
d. Newton+Krylov
g. Broyden-Armijo
h. Trust-Region
4. ALL, runs, in order, all the available methods, until one shows
progress:
a. ORIGINAL
b. ORIGINAL+Krylov
c. ORIGINAL+UMF
d. Newton+Krylov
g. Broyden-Armijo
h. Trust-Region
i. Hooke-Jeeves
Default: ORIGINAL
Adams/Solver
C++Commands
44
Extended Definition
For an extended definition on the EQUILIBRIUM command and corresponding tips, cautions, and
examples, refer to the EQUILIBRIUM statement.
ATOL Specifies the absolute tolerance value
Default: 1.0e-6
Range: 0.0 < ATOL < 1.0
RTOL Specifies the relative tolerance value
For all solvers, except ORIGINAL and ORIGINAL+Krylov, the tolerance is
defined as : TOL=ATOL+| | x
I C
| | *RTOL.
For ORIGINAL and ORIGINAL+Krylov solvers the tolerance is equal to
ERROR.
Default: 0.0
Range: 0.0 < RTOL < 1.0
MAXITL Specifies the maximum number of allowed inner loops in all the solvers.
ORIGINAL, ORIGINAL+Krylov and ORIGINAL+UMF solver methods
ignore this parameter. For Hooke-Jeeves method, allowed budget of function
evaluations is set to MAXITL*N, where N is the size of the problem (number
of unknowns).
Default: 40
Range: > 0
ETAMAX Specifies the maximum threshold for the error tolerance of the linear Krylov
solver (for Newton+Krylov and Tensor-Krylov methods) that solves the
linear systems required by Krylov algorithm. Maximum error tolerance for
residual in inner iteration. The inner iteration terminates when the relative
linear residual is smaller than eta*| F(x_c) |. eta is determined by the modified
Eisenstat-Walker formula if etamax > 0. If etamax < 0, then eta = |etamax|
for the entire iteration.
Default: 0.9
Range: 0.0 < ETAMAX < 1.0
ETA Specifies the initial residual tolerance for the linear Krylov Solver for Tensor-
Krylov method. The Tensor-Krylov ETA parameter is maintained adaptively
by the Krylov algorithm but ETA is the indicated starting value, while
ETAMAX is the maximum threshold for ETA.
Default: 1.0e-4
Range: 0.0 < ETA < 1.0
Specifies the dimensionless radius of the trust-region for Trust-region
method. The smaller the value, the more the refinement of Trust-region
solution (hence more work).
Range: 0.0 < ETA < 0.25
45 FIELD
C++Commands
FIELD
The FIELD command redefines and/or lists the data for a FIELD statement. You cannot redefine the I and
the J markers, but you can redefine any other argument values.
Format

Adams/Solver
C++Commands
46
Arguments
CMATRIX=r1,...,r36 Respecifies the six-by-six matrix of viscous damping coefficients.
Enter the elements by columns from top to bottom, then from left to
right. The units for the translational and rotational components of
CMATRIX should be force-time per displacement unit and torque-
time per radian, respectively.
CRATIO=r Respecifies the ratio of CMATRIX to KMATRIX. Adams/Solver
(C++) multiplies KMATRIX by CRATIO to obtain CMATRIX.
FORCE=r1,...,r6 Respecifies three preload force components and three preload torque
components transferred by the FIELD element when the I and J
markers are separated/misaligned by the values specified in the
LENGTH argument. The terms r1,...,r6 are the force components
along the x-axis, the y-axis, and the z-axis of the J marker and the
torque components about the x-axis, the y-axis, and the z-axis of the
J marker, respectively. FORCE is optional.
FUNCTION=USER(r1[,...,r30]) Respecifies the USER parenthetical list for a nonlinear field. Follow
FUNCTION with an equal sign, the character string USER, and the
values (r1[,...,r30]) that you want Adams/Solver (C++) to pass to the
FIESUB user-written subroutine. The FUNCTION argument is
used, it must either be the last argument in the FIELD command or
be followed by a backslash (\).
KMATIX=r1,...r36 Respecifies the six-by-six matrix of stiffness coefficients. The units
for the translational and rotational components of KMATRIX should
be force per displacement unit and torque per radian, respectively.
Enter the elements by columns from top to bottom, then from left to
right.
LENGTH=r1,...r6 Respecifies six reference length angles. This is the nominal position
of the I marker with respect to the J marker, resolved in the J marker
coordinate system. The terms r1,...,r6 are the x, y, and z translational
components (specified in linear displacement units) of the
displacement between the I and J markers; and a, b, and c are
rotational displacement of the axes of the I marker with respect to the
J marker, resolved in the J marker axes (specified in radians). If the
reference force is zero, LENGTH is the same as the free length.
LIST Lists the current values of the data in the FIELD statement.
FIESUB.
Learn more about the ROUTINE Argument.
47 FIELD
C++Commands
Tip: Finite element analysis programs can give the values for CMATRIX and KMATRIX.
Caution: The three rotational displacements (a, b, and c) that define the field are not Euler
angles. They are the projected angles of the I marker with respect to the J marker.
Adams/Solver (C++) measures them about the x-, y-, and z-axis of the J marker.
For the constitutive equations to be accurate, at least two of the rotations (a, b, c)
must be small. That is, two of the three values must remain smaller than 10
degrees. In addition, if a becomes greater than 90 degrees, b becomes erratic. If b
becomes greater than 90 degrees, a becomes erratic. Only c can become greater
than 90 degrees without causing convergence problems. For these reasons, it is
best to define your field such that angles a and b (not a and c and not b and c)
remain small.
Adams/Solver (C++) applies the component translational and rotational forces for
a field to the I marker and imposes reaction forces on the J marker.
The FIELD command allows you to define all six-component, action-reaction
forces. However, when massless beams are being defined, you may want to use the
BEAM command. It requires only six input values to compute the thirty-six values
for the KMATRIX argument (see the BEAM statement).
The K and C matrices must be positive semidefinite. In other words:
x
t
K x > 0 for all non-zero displacements x, and
y
t
C y > 0 for all non-zero velocities y.
If this is not true, the stiffness matrix of the field may be removing energy from the
system. Similarly, the damping matrix may be adding energy to the system. Both
of these situations are uncommon. Adams/Solver (C++) does not warn you if the C
matrix, K matrix, or both are not positive semidefinite. While Adams/Solver
(C++) does not require that these matrices be symmetric, that is most realistic.
Adams/Solver
C++Commands
48
FILE
The FILE command loads a new model from a dataset file, or executes commands from a Command file.
Format
Arguments
COMMAND=c Specifies the file name of a file that contains Adams/Solver (C++) commands.
The file name may include the directory on operating systems that support path
names, such as UNIX. Adams/Solver (C++) assumes an .acf file extension if
you do not specify one. Because the COMMAND argument and value can be
at most eighty characters long, the file name and path name are limited from
seventy-two characters (if you do not abbreviate COMMAND=) to seventy-six
characters (if you abbreviate COMMAND= to COM=).
Range: All printable characters except !, ;, , and &
MODEL=c Specifies the file name of an Adams/Solver (C++) model definition file.
names, such as UNIX. Adams/Solver (C++) assumes an .adm file extension if
you do not specify one. Because the argument and value can be at most eighty
characters long, the file name and path are limited from seventy-three
characters (if you do not abbreviate MODEL=) to seventy-six characters (if
you abbreviate MODEL= to MOD=).
OUTPUT_PREFIX=c Optionally, specifies a new file base name for output files that Adams/Solver
(C++) generates by subsequent simulations. The file extensions conform to
standard Adams/Solver (C++) naming conventions. If you do not specify an
OUTPUT_PREFIX argument, Adams/Solver (C++) defaults to the basename
of the MODEL argument. Because the OUTPUT_PREFIX argument and value
can be at most eighty characters long, the basename and path are limited from
sixty-six characters (if you do not abbreviate OUTPUT_PREFIX) to seventy-
six characters (if you abbreviate OUTPUT_PREFIX to OUT=).
49 FILE
C++Commands
Extended Definition
The FILE command either restarts Adams/Solver (C++) with a new model, or a executes a set of
commands from a file.
The MODEL argument specifies a new dataset (.adm) file. Adams/Solver (C++) closes any output files
from a previous simulation, and then completely restarts by setting the simulation time to zero and
reading the new model. Next, Adams/Solver (C++) prompts you for a new command, just as if
Adams/Solver (C++) had read the model when first started. By default, the output files use the same base
name as the model file. The optional OUTPUT_PREFIX argument specifies a different base name, if
needed. An OUTPUT_PREFIX argument only changes the names of the output files (files with .res, .req,
and .gra extensions). A message file with a new name is not created. Every message from a single
Adams/Solver (C++) session is logged in the same message file.
The COMMAND argument specifies a file containing Adams/Solver (C++) commands. Adams/Solver
(C++) reads and executes the commands in the file. If the FILE command was interactive, Adams/Solver
(C++) returns to interactive input when the command file is exhausted. If the FILE command was in a
command file itself, Adams/Solver (C++) returns to reading commands from that file. Command files
can contain other FILE commands.
Examples
FI LE/ MODEL=TURN45
This FILE command loads dataset TURN45.ADM. The output files default to TURN45.REQ,
TURN45.GRA, etc.
FI LE/ MODEL=TURN45, OUTPUT_PREFI X=TEST2
This FILE command also loads dataset TURN45.ADM, but the output files are TEST2.REQ,
TEST2.GRA, etc.
Tip: The FILE/MODEL= command allows you to execute a series of simulations
within one Adams/Solver (C++) run. This may be quicker and more convenient
than invoking Adams/Solver (C++) separately for each simulation.
Although the FILE command may be used to repeatedly reload the same model,
the SAVE and RELOAD combination is much quicker than rereading the original
dataset.
Caution: The COMMAND argument does not automatically load a new model, it executes
commands just as they appear in the specified file. Unlike a Command file used to
start Adams/Solver (C++), a Command file read here must start with an
Adams/Solver (C++) command, not input and output file names.
Since Adams/Solver (C++) does not support TIRE 5.2.1, the TIRE_LIST_FILE is
not supported.
Adams/Solver
C++Commands
50
51 FLEX_BODY
C++Commands
FLEX_BODY
The FLEX_BODY command redefines and/or lists the data for the FLEX_BODY statement that defines
linear elastic body.
Format

Arguments
See other bordered available.
Redefines modal damping as a fraction of critical damping. You
can specify modal damping using a function expression or a user-
written subroutine. To define the modal damping with an
expression, follow CRATIO with an equal sign and the expression.
The FXFREQ and FXMODE function expression may be useful
here.
To define modal damping with a user-written subroutine, follow
CRATIO with an equal sign, the character string USER, and the
values (r1,[,...,r30] that the Adams/Solver (C++) is to pass to the
DMPSUB user-written subroutine. If the CRATIO argument is
used, it must either be the last argument in the FLEX_BODY
statement, or be followed by a backslash (\).
LIST Lists the current values of the FLEX_BODY arguments.
Adams/Solver
C++Commands
52
FRICTION
The FRICTION command defines parameters that enable joint friction forces on translational, revolute,
cylindrical, hooke, universal, and spherical joints.
Format
Note: Frictional forces and torques are computed by Adams/Solver (C++) using a friction model
that supports dynamic frictions and stiction.
53 FRICTION
C++Commands
Arguments
BALL_RADIUS=R
b
Defines the radius of the ball in a spherical joint for use in friction-force and
torque calculations.
Range: BALL_RADIUS > 0
STICTION_TRANSITION_VEL
OCITY=r
Defines the absolute velocity threshold for the transition from dynamic friction
to static friction. If the absolute relative velocity of the joint marker is below
STICTION_TRANSITION_VELOCITY, then static friction or stiction acts to
make the joint stick.
Range: STICTION_TRANSITION_VELOCITY > 0
EFFECT={ALL[[STICTION,
SLIDING]]}
Defines the frictional effects included in the friction model. Stiction is static-
friction effect, while sliding is dynamic-friction effect. Excluding stiction in
simulations that dont require it can greatly improve simulation speed.
FRICTION_FORCE_PRELOAD=
r
Defines the joints preload frictional force, which is usually caused by
mechanical interference in the assembly of the joint.
Range: FRICTION_FORCE_PRELOAD > 0
FRICTION_ARM=R
n
, Defines the effective moment arm used to compute the axial component of the
friction torque in revolute, Hooke, and universal joints.
Range: FRICTION_ARM > 0
INACTIVE=STATIC Specifies that frictional forces not be calculated for a static or quasi-static
solution.
Range: STATIC
INITIAL_OVERLAP=X
s0
Defines the initial overlap of the sliding parts in either a translational or
cylindrical joint. The joint's bending moment is divided by overlap to compute
the bending moment's contribution to frictional forces.
Range: INITIAL_OVERLAP > 0
INPUTS=( {ALL, NONE
[[PRELOAD:
REACTION_FORCE:
BENDING_MOMENT:
TORSIONAL_MOMENT]]} )
Defines the input forces to the friction model. By default, all user-defined
preloads and joint-reaction force and moments are included. You can
customize the friction-force model by limiting the input forces you list in the
statement.
Joint type: (Available inputs:)
Translational (PRELOAD, REACTION_FORCE, BENDING_MOMENT,
TORSIONAL_MOMENT)
Cylindrical, Revolute, Universal, Hooke (PRELOAD,
REACTION_FORCE, BENDING_MOMENT)
Spherical (PRELOAD, REACTION_FORCE)
Adams/Solver
C++Commands
54
JOINT=id Identifies the JOINT to which frictional forces apply.
MAX_STICTION_DEFORMATI
ON=r
Defines the maximum creep that can occur in a joint during the stiction regime.
The creep allows Adams/Solver (C++) to impose the Coulomb conditions for
stiction or static friction, for example:
Friction force magnitude < static * normal force
Therefore, even at zero velocity, a finite stiction force is applied if your system
dynamics requires it.
Range: MAX_STICTION_DEFORMATION > 0
MU_DYNAMIC=r Defines the coefficient of dynamic friction during the sliding regime. The
magnitude of the frictional force is the product of MU_DYN and the
magnitude of the normal force in the joint, for example:
Friction force magnitude, F = N
where = MU_DYNAMIC and N = normal force
The dynamic frictional force acts in the opposite direction of the velocity of the
joint.
Range: MU_DYNAMIC > 0
LIST Lists the current values of the FRICTION statement.
MU_STATIC=r Defines the coefficient of static friction in the joint. The magnitude of the
frictional force is the product of a function of MU_STATIC, MU_DYNAMIC,
and the creep, times the magnitude of the normal force in the joint, for
example:
Friction Force Magnitude, F = N
where = (MU_STATIC, MU_DYNAMIC, creep) and N = normal force
The static frictional force acts to oppose the net force or torque along the
degrees of freedom of the joint.
Range: MU_STATIC > 0
55 FRICTION
C++Commands
Extended Defintion
For an extended definition on the statement associated with this command, see the FRICTION statement.
Examples
FRI CTI ON/ 102, I NPUTS=NONE
This command turns off the friction calculations of FRICTION/102.
OVERLAP_DELTA={INCREAS
E, DECREASE, CONSTANT}
To define friction in a sliding joint (either a translational or a cylindrical joint),
Adams/Solver (C++) computes the overlap of the joint. As the joint slides, the
overlap can increase, decrease, or remain constant. OVERLAP_DELTA is
used to define any change in overlap.
INCREASE indicates that overlap increases as the I Marker translates in
the positive direction along the J Marker; the slider moves to be within the
joint.
DECREASE indicates that the overlap decreases with positive translation
of the joint; the slider moves outside of the joint.
CONSTANT indicates that the amount of overlap does not change as the
joint slides; all of the slider remains within the joint.
PIN_RADIUS=R
p
Defines the radius of the pin for a revolute, cylindrical, Hooke, or universal
joint.
Range: PIN_RADIUS > 0
REACTION_ARM=R
n
Defines the effective moment arm of the joint-reaction torque about the
translational joints axial axis (the z-direction of the joints J marker). This
value is used to compute the contribution of the torsional moment to the net
frictional force.
Range: REACTION_ARM > 0
FRICTION_TORQUE_PRELOA
D=r
Defines the preload friction torque in the joint, which is usually caused by
mechanical interference in the assembly of the joint.
Range: FRICTION_TORQUE_PRELOAD > 0
I_YOKE
J_YOKE
I_YOKE and J_YOKE define the rotational constraint on which the
FRICTION statement acts. I_YOKE identifies the yoke to the I markers
rotational constraint. Likewise, J_YOKE identifies the yoke to the J markers
rotational constraint. These keywords are used with only Hooke and
UNIVERSAL joints.
Caution: You cannot apply friction to JOINTs that connect to FLEX-BODYs or POINT_MASSes.
Adams/Solver
C++Commands
56
57 GCON
C++Commands
GCON
The GCON (general constraint) command lists all the data for a GCON statement.
Format
GCON/id [,LIST]
Arguments
Examples
GCON/10, LIST
This GCON command lists all the data for GCON 10.
See other Constraints available.
LIST Lists the current values of the data in the GCON statement.
Adams/Solver
C++Commands
58
GFORCE
The GFORCE command redefines and/or list the data for a GFORCE statement that defines a force
element that consists of three orthogonal translational force components and three orthogonal torque
components.
Format

Arguments
FUNCTION=USER(r1[,...,r30]) Respecifies up to thirty user-defined constants to compute the force
components in a user-defined subroutine GFOSUB.
FX=e Respecifies the magnitude and sign of the x component of the
GFORCE translational force. Adams/Solver (C++) applies this force
parallel to the x-axis of the RM marker.
FY=e Respecifies the magnitude and sign of the y component of the
parallel to the y-axis of the RM marker.
FZ=e Respecifies the magnitude and sign of the z component of the
parallel to the z-axis of the RM marker.
59 GFORCE
C++Commands
Extended Definition
The GFORCE command lists or redefines a force element that consists of three mutually orthogonal
translational force components and three orthogonal torque components. You can alter one or both points
of force and torque application, change the force reference marker, and change the force and torque
function expressions or the parameters passed to the GFOSUB user-written subroutine.
I=id Respecifies the marker at which Adams/Solver (C++) applies the
forces and torques. You must ensure that the I marker is a fixed
marker and on a different part than the JFLOAT marker. Because I is
a fixed marker, Adams/Solver (C++) always applies the force at a
fixed point on the part containing the I marker.
JFLOAT=id Respecifies the marker at which Adams/Solver (C++) applies the
reaction forces and torques. You must ensure that the JFLOAT
marker is a floating marker and on a different part than the I marker.
Adams/Solver (C++) moves the JFLOAT marker to keep it
superimposed on the I marker, meaning the point of application of
the reaction force may move with respect to its part. Adams/Solver
(C++) does not calculate reaction forces when the JFLOAT marker is
on the ground part.
LIST Lists the current values of the GFORCE arguments.
RM=id Respecifies the marker and therefore the coordinate system in which
the force and torque components are specified. You must ensure that
RM is a fixed marker. RM may be the same as I and may be fixed on
any part in your system.
GFOSUB.
TX=e Respecifies the magnitude and sign of the x component of the
GFORCE rotational torque. Adams/Solver (C++) applies this torque
parallel to the x-axis of the RM marker in the sense of the right-hand
rule (that is, a positive torque causes a counterclockwise rotation).
TY=e Respecifies the magnitude and sign of the y component of the
parallel to the y-axis of the RM marker in the sense of the right-hand
TZ=e Respecifies the magnitude and sign of the z component of the
parallel to the z-axis of the RM marker in the sense of the right-hand
Adams/Solver
C++Commands
60
After a change to a GFORCE, Adams/Solver (C++) reprocesses the model at the next SIMULATE
While checking, Adams/Solver (C++) verifies that the model is still valid with the new GFORCE. If, for
example, the GFORCE function expression refers to an inactive element, Adams/Solver (C++) issues an
error.
the first simulation, Adams/Solver begins with the positions and velocities specified in the dataset. If you
ran a previous simulation, Adams/Solver begins with the final displacements and velocities.
constraints. If this is the first simulation, Adams/Solver (C++) also maintains any user supplied joint
initial-conditions and positions specified as EXACT.
Examples
GFORCE/ 1, I =8, J FLOAT=6, RM=7, LI ST, &
FY = 0/ &
FZ = 0/ &
TY = 0/ &
TZ = 0
This GFORCE command redefines and lists the general, six-component force acting between fixed
Marker 310 and floating Marker 9910. The force and torque components FY, FZ, TY, and TZ are set to
zero along the y and z axes of the reference marker, which is Marker 310. Adams/Solver (C++)
superimposes floating Marker 9910 on Marker 310 and applies the FX and TX reaction force and torque
at that point.
Tip: Depending on the nature of the desired force relationship, the RM marker may belong to
the same part as the I marker or the JFLOAT marker, or to a third, unrelated part.
Caution: The user-defined functions FX, FY, FZ, TX, TY, and TZ should be smooth, continuous, and
single-valued. These conditions make the solution process very effective.
61 HELP
C++Commands
HELP
The HELP command opens the online help for Adams/Solver.
To navigate through the help:
Select a topic from the left.
See other Information available.
Adams/Solver
C++Commands
62
IC
The IC command redefines and/or lists the data for an IC statement. If you issue neither the IC command
nor statement in an Adams/Solver (C++) session, Adams/Solver (C++) uses the default values for
AERROR, ALIMIT, AMAXIT, APATTERN, ERROR, MAXIT, PATTERN, TLIMIT, and VERROR
when finding initial conditions.
Format

63 IC
C++Commands
Arguments
AERROR=r Respecifies the maximum acceleration error Adams/Solver (C++) is to
allow during an initial conditions solution or for reconciling INTEGRATOR
acceleration output.
Range: AERROR > 0
ALIMIT=r Respecifies the maximum angular increment Adams/Solver (C++) is to
allow while testing trial solutions for a set of consistent initial conditions
that satisfy all system constraints. The default units for ALIMIT are radians.
To specify ALIMIT in degrees, add a D after the value.
Range: ALIMIT > 0
AMAXIT=i Respecifies the maximum number of iterations Adams/Solver (C++) is to
allow for finding accelerations during an initial conditions solution or for
reconciling INTEGRATOR acceleration output.
Range: AMAXIT > 0
APATTERN=c1[:...:c10] Respecifies as many as ten character strings that together establish the
pattern for evaluating the Jacobian matrix during the modified Newton-
Raphson solution for the accelerations. For each iteration, T or TRUE
indicates that Adams/Solver (C++) is to evaluate the Jacobian, and F or
FALSE indicates that Adams/Solver (C++) is not to evaluate the Jacobian.
Thus, c
j
determines whether or not ADAMS is to evaluate the Jacobian at
the j
th
iteration. If necessary, Adams/Solver (C++) repeats the pattern of
evaluation until it reaches the maximum number of iterations (AMAXIT).
The number of T's or TRUEs and Fs or FALSEs together must be at least
one and no more than 10.
DEFAULT Resets all options to the default values specified in the IC statement,
namely:
AERROR = 1.0E-4
ALIMIT = 30D
AMAXIT = 25
APATTERN = T:T:T:T:T:T:T:T:T:T
ERROR = 1.0E-10
MAXIT = 25
PATTERN = T:T:T:T:T:T:T:T:T:T
TLIMIT = 1.0E10
VERROR = 1.0E-4
ERROR Respecifies the maximum displacement error Adams/Solver (C++) is to
allow for the assembly process.
Range: ERROR > 0
Adams/Solver
C++Commands
64
LIST Lists the current values of the data in the IC statement.
MAXIT=i Specifies the maximum number of iterations Adams/Solver (C++) is to
allow for finding displacements during initial conditions, or when
reconciling the position of configuration during integration (interpolate on,
or with the WSTIFF integrator), and static analysis.
Range: MAXIT > 0
PATTERN=c1[:...:c10] Respecifies as many as ten character strings that together establish the
Raphson solution for the displacements. For each iteration, T or TRUE
Thus, c
j
determines whether or not the solver is to evaluate the Jacobian at
the j
th
iteration. If necessary, Adams/Solver (C++) repeats the pattern of
evaluation until it reaches the maximum number of iterations (MAXIT).
The number of Ts or TRUEs and Fs or FALSEs together must be at least
one and no more than 10.
TLIMIT=r Respecifies the maximum translational increment Adams/Solver (C++) is to
allow while testing trial solutions during a solution step.
Range: TLIMIT > 0
VERROR=r Respecifies the maximum velocity error that Adams/Solver (C++) is to
ignore during an initial conditions solution. If the value of VERROR is
exceeded, Adams/Solver (C++) issues a warning. If
PREFERENCES/SIMFAIL=STOPCF is chosen, Adams/Solver (C++)
issues an error.
Range: VERROR > 0
Tip: Use the ALIMIT and TLIMIT arguments to limit the increments of the displacement
variables if Adams/Solver (C++) fails to converge to a solution or converges to an
undesirable configuration. This lessens the position change on successive iterations, and
tends to keep the solution closer to the initial configuration.
65 INFO
C++Commands
INFO
The INFO command lists the vector components for the displacement, velocity, or acceleration of one
marker with respect to another or displays force values at the current simulation time. This command
resolves components in the ground coordinate system (GCS) or in another specified reference frame.
Format

Arguments
ACCELERATION Lists the accelerations of the I marker minus the accelerations of the J marker.
Adams/Solver (C++) reports translational accelerations in units of displacement
per time squared and rotational accelerations in units of radians per time squared.
DISPLACEMENT Lists the x, y, z, psi, theta, and phi displacements of the I marker with respect to
the J marker. Adams/Solver (C++) reports translational displacements in units of
displacement and rotational displacements in units of radians.
FORCE Lists the components for the force at the I marker. A BEAM, BUSHING, CVCV,
FIELD, GFORCE, JOINT, JPRIM, MOTION, NFORCE, PTCV, SFORCE,
SPRINGDAMPER, VFORCE, or VTORQUE statement can define the force.
You should include both the I and the J arguments to measure the action-reaction
force(s) between two markers (I, J). You should include the I argument and either
give zero as the J argument or omit the J argument altogether to measure the
action-only force(s) at a marker (I).
I=id Specifies the identifier of the fixed or floating marker for which Adams/Solver
(C++) is to measure displacements, velocities, accelerations, or action forces.
J=id Specifies the identifier of the fixed or floating marker with respect to which
Adams/Solver (C++) is to measure the displacements, velocities, or accelerations
of the I marker, or the identifier of the marker for which Adams/Solver (C++) is
to measure reaction forces.
Adams/Solver
C++Commands
66
Examples
INFO/ DISP, I=10, J=15, RM=43
This INFO command lists the x, y, z, psi, theta, and phi displacements of Marker 10 with respect to
Marker 15. Adams/Solver (C++) measures x, y, and z in the Cartesian coordinates of Marker 43.
INFO/ ACC, I=12, J=100
This INFO command lists the x, y, and z translational and rotational accelerations of Marker 12 with
respect to Marker 100. Adams/Solver (C++) measures x, y, and z in the Cartesian coordinates of the
ground coordinate system (GCS).
RM=id Specifies the identifier of the fixed or floating marker relative to which
Adams/Solver (C++) resolves displacements, velocities, accelerations, or forces.
If a value for the RM argument is not set or if the RM argument is set equal to
zero, Adams/Solver (C++) resolves the displacements, velocities, accelerations,
or forces in the ground coordinate system (GCS).
VELOCITY Lists the velocities of the I marker minus the velocities of the J marker.
Translational velocities are given in units of displacement per time. Rotational
displacements are given in units of radians per time.
67 INTEGRATOR
C++Commands
INTEGRATOR
The INTEGRATOR command lets you redefine data in the INTEGRATOR statement.
Format
Adams/Solver
C++Commands
68
Arguments
ALPHA = r Defining coefficient for the HHT method.
Default value: -0.3
Range: -0.3 < ALPHA < 0
BETA = r One of the two defining coefficients associated with the Newmark
method.
Default Value: 0.36
Range: Defined in conjunction with GAMMA. Together they must
satisfy the stability condition.
Specifies the corrector algorithm used with the stiff integrators GSTIFF
or WSTIFF. The corrector in a stiff integrator ensures that all candidate
solutions satisfy the equations of the system. The two algorithms,
original and modified, differ primarily in how they assess when the
corrector iterations have converged.
CORRECTOR=original - Specifies the corrector available in
the previous releases of Adams/Solver. This is the default. This
implementation of the corrector requires that at convergence,
the error in all solution variables be less than the corrector error
tolerance.
CORRECTOR=modified - Specifies a modified corrector.
This implementation of the corrector requires that at
convergence, the error in only those variables for which
integration error is being monitored, be less than the corrector
error tolerance. Because this is a slightly looser definition of
convergence, use proper care when using this option.
The CORRECTOR=modified setting is helpful for models
containing discontinuities in the forcing functions. Problems
with contacts belong in this category.
For additional information, see the Extended Definition in the
INTEGRATOR statement.
|

1
2
--- +
\ .
| |
2
4
-------------------- >
CORRECTOR
original
modified
)
`

=
69 INTEGRATOR
C++Commands
DEFAULT Resets the integrator parameters to the default values specified in the
INTEGRATOR statement, namely:
GSTI FF, I 3
CORRECTOR = or i gi nal
ERROR = 1. 0E- 3
HI NI T = 1/ 20 of t he out put st ep
HMAX = t he out put st ep
HMI N = 1. 0E- 6*HMAX
I NTERPOLATE = OFF
MAXI T = 10
KMAX = 6
PATTERN = T: F: F: F: T: F: F: F: T: F
ERROR=r Specifies the relative and absolute local integration error tolerances that
the integrator must satisfy at each step. For BDF integrators,
Adams/Solver (C++) monitors the integration errors in the
displacement and state variables that the other differential equations
(DIFFs, LSEs, GSEs, and TFSISOs) define. The larger the ERROR, the
greater the error/step in your solution.
Note that the value for ERROR is units-sensitive. For example, if a
system is modeled in mm-kg-s units, the units of length must be in mm.
Assuming that all the translational states are larger than 1mm, setting
ERROR=1E-3 implies that the integrator monitors all changes of the
order of 1 micron.
The error tolerances (e) are enforced as:
||Y
c
- Y|| < MAX (e,e * ||Y||)
where Y
c
is the column matrix of computed values for the unknowns,
Y. The symbol || || indicates the root-mean-square of the array of
numbers.
Range: ERROR > 0
GAMMA One of the two (together with BETA) defining coefficients associated
with the Newmark method.
Default value: 0.7
Range: Defined in conjunction with BETA. Together they must satisfy
the stability condition.
|

1
2
--- +
\ .
| |
2
4
-------------------- >
Adams/Solver
C++Commands
70
GSTIFF Specifies that the GSTIFF (Gear) integrator is to be used for integrating
the differential equations of motion.
HHT Specifies that the HHT (Hilber-Hughes-Taylor) integrator is used for
integrating the equations of motion.
HINIT=r Defines the initial time step that the integrator attempts.
Range: 0 < HMIN < HINIT < HMAX
HMAX=r Defines the maximum time step that the integrator is allowed to take.
Default: When setting the argument INTERPOLATE = ON, the
integration step size is limited to the value specified for HMAX, but if
HMAX is not defined, no limit is placed on the integration step size. If
INTERPOLATE = OFF, the maximum step size is limited to the output
step.
HMIN=r Defines the minimum time step that the integrator is allowed to take.
Default:
1.0E-6*HMAX for GSTIFF, WSTIFF, and I3
Machine precision for GSTIFF, WSTIFF, SI2, and for HHT and
Newmark
INTERPOLATE=ON specifies that the integrator is not required to
control its step size to hit an output point. Therefore, when the integrator
crosses an output point, it computes a preliminary solution by
interpolating to the output point. It then refines or reconciles the
solution to satisfy the equations of motion and constraint.
INTERPOLATE=OFF turns off interpolation for the chosen integrator.
Note: When using INTERPOLATE with models containing
CONTACT, you may see intermediate data at intervals that
do not coincide with your specified output interval. This
intermediate data (the data in-between the interpolated
outputs) actually corresponds to contact incidences. You can
turn off these extra contact data points with an environment
variable, MDI_ADAMS_CONTACT_OUT.
I3 Specifies the Index-3 (I3) formulation be used. Default for
GSTIFF/WSTIFF/HHT.
For additional information, see the Extended Definition in the
INTEGRATOR statement.
INTERPOLATE
ON
OFF
)
`

=
71 INTEGRATOR
C++Commands
KMAX=i Indicates the maximum order that the integrator can use. The order of
integration refers to the order of the polynomials used in the solution.
The integrator controls the order of the integration and step size, and
therefore, controls the local integration error at each step so that it is less
than the error tolerance specified.
Note: For problems involving discontinuities, such as contacts,
setting KMAX=2 can improve the speed of the solution.
However, we do not recommend that you set the KMAX
parameter unless you are a very experienced user. Any
modification can adversely affect the integrators accuracy
and robustness.
Range: 1 < KMAX < 6
LIST Lists current values of the integrator arguments.
MAXIT=i Specifies the maximum number of iterations allowed for the Newton-
Raphson iterations to converge to the solution of the nonlinear
equations. The corrector uses Newton-Raphson iterations.
MAXIT should not be set larger than 10. This is because round-off
errors increase when a large number of iterations are taken. This can
cause an error in the solution.
Range: MAXIT > 0
NEWMARK Specifies that the NEWMARK integrator be used for integrating the
equations of motion.
PATTERN=c1[:...:c10] Indicates the pattern of trues and falses for re-evaluating the Jacobian
matrix for Newton-Raphson. A value of true (T) indicates that
Adams/Solver (C++) is evaluating a new Jacobian matrix for that
iteration. A value of false (F) indicates that Adams/Solver (C++) is
using the previously calculated Jacobian matrix as an approximation of
the current one.
Note: PATTERN accepts a sequence of at least 1 character string
and not more than 10 character strings. Each string must be
either TRUE or FALSE, which you can abbreviate with T or
F. You must separate the strings with colons.: A pattern
setting of all false, implies that Adams/Solver (C++) is not to
evaluate the Jacobian until it encounters a corrector failure.
For problems that are linear or almost linear, this setting can
improve simulation speed substantially.
Adams/Solver
C++Commands
72
SI2 Specifies that the Stabilized Index-2 (SI2) formulation, in conjunction
with the GSTIFF, WSTIFF, or HASTIFF integrators, be used for
formulating and integrating differential equations of motion.
The SI2 formulation takes into account constraint derivatives when
numerically solving the equations of motion. This process enables the
integrator to monitor the integration error of velocity variables, and,
therefore, renders highly accurate simulations. A positive side effect of
the SI2 formulation is that the Jacobian matrix remains stable at small
step sizes, which increases the stability and robustness of the corrector
at small step sizes.
The SI2 formulation is available only with GSTIFF, WSTIFF, and
HASTIFF.
WSTIFF Specifies that the WSTIFF (Wielenga stiff) integrator be used for
integrating the differential equations of motion. WSTIFF uses the BDF
method that takes step sizes into account when calculating the
coefficients for any particular integration order.
HASTIFF Specify that the HASTIFF (Hiller Anantharaman stiff) integrator be
used for integrating the differential equations of motion.HASTIFF uses
the BDF method that takes step sizes into account when calculating the
coefficients for any particular integration order.
SI1 Specifies that the Stabilized Index-1 (SI1) formulation, in conjunction
with the HASTIFF integrator, be used for formulating and integrating
differential equations of motion.
The SI1 formulation takes into account constraint derivatives when
solving for equations of motion. This process enables the HASTIFF
integrator to monitor the integration error of velocity variables, and
therefore renders highly accurate simulations. A positive side effect of
the SI1 formulation is that the Jacobian matrix remains stable at small
step sizes, which increases the stability and robustness of the corrector
at small step sizes.
The SI1 formulation is available only with HASTIFF, for which it is the
default.
73 INTEGRATOR
C++Commands
Extended Definition
For a detailed definition, cautions, tips, and more, see the Extended Defintion in the INTEGRATOR
statement.
Examples
INTEGRATOR/SI2,GSTIFF, ERROR=1.0E-4, HINIT=1.0E-6, LIST
This command specifies a dynamic simulation using the SI2 equation formulation combined
with the GSTIFF integrator.
The integrator has an error limit of 1.0E-4 and overrides the default value of 1.0E-3.
HINIT =1.0E-6 specifies an initial timestep of 1.0E-6, which overrides the default of 1/20th
of the output step.
LIST prints all current settings of the INTEGRATOR to the screen and message file.
INTEGRATOR/HHT, ERROR=5.0E-6, PATTERN=F, HMAX=1e-3
This integrator statement specifies that dynamic simulations be run using the HHT integrator
with the adaptive jacobian pattern.
This solution has an error limit of 5.0E-6.
The maximum step size the integrator is to take is 1.0E-3.
Caution: The INTEGRATOR command is not equivalent to the INTEGRATOR statement. The
statement lets you specify explicitly or implicitly the collection of attributes that define the
integration formula used and the integration parameters. The command allows you to
adjust some of these settings. Therefore, if no INTEGRATOR statement is present in the
.adm file and later an INTEGRATOR command sets the INTEGRATOR to be HHT, the
ERROR setting will be 1.E-3 rather than the HHT default of ERROR=1.E-5. This is
because the integrator GSTIFF was considered the default, along with its default
ERROR=1.E-3 in the .adm file. Changing the integrator from GSTIFF to HHT does not
change the value of ERROR. The correct command to make HHT work with its default
value ERROR=1.E-5 is either INTEGRATOR/HHT, DEFAULT, or
INTEGRATOR/HHT, ERROR=1.E-5.
The INTEGRATOR command changes one attribute at a time, and this operation has no
side effect, such as implicitly changing other attributes that have been explicitly or
implicitly defined through the INTEGRATOR statement.
Adams/Solver
C++Commands
74
JOINT
The JOINT command lists all the data for a J OINT statement.
Format
JOINT/id [,LIST]
Arguments
Examples
J OI NT/ 10, LI ST
This JOINT command lists all the data for Joint 10.
LIST Lists the current values of the data in the JOINT statement.
75 KINEMATICS
C++Commands
KINEMATICS
The KINEMATICS command redefines and/or lists the data for a KINEMATICS statement. If you issue
neither the KINEMATICS command nor statement in an Adams/Solver (C++) session, Adams/Solver
(C++) uses the default values for AERROR, ALIMIT, AMAXIT, APATTERN, ERROR, MAXIT,
PATTERN, and TLIMIT when performing a kinematic analysis.
Format
Adams/Solver
C++Commands
76
Arguments
AERROR=r Respecifies the maximum acceleration error Adams/Solver (C++) is to
allow for each time step.
Range: AERROR > 0
ALIMIT=r Respecifies the maximum angular increment Adams/Solver (C++) is to
allow per iteration. The default units for ALIMIT are radians. To specify
ALIMIT in degrees, add a D after the value.
Range: ALIMIT > 0
AMAXIT=i Respecifies the maximum number of iterations Adams/Solver (C++) is to
allow for finding accelerations at a point in time.
Range: AMAXIT > 0
APATTERN=c1[:...:c10] Respecifies as many as ten character strings that together establish the
Raphson solution for the accelerations. For each iteration, T or TRUE
Thus, cj determines whether or not Adams/Solver (C++) is to evaluate the
Jacobian at the j
th
iteration. If necessary, Adams/Solver (C++) repeats the
pattern of evaluations until it reaches the maximum number of iterations
(AMAXIT). The number of Ts or TRUEs and Fs or FALSEs together
must be at least one and no more than 10.
DEFAULT Resets the kinematic analysis simulation parameters to their default
settings, namely:
AERROR=1. 0E- 4
ALI MI T=30D
AMAXI T=25
APATTERN=T: T: T: T: T: T: T: T: T: T, ( eval uat e t he
accel er at i on J acobi an at ever y i t er at i on)
ERROR=1. 0E- 4
MAXI T=25
PATTERN=T: T: T: T: T: T: T: T: T: T, ( eval uat e t he
posi t i on J acobi an at ever y i t er at i on)
TLI MI T=1. 0E10 ( no l i mi t )
ERROR=r Respecifies the maximum displacement error Adams/Solver (C++) is to
allow for each time step.
Range: ERROR > 0
77 KINEMATICS
C++Commands
HMAX=r Defines the maximum time step that the KINEMATICS solution is allowed
to take.
When performing kinematic simulations on systems with parts that are
rotating at very high speeds (at or more than one revolution per time step),
it is possible for the kinematic to fail or provide inaccurate results because
of lack of information on the system between output step solutions. The
HMAX value can be used to limit the time between solution steps without
having to specify a large number of output steps.
LIST Lists the current values of the data in the KINEMATICS statement.
MAXIT=i Respecifies the maximum number of iterations Adams/Solver (C++) is to
allow for finding the displacements at a point in time.
Range: MAXIT > 0
PATTERN=c1[:...:c10] Respecifies as many as ten character strings that together establish the
Raphson solution for the displacements. For each iteration, T or TRUE
indicates that Adams/Solver (C++) is to evaluate the Jacobian and F or
Thus cj determines whether or not Adams/Solver (C++) is to evaluate the
Jacobian at the j
th
iteration. If necessary, Adams/Solver (C++) repeats the
pattern of evaluations until it reaches the maximum number of iterations
(MAXIT). The number of Ts or TRUEs and Fs or FALSEs together must
be at least one and no more than ten.
TLIMIT=r Respecifies the maximum translational increment Adams/Solver (C++) is to
allow per iteration.
Range: TLIMIT > 0
Tip: Using the PATTERN argument to request less frequent evaluations of the Jacobian
matrix may decrease the computation time, thereby decreasing the cost and
improving the response time. However, it could also have the opposite effect since
more iterations may be required to reach the solution with a stale Jacobian matrix.
Use the ALIMIT and TLIMIT arguments to limit the increments of the
displacement variables if Adams/Solver (C++) fails to converge to a solution or
converges to an undesirable configuration. This lessens the position change on
successive iterations, and tends to keep the solution closer to the previous
configuration.
Adams/Solver
C++Commands
78
LINEAR
The LINEAR command is divided into the following sections:
General
Definition
Format
Arguments
Extended Definition
Eigensolutions
Scope
Using the RM option
Using the PSTATE option
Using both the RM and PSTATE options
Coordinates, Kinetic, Dissipative and Strain options
State matrices and MKB computation
Scope
Using the RM and PSTATE options
Plant inputs and Plant outputs
MATRIXX format
MATLAB format
Contents of the STATES matrix
Contents of the PINPUT and POUTPUT matrices
Nastran bulk data deck export
Scope
Limitations
BLACKBOX and WHITEBOX exported cards
Configuration file syntax
Configuration file examples
Theoretical background
Note: The LINEAR/EXPORT option is available only with an Adams MD license.
79 LINEAR
C++Commands
Examples
Applications
Eigen analysis application
State matrices output
Appendix
1. General
You can use the LINEAR command to linearize Adams models. Linearized Adams models can be
represented by complex valued eigendata (eigenvalues, mode shapes) or by a state-space representation
in the form of real-valued state matrices. Two state-space representations are possible, the ABCD
standard representation and the MKB Nastran representation. Moreover, the LINEAR command can be
used to export the linearized Adams model into an equivalent Nastran bulk data deck.
Adams/Solver (C++) uses a state-of-the-art condensation scheme to reduce an Adams model to a
minimal linear form for efficient solution. (For more information, see On an approach for the
linearization of the Differential Algebraic Equations of Multi-body Dynamic, D. Negrut and J. L. Ortiz.
Fifth ASME International Conference on Multibody Systems, Nonlinear Dynamics and Control, ASME
2005.)
The LINEAR command has four main options designed to provide important insight into the dynamic
behavior of the model. For instance, the LINEAR/EIGENSOL option can be used to assess the stability
of the model. Stability properties of the model have a direct relationship to the real part of the complex
eigenvalues. Eigenvalues with positive real parts represent unstable modes of the system, while those
with negative real parts represent stable modes. If bounded inputs to the system cause excitation of an
unstable mode, the system produces an unbounded response. On the other hand, bounded excitation of a
stable mode results in a bounded response. Eigenvalues computed by Adams/Solver (C++) can be plotted
on a real-imaginary plot and the mode shapes can be animated using Adams/View. In addition to
verifying stability, eigendata is used for validating implementation of models with eigendata from other
modeling approaches or experimental data. This is especially true if an elastic or control sub-system
model has been implemented in Adams/Solver (C++). If you issue the LINEAR/EIGENSOL option,
Adams/Solver (C++) computes the model eigendata and reports the model eigenvalues to the workstation
screen. If the results outputs are enabled, eigendata is also written into the results (.res) file, and may be
taken to Adams for further processing.
Both the LINEAR/STATEMAT and the LINEAR/MKB options output a state-space representation in a
form suitable for importation into matrix manipulation and control design packages such as MATRIX
x

and MATLAB (for more information see the Xmath Basics Guide, 1996, Integrated Systems Inc., Santa
Clara, CA and Matlab User's Guide, The MathWorks Inc., Natick, Massachusetts). A state-space model
representation is suitable for obtaining frequency response of the Adams model, verifying model control
Important: The LINEAR/EIGENSOL option RESULTS statement should have the XRF option.
Otherwise the eigendata is not written into the results file and this cannot be postprocessed
in Adams/View or PPT.
Adams/Solver
C++Commands
80
properties (controllability and observability), and designing feedback controllers for Adams models. If
you issue the LINEAR/STATEMAT or LINEAR/MKB command, Adams/Solver (C++) computes the
state matrices for the model and writes them to a user-specified file or files. If enabled, state matrices are
also written out to the Results file.
Option LINEAR/EXPORT is used to export the linearized model into an equivalent Nastran model.
Using this option, Adams/Solver (C++) creates an ASCII file containing a Nastran bulk data deck. Two
sub options are available: a "blackbox" sub option equivalent to a state space representation, and a
"whitebox" sub option in which an element-to-element export is performed. Using the "whitebox" sub
option, rigid Adams PARTS are exported as CONM2 cards, Adams JOINTS are exported as RJOINT
cards or as sets of MPC cards, etc. Both the "blackbox" and "whitebox" sub options honor a configuration
file which is used to fine tune the exporting process. The configuration file can be used to custom the
exported model. See below for current limitations of the LINEAR/EXPORT option.
2. Definition
The LINEAR command linearizes the nonlinear system equations of motion and provides four basic
capabilities: an eigensolution, a standard state-space matrix calculation, a Nastran-specific state space
calculation, and an export to a Nastran bulk data deck.
The eigensolution option determines natural frequencies and mode shapes while the state space
calculations compute the linear state space matrices that describe the linearized mechanical system.
You may issue this command following initial conditions, a static or a transient analysis. Depending on
the options you specify, the results of the command are reported on the screen and written to the Message
file, the Results file, and, if required, the user-specified files.
The LINEAR/EXPORT option has been modified to support all types of operating points (static or
dynamic). However, matching eigenvalues with Nastran can be obtained using static operating points
only. Kinematic models (zero degrees of freedom) can only be exported using the WHITEBOX option.
For theoretical details on the linearization algorithm, see the white paper in Simcompanion Article
KB8016460.
81 LINEAR
C++Commands
3. Format
Adams/Solver
C++Commands
82
4. Arguments
CONFIG=c Specifies a file name from which Adams/Solver (C++) reads
configuration directives to customize the export process to a Nastran bulk
data deck. If no configuration file is specified, Adams/Solver (C++) will
use default configuration parameters. See below for the syntax of the
configuration file.
Range: Valid file name.
Type: Optional with EXPORT.
COORDS=i1[,i2] Specifies that a table of coordinates for mode numbers in the range i1 to
i2 be computed and output. If i2 is not specified, Adams/Solver (C++)
produces the table of coordinates for mode number i1 only.
Range: i1 > 1, i2 > i1
Type: Optional with EIGENSOL; mutually exclusive with NOVECTOR
DISSIPAT=i1[,i2] Specifies that a table of dissipative energy distribution for mode numbers
in the range i1 to i2 be computed and output. If i2 is not specified,
Adams/Solver (C++) produces the table of dissipative energy distribution
for mode number i1 only.
Range: i1 > 1, i2 > i1
EIGENSOL Specifies that Adams/Solver (C++) performs an eigenanalysis of the
Adams model.
Type: Optional (either EIGENSOL, MKB, STATEMAT or EXPORT is
required)
EXPORT Specifies that Adams/Solver (C++) performs a Nastran bulk data deck
export.
required)
83 LINEAR
C++Commands
FILE=c If using the STATEMAT or MKB options, specifies a file name to which
Adams/Solver (C++) writes the state matrices. If the output is in the
MATRIXX format, all matrices are written to this file. For the MATLAB
format, the file name is used as a base name. Each matrix is written to a
separate file, whose name Adams/Solver (C++) automatically constructs
by appending the matrix name to the user-specified base name.
If using the EXPORT option, specifies a file prefix for the bulk data deck
to which Adams/Solver (C++) writes the exported data.
Range: Valid file name up to 76 characters
Type: Required with MKB or STATEMAT or EXPORT
Specifies the name of the software in whose input format Adams/Solver
(C++) is to output the state matrices. Presently, two software formats are
supported: MATRIXX (FSAVE format) and MATLAB (ASCII flat file
format). This argument is a qualifier for the MKB or STATEMAT option.
Type: Optional with MKB or STATEMAT
KINETIC=i1[,i2] Specifies that a table of kinetic energy distribution for mode numbers in
the range i1 to i2 be computed and output.
If i2 is not specified, Adams/Solver (C++) produces the table of kinetic
energy distribution for mode number i1 only.
Range: i1 > 1, i2 > i1
MKB Specifies that Adams/Solver (C++) calculates the M, K, B, C and D
matrices for the Adams model. These matrices are used as inputs to a
MSC.NASTRAN model.
required)
MLIST=id1[,id2..., idn] Specifies that a table of marker mode for mode numbers in the MRANGE
be computed and output. Specify the marker IDs: id1, id2 ..., idn.
Range: i1 > 1, i2 > i1
Type: Optional with EIGENSOL; mutually exclusive with NOVECTOR.
Required with MRANGE.
)
`
=
MATLAB
MATRIXX
FORMAT
Adams/Solver
C++Commands
84
MRANGE=i1[,i2] Specifies that a table of marker mode for mode numbers in the range i1 to
i2 be computed and output. If i2 is not specified, Adams/Solver (C++)
produces the table of marker mode for mode number i1 only.
Range: i1 > 1, i2 > i1
Type: Optional with EIGENSOL; mutually exclusive with NOVECTOR.
Required with MLIST.
NODAMPIN Specifies that Adams/Solver (C++) ignores damping while performing an
eigenanalysis for the Adams model. This argument affects only force
statements (such as SPRINGDAMPER, SFORCE, BEAM, BUSHING,
and so on) and VARIABLE statements whose definition includes velocity
dependencies. This argument is a qualifier to the EIGENSOL or MKB
option.
Type: Optional with EIGENSOL or MKB
NOVECTOR Specifies that Adams/Solver (C++) performs the eigenanalysis without
computation of mode shapes. This argument is a qualifier to the
EIGENSOL option. This argument does not have any values.
Type: Optional with EIGENSOL
PINPUT=id Specifies the identifier of the PINPUT statement that Adams/Solver
(C++) uses as plant inputs in the state matrices computation. If this
argument is not specified, the B and D matrices will not be output. This
argument is a qualifier for the MKB or STATEMAT option.
POUTPUT=id Specifies the identifier of the POUTPUT statement that Adams/Solver
(C++) uses as plant outputs in the state matrices computation. If this
argument is not specified, the C and D matrices will not be output. This
argument is a qualifier for the MKB or STATEMAT option.
PSTATE=id Specifies the identifier of the PSTATE statement that Adams/Solver
(C++) uses as user-defined coordinates for the linearization. If this
argument is not specified, Adams/Solver (C++) uses default state
coordinates or coordinates generated by the RM option.
Type: Optional with EIGENSOL, STATEMAT, or MKB
RM=id Specifies the identifier of the MARKER statement that Adams/Solver
(C++) uses to generate user-defined coordinates for linearization. This
argument is a qualifier for the STATEMAT, EIGENSOL, or MKB option.
Type: Optional with EIGENSOL, STATEMAT, or MKB
85 LINEAR
C++Commands
5. Extended Definition
To linearize an Adams model about an operating point, issue the SIMULATE/INITIAL,
SIMULATE/STATIC, STATIC/DYNAMIC, or SIMULATE/TRANSIENT commands and then issue the
LINEAR command to exercise a linear analysis on the model. Option EXPORT can be used at any
operating point (static or dynamic). Notice however that after performing a STATIC analysis at time t=0,
all initial velocities found in the model are restored. This means that the operating point may not be truly
static at time t=0 after a static simulation. Use the environment variable
MSC_ADAMS_STATI CS_NO_RESTORE_VELOCI TI ES to override the default solver behavior.
Use the option EIGENSOL to compute the eigenvalues and mode shapes for the Adams model. To
compute the state matrices representation of the Adams model use the STATEMAT or the MKB options.
To export the linearized model as a Nastran bulk data deck use the EXPORT option.
5.1 Eigensolutions
5.1.1 Scope
If you specify the EIGENSOL option, Adams/Solver (C++) computes the A state matrix of the Adams
model and it performs an eigenanalysis. Eigendata results from the solution of a generalized eigenvalue
problem of the form:
A z = z
where:
z is the eigenvector.
STATEMAT Specifies that Adams/Solver (C++) calculates state matrices for the
ADAMS model.
Type: Optional (either MKB,STATEMAT or EIGENSOL is required)
STRAIN=i1[,i2] Specifies that a table of strain energy distribution for mode numbers in the
range i1 to i2 be computed and output. If i2 is not specified, Adams/Solver
(C++) produces the table of strain energy distribution for mode number i1
only.
Range: i1 > 1, i2 > i1
Specifies the type of Nastran bulk data deck export. Using the
BLACKBOX option Adams/Solver (C++) exports the state space
matrices MKB using DMIG cards. Using the WHITEBOX option
Adams/Solver (C++) exports the model using an element-to-element
translation.
Type: Required with EXPORT.
)
`
=
BLACKBOX
WHITEBOX
TYPE
Adams/Solver
C++Commands
86
is the eigenvalue.
A is the state matrix computed by Adams/Solver (C++) from the Adams model.
The standard approach to compute the state matrix (A) consists of a direct linearization of the equations
of motion, hence the state variables (x) are a subset of the default coordinates used to build the equations
of motion. However, the default state variables may not be the correct choice. In rotational systems
(turbines, helicopter blades, etc.), you may prefer using relative coordinates or user-defined coordinates
instead of the default coordinates. The RM and PSTATE options (see Using the RM Option) allow you to
specify user-defined coordinates, which results in better eigensolution computations.
Once the eigensolution is completed, the eigenvector is mapped to the mode shape prior to output to the
results (.res) file.
If you specify the NODAMPIN argument, Adams/Solver (C++) does not include the velocity-dependent
terms in forces nor does it include velocity-dependent terms in the VARIABLE statements in the A
matrix. Using this option may be beneficial in determining the underlying modes for a system with
critical or greater than critical damping.
If you specify the NOVECTOR argument, Adams/Solver (C++) computes only the eigenvalues and not
the mode shapes. Adams/Solver (C++) reports on the screen eigenvalues that result from the
eigensolution. If you use the RESULTS statement to enable output to the results file (.res) in the
Adams/Solver (C++) dataset, the eigenvalues and mode shapes (if computed) will be written to this file.
The results file may be taken to a postprocessor, such as Adams/View, for further processing.
All eigenvalues are normalized to be in cycles/second. The imaginary component of the eigenvalue
represents the oscillatory behavior of the mode and the real component the damping characteristic.
The model eigenvalues are reported to the workstation screen. In general, the eigenvalues are complex
values, made up of real and imaginary components. The imaginary component represents the damped
natural frequency . The damping ratio must be less than 1 in order to produce an imaginary
component in the eigenvalue - in other words, the damped natural frequency is zero whenever the
damping ratio is 1 or greater.
The undamped natural frequency and damping ratio obeys the following equations:
where:
is the real part of eigenvalue.
is the imaginary part of eigenvalues.
e
d
e
n

r
2

i
2
+ ( ) =
,

r
e
n
------ =
i
87 LINEAR
C++Commands
is the undamped natural frequency.
is the damping ratio ( < 1).
The relationship between the damped natural frequency, , and undamped natural frequency, , is:
The damped natural frequency is the actual frequency at which the system is oscillating for that mode.
5.1.2 Using the RM option
By default (if no RM option and no PSTATE option are used), Adams/Solver (C++) uses the global
displacements and global rotations about the ground origin of all PARTS to build the linearized equations
of motion. The complete set of defaults coordinates is shown in the next table.
The default linearization coordinates are not a minimal set. Therefore, Adams/Solver (C++) selects an
optimal subset x (the state variables) and linearizes the system in terms of those variables. As mentioned
above, the default coordinate selection may not be the best choice in cases of rotating or accelerating
systems. The first tool to customize the state variables is the RM option. The RM option sets the ADAMS
id of a MARKER, for example:
LI NEAR/ EI GENSOL, RM=b
Default linearization coordinates (no RM, no PSTATE options used)
Global displacements of the BCS of all PARTS, FLEX_BODY and POINT_MASS relative
to the ground coordinate system, namely DX(BCS), DY(BCS) and DZ(BCS).
Global rotations of the BCS of all PARTS and FLEX_BODY relative to the ground
coordinate system, namely AX(BCS), AY(BCS) and AZ(BCS).
All active modal coordinates in FLEX_BODY.
All states in LSE, TFSISO, LSE and GSE objects.
All states in DIFF objects.
e
n
, ,
e
d
e
n
e
d
e
n
1 ,
2
( ) =
Note: BCS stands for an internal MARKER located at the Body Coordinate System which is the
location specified by the QG and REULER arguments of the PART, FLEX_BODY and
POINT_MASS statements.
Adams/Solver
C++Commands
88
MARKER/b may be located on a rotating hub or accelerating subsystem of the model. When the option
RM is used, the default coordinates are the following:
The RM option is useful in linearizing helicopter blades, turbines, etc. If no RM option is used, the
computed frequencies reflect a dependency on the rotation frequency, hiding the frequencies of interest.
When the RM option is used, Adams/Solver (C++) selects a subset x of the coordinates shown in the table
above to perform the linearization.
For example, Figure 6 below shows a rotating system modeled using coordinates o and u.
Figure 6 Rotating spring-mass system
The exact equations of motion in terms of the shown coordinates are the following:
Default linearization coordinates using RM=b
Relative displacements of the BCS of all PARTS, FLEX_BODY and POINT_MASS relative
to MARKER/b, namely DX(BCS,b,b), DY(BCS,b,b) and DZ(BCS,b,b). There is one
exception: for the PART that owns MARKER/b, the default coordinates are
DX(GROUND,b,b), DY(GROUND,b,b) and DZ(GROUND,b,b).
Relative rotations of the BCS of all PARTS and FLEX_BODY relative to MARKER/b,
namely AX(BCS,b), DY(BCS,b) and DZ(BCS,b). There is one exception: for the PART that
owns MARKER/b, the default coordinates are AX(GROUND,b), AY(GROUND,b) and
AZ(GROUND,b).
All active modal coordinates in FLEX_BODY.
All states in LSE, TFSISO, LSE and GSE objects.
All states in DIFF objects.
o
2Buu
A Bu
2
+
------------------- =
89 LINEAR
C++Commands
where:
Setting m
1
=m
2
=3, I
1
=I
2
=10, e=1, K=5, u
o
=10 and selecting an operating point defined by t=0, o =10,
u=0, =0, =0, we obtain that one eigenvalue is zero and the other is 2.63056 Hz.
The corresponding Adams dataset file is:
UNI TS/ FORCE = NEWTON, MASS = KI LOGRAM, LENGTH = METER, TI ME = SECOND
PART/ 1, GROUND
MARKER/ 6, PART = 1
PART/ 2, MASS = 3, CM = 7, I P = 10, 10, 10, WZ = 10
MARKER/ 5, PART = 2
MARKER/ 7, PART = 2, QP = 1, 0, 0
MARKER/ 10, PART = 2, REULER = 90D, 90D, 0D
PART/ 3, MASS = 3, CM = 8, I P = 10, 10, 10, WZ = 10
MARKER/ 8, PART = 3, QP = 10, 0, 0
MARKER/ 9, PART = 3, REULER = 90D, 90D, 0D
J OI NT/ 1, REVOLUTE, I = 5, J = 6
J OI NT/ 2, TRANSLATI ONAL, I = 9, J = 10
SPRI NGDAMPER/ 1, TRANSLATI ONAL, I = 6, J = 8, K = 5, L = 10
ACCGRAV/ I =0, J =0, K=0
RESULTS/ XRF
END
PART/2 corresponds to the first link and PART/3 is the mass on the tip. Computing an eigensolution using
the default command LINEAR/EIG, we obtain the following results shown in the message file:
Thi s model has
4 ki nemat i c st at es ( di spl acement and vel oci t i es)
0 di f f er ent i al st at es ( DI FFs, LSEs, et c. )
The sel ect ed ki nemat i c st at es ar e:
1 Gl obal r ot at i on AZ( BCS) PART/ 2
2 Gl obal di spl acement DX( BCS) PART/ 3
The ot her ki nemat i c st at es ar e t he r espect i ve der i vat i ves.
E I G E N V A L U E S at t i me = 0. 00000E
Number Real ( cycl es/ uni t t i me) I mag. ( cycl es/ uni t t i me)
1 0. 00000E
2 0. 00000E
3 0. 00000E 3. 07455E
u
uo
2
K u u
o
( )
2B
-----------------------
U
2B
------- + =
A
1
2
--- m
1
h
1
2
I
1
I
2
+ + ( ) =
B
1
2
---m
2
=
o
Adams/Solver
C++Commands
90
Notice that the selected states are the global rotation of PART/2 about the z-axis (AZ(BCS) PART/2) and
the global x-displacement of PART/3 (DX(BCS) PART/3). While the first one coincides with the
coordinate alpha used to generate the equations of motion, the second one does not correspond to
coordinate u.
The correct results are obtained using the following command:
LI NEAR/ EI GEN, RM=5
Where MARKER/5 is located on the first link. The corresponding results are:
Thi s model has
1 Rel at i ve r ot at i on AZ( GROUND, 5) PART/ 2
2 Rel at i ve di spl acement DX( BCS, 5, 5) PART/ 3
1 0. 00000E
2 0. 00000E
3 0. 00000E 2. 63056E
Notice that the selected states now coincide with o and u and that the results match the theoretical ones.
For an example of using RM, see Simcompanion Knowledge Base Article KB8016438.
5.1.3 Using the PSTATE option
The PSTATE option is used to indicate the ADAMS ID of a PSTATE object. A PSTATE object is a set
of VARIABLES defining user-defined coordinates (see the PSTATE statement). You may want to
linearize the system using specific coordinates that the RM option does not provide. The methodology is:
1. Create as many variables as user-defined coordinates you want Adams/Solver (C++) to use when
linearizing the model.
2. Create a PSTATE object and enter the Adams id of all variables created in the previous step.
3. Issue a LINEAR/EIGEN command using the PSTATE=id option.
91 LINEAR
C++Commands
The following example illustrates these steps.
Figure 7 Simple model of a rigid helicopter blade
Figure 7 shows a simplified model of a rigid helicopter blade where the first link has a prescribed angular
velocity w. Observe that the system has one degree of freedom but there are several coordinates to choose
from to build the equations of motion. The classical approach is to use angle but there may be a
requirement to use coordinate y instead.
If the angle is used, the equation of motion is:
Linearizing this equation in terms of the following state matrix is obtained (at time t=0):
and the corresponding frequency is
where i is the imaginary constant. Setting m=3, e=2, l=10, I=10, and w=10, we obtain = 0.70019 Hz.
The corresponding Adams dataset is:
UNI TS/ FORCE=NEWTON, MASS=KI LOGRAM, LENGTH=METER, TI ME=SECOND
PART/ 1, GROUND
MARKER/ 6, PART = 1
PART/ 2
o
o
I ml
2
+ ( )o
mele
2
o e t ( ) sin + 0 =
o
A | |
0
mele
2
I ml
2
+
-------------------
1 0
=
1 2 ,
i
mel
I ml
2
+
-----------------e =
Adams/Solver
C++Commands
92
MARKER/ 5, PART = 2
MARKER/ 8, PART = 2, QP = 2, 0, 0
PART/ 3, MASS = 3, CM = 10, I P = 0, 0, 10, WZ = 10
MARKER/ 7, PART = 3, QP = 2, 0, 0
MARKER/ 10, PART = 3, QP = 12, 0, 0
MARKER/ 12, PART = 3, QP = 22, 0, 0
MOTI ON/ 1, ROTATI ONAL, J OI NT = 1, FUNCTI ON = 10*TI ME
ACCGRAV/ I =0, J =0, K=0
RESULTS/ XRF
END
where PART/2 is the first link and PART/3 is the rigid blade. Running the model with a LINEAR/EIG
command, we obtain the following output:
Thi s model has
1 Gl obal r ot at i on AZ( BCS) PART/ 3
1 0. 00000E 7. 00188E- 01
Notice the exact match with the theoretical results. However, let's assume you want to linearize the model
using coordinate y instead. If that is the case, the state matrix is now:
and the frequencies are:
Using the same physical parameters, the frequency turns out to be = 1.73867 Hz. To obtain this second
result, add the following lines to the dataset file:
VARI ABLE/ 1, FUN=DY( 10)
PSTATE/ 1, VAR=1
Notice that MARKER/10 is located on the CM of the blade, therefore DY(10) is the coordinate y shown
in the figure above. Re-running the model using the following command:
LI N/ EI GEN, PSTATE=1
The corresponding results are:
A
-
| |
0
melw
2
I ml
2
+
----------------- w
2

1 0
=
-
1 2 ,
iw
mel
I ml
2
+
------------------ 1 + =
93 LINEAR
C++Commands
Thi s model has
1 PSTATE VARI ABLE VAR/ 1 DY( 10)
1 0. 00000E 1. 73876E
Notice that the results match the theory.
The documentation for the PSTATE statement provides guidelines for the correct definition of user-
defined coordinates. Below is a brief summary:
The VARIABLE's function expression must define a non constant displacement or angular
measure.
The displacement or angular measure can be global or relative.
The number of user-defined coordinates can be less than the number of degrees of freedom of the
model. Adams/Solver (C++) will complete the state array using coordinates taken from the set of
default coordinates.
The number of user-defined coordinates can be greater than the number of degrees of freedom of
the model. Adams/Solver (C++) selects the required number, ignoring the rest.
Redundant definitions will be rejected.
Adams/Solver (C++) may ignore a user-defined coordinate if there is already an equivalent
default definition.
For an example of using PSTATE, see Simcompanion Knowledge Base Article KB8016414
5.1.4 Using both the RM and PSTATE options
You may safely use both the RM and the PSTATE options. Adams/Solver (C++) assigns a higher priority
to the user-defined states specified by the VARIABLES referenced in the PSTATE object. Default
coordinates generated by the RM option have a lower priority.
For example, the following command linearizes the model using both options.
LI NEAR/ EI GEN, RM=77, PSTATE=3
5.1.5 Coordinates, Kinetic, Dissipative and Strain options
If you specify the COORDS, KINETIC, DISSIPAT, or STRAIN arguments, Adams/Solver (C++)
computes tabular output and writes it to an ASCII (.txt) file. For each mode in the specified range, this
output could consist of up to five sections. The header section contains the mode number, undamped
natural frequency, damping ratio, generalized stiffness, generalized mass and model energy for the mode.
Generalized stiffness and generalized mass are in user-specified units.
Adams/Solver
C++Commands
94
The second section is a table of coordinates if the COORDS argument is specified. This section is not
output if the COORDS argument is not specified or if the particular mode number is not within the range
specified on the COORDS argument. Each part in the Adams/Solver (C++) model has one row in this
table. The part translational coordinates in columns labeled (X,Y, and Z), represent the small translational
displacements of the part center-of-mass (cm) marker in the global reference frame. The part rotational
coordinates, in columns labeled (RX, RY, and RZ), represent the small rotational displacements of the
part about the global x, y and z axes, respectively. Each coordinate in this table is represented by a
magnitude and a phase. The mode is normalized so that the largest component in the mode has a value
of 1.0 and a phase angle of 0 degrees. Magnitude and phase of all other components in the mode are
reported relative to this largest component. Phase angles are represented in the range 0 to 355 degrees.
Phase angles in the range 175 to 185 degrees are reported as 180 degrees. Phase angles in the range 355
to 360 degrees as well as phase angles in the range zero to five degrees are reported as zero degrees. States
of elements resulting in user supplied differential equations are also represented in the coordinate table.
All components with zero magnitude are also reported as having zero phase angles.
The third section is a table of modal kinetic energy distribution if the KINETIC arguments are specified.
This section is not present in the output for a particular mode if the mode number is not within the range
of the modes specified on the KINETIC arguments. Each part is represented by a single row in this table.
Each entry in this table represents the percentage of the total modal kinetic energy for that part in a
particular direction. Translational directions in which the modal kinetic energy distribution is computed
are x, y and z displacement of the part center-of-mass (cm) in the global reference frame. Rotational
directions are denoted by RXX, RYY, and RZZ; these represent the small displacement rotations of the
part about the global x, y and z axes, respectively. The cross rotations are represented as RXY, RYZ, and
RXZ. The sum of all values in a modal energy distribution table should be 100.0. Elements resulting in
user-supplied differential equations are not considered in the computation for this table.
The fourth section is a table of modal strain energy distribution if the STRAIN argument is specified.
of the modes specified on the STRAIN argument. Each force element is represented by one or more rows
in this table. The table below shows the contribution of various element types to this table. Computation
of strain energy accounts for the direct and indirect dependence of the force on PART displacements. The
indirect dependence on PART displacements may be through dependence of the force on other FORCEs,
VARIABLEs, or algebraic DIFFs that may be directly or indirectly dependent on PART displacements.
Elements Contributing to Table for Dissipative and Strain Energy Computations
Total X Y Z RX RY RZ
BEAM X X X X X X X
BUSHING X X X X X X X
CONTACT X X X X X X X
FIELD X X X X X X X
GFORCE X X X X X X X
NFORCE for marker 1 X X X X X X X
... X X X X X X X
95 LINEAR
C++Commands
In the table, X, Y, and Z refer to translation components along the global x, y and z directions and RX,
RY, and RZ refer to rotational components about the global x, y and z directions. x indicates locations for
contributions for individual elements. The column labeled Total contains a summation of the
strain/dissipative energy contribution due to the element in various directions.
The fifth section is a table of modal dissipative energy distribution if the DISSIPAT argument is specified.
of the modes specified on the DISSIPAT argument. Each force element is represented by one or more
rows in this table. The table shows the contribution of elements to this table. Computation of dissipative
energy accounts for the direct and indirect dependence of the force on PART velocities. The indirect
dependence on PART velocities may be through dependence of the force on other FORCEs,
VARIABLEs, or algebraic DIFFs that may be directly or indirectly dependent on PART velocities.
5.2 State matrices and MKB computation
5.2.1 Scope
If you specify the STATEMAT option, Adams/Solver (C++) computes the state matrices representation
for an Adams model. The linearized Adams model is represented as:
where:
Vector x represents the state variables of the plant model. The state variables can be user-defined
coordinates (see the RM and PSTATE options). By default, the state variables are the
displacements, modal coordinates (from flexible elements) and their corresponding time
derivatives. The state variables also include all of the differential states from DIFs, LSEs, GSEs
and TFSISOs.
Vector u represents the inputs of the plant model.
for marker n X X X X X X X
SFORCE (translational) X X X X
SFORCE (rotational) X
SPRINGDAMPER
(translational)
X X X X
SPRINGDAMPER
(rotational)
X
VFORCE X X X X
VTORQUE X X X X
Total X Y Z RX RY RZ
x
Ax Bu + =
y Cx Du + =
Adams/Solver
C++Commands
96
Vector y represents the outputs from the plant model.
A, B, C, and D are state matrices representing the plant.
If you specify the MKB option, Adams/Solver (C++) computes another form of the state matrices
representation for an Adams model. In this case, the linearized Adams model is represented as:
where:
Vector x represents the state variables of the plant model. The state variables can be user-defined
coordinates (see the RM and PSTATE options.) In this case the state variables are the
displacements, modal coordinates (from flexible elements) and all differential states from DIFS,
LSEs, GSEs and TFSISOs.
Vector u represents the inputs of the plant model.
Vector y represents the outputs from the plant model.
M, K, B, C, and D are state matrices representing the plant.
Matrices M, K, B, computed using the MKB option are equivalent to matrices A and B obtained using
the STATEMAT option. The MKB option is useful if you need to export the Adams model to be a
subsystem of an MSC.NASTRAN model.
5.2.2 Using the RM and PSTATE options
See sections Using the RM and PSTATE options.
5.2.3 Plant inputs and Plant outputs
You can specify the definition of plant inputs with the PINPUT argument value. Similarly, plant outputs
are specified by the POUTPUT argument. States variables (x) are automatically selected by
Adams/Solver (C++) out of the total set of coordinates used to model the mechanical system. However,
using the RM and/or the PSTATE options, you may have Adams/Solver (C++) use user-defined
coordinates for linearization. This is particularly important for rotating systems. While several PINPUT
statements and POUTPUT statements may be present in an Adams model, you can specify only one of
each on the LINEAR command.
Corresponding to each VARIABLE id specified on the PINPUT statement, a column exists in the B and
D matrices (STATEMAT option). Similarly, for each VARIABLE id specified on the POUTPUT
statement, a row exists in the C and D matrices. In effect, each VARIABLE id specified on the PINPUT
or POUTPUT statement specifies an input or output channel, respectively.
Input channels are important in the computation of state matrices. It is important to notice that
Adams/Solver (C++) assumes the function expressions of all input channels are zero. If the function
expression of an input VARIABLE is not zero, then you have two choices to properly model the system
(assume the original input variable is VARIABLE/f):
Mx
Kx Bx
+ + Pu =
y Cx Du + =
97 LINEAR
C++Commands
1. Remove VARIABLE/f from the INPUT statement. This is usually the simples and correct choice.
2. Create a new VARIABLE/d and add it to the INPUT statement. Remove VARIABLE/f from the
INPUT statement and modify its function expression to original_expression + VARVAL(d).
Choose this approach if you need to keep the size of the B to an specified value.
Following the above recommendation you may properly model both open-loop and close-loop control
systems.
5.2.4 MATRIXX format
State matrices output by Adams/Solver (C++) in the MATRIXX format conforms to the MATRIXx
FSAVE ASCII file specification. These specifications are given in the Xmath Basics Guide, 1996,
Integrated Systems Inc., Santa Clara, CA.
More than one matrix may be present in a single file. The Adams/Solver (C++) state matrices file can
have up to seven matrices. The first four matrices are the A, B, C, and D state matrices. The next three
matrices are STATES, PINPUT, and POUTPUT. The contents and format of these matrices are explained
in the next sections.
5.2.5 MATLAB format
State matrices output by Adams/Solver (C++) in the MATLAB format conform to the ASCII flat file
format. This format requires that all entries in a row of the matrix be written in a single record. Successive
values in a row are separated by a single space. A file is allowed to contain only one matrix. Therefore,
Tip: To reduce computing time, specify the NOVECTOR argument with the
EIGENSOL option if mode shapes are not desired.
Specify the LINEAR command to assess stability of Adams models by computing
its eigenvalues. Eigenvalues with positive real parts correspond to unstable modes
of the system.
If you specify the PINPUT and the POUTPUT arguments for state matrices output,
Adams/Solver (C++) produces all four matrices (A, B, C, and D). If you do not
specify the PINPUT argument, Adams/Solver (C++) does not produce the B or D
matrices. Similarly, if you do not specify the POUTPUT argument, Adams/Solver
(C++) will not produce the C or D matrices. If you do not specify either the
PINPUT or POUTPUT arguments, Adams/Solver (C++) produces only the A
matrix.
You may define several PINPUT and POUTPUT statements in an Adams/Solver
(C++) dataset, however, a LINEAR command allows only one PINPUT and one
POUTPUT statement to be specified at a time. If you issue a series of LINEAR
commands, Adams/Solver (C++) computes alternate state matrix descriptions at
the same operating point with different combinations of PINPUT and POUTPUT
identifiers. Changes in the PINPUT and POUTPUT descriptions are reflected in
the A, B, C, and D matrices.
Adams/Solver
C++Commands
98
Adams/Solver (C++) may create up to seven output files, one each for the A, B, C, and D matrices, one
for STATES, one for PINPUT, and one for POUTPUT. The contents and format of the last three matrices
are as shown in the next sections. The file name you specify is used as a base name and is appended with
the matrix name to write the matrix of the appropriate type. The file names used for the seven matrices
are as given in the table below.
File Names Used for MATLAB State Matrices Output
5.2.6 Contents of the STATES matrix
The STATES matrix contains information regarding states that Adams/Solver (C++) has chosen for the
state matrices representation. For each state, one record exists in this matrix. The following information
is contained in each record:
Type_of_element
Type_of_element can take on the following values:
1. PART coordinates (using Euler angles)
2. States in a LSE element
3. States in a TFSISO element
4. States in a GSE element
5. Diff variable
6. Coordinate for a PTCV element
7. Coordinates for a CVCV element
8. FLEX_BODY element
9. POINT_MASS element
10. PSTATE variable (a VARIABLE used in a PSTATE object)
Matrix Name file Name
A "base_name" "a"
B "base_name" "b"
C "base_name" "c"
D "base_name" "d"
STATES "base_name" "st"
PINPUT "base_name" "pi"
POUTPUT "base_name" "po"
Type_of_element Element_identifier Element_coordinate
99 LINEAR
C++Commands
11. Derivative of a PSTATE variable
21. PART coordinates (no RM option was used)
28 FLEX_BODY element (no RM option was used)
29 POINT_MASS element (no RM option was used)
31 PART coordinates (RM option was used)
38 FLEX_BODY element (RM option was used)
39 POINT_MASS element (RM option was used)
Element_identifier
Element_identifier is the eight-digit Adams/Solver (C++) identifier of the element.
Element_coordinate
If Type_of_element=1, the Element_coordinate can take on the values:
1 Global x-displacement of PBCS (See the Note: below)
2 Global y-displacement of PBCS
3 Global z-displacement of PBCS
4 Global angle of part principal axis of PBCS
5 Global angle of part principal axis of PBCS
6 Global angle of angle of part principal axis of PBCS
7 to 12 Correspond to the respective derivatives
1 Global x-displacement of BCS (See the Note: below)
2 Global y-displacement of BCS
3 Global z-displacement of BCS
4 Global rotation of BCS about the global x-axis
5 Global rotation of BCS about the global y-axis
6 Global rotation of BCS about the global z-axis
+
u
|
Note: PBCS stands for Principal Body Coordinate System. PBCS is a frame coincident with the
PARTs CM MARKER but it is oriented along the principal inertia axis. PBCS is an internal
MARKER used by Adams/Solver (C++) to build the equations of motion.
Note: BCS stands for Body Coordinate System. For details on BCS, see the PART command.
Adams/Solver
C++Commands
100
1 Relative x-displacement of BCS with respect to the RM marker
2 Relative y-displacement of BCS with respect to the RM marker
3 Relative z-displacement of BCS with respect to the RM marker
4 Relative rotation of BCS about the x-axis of the RM marker
5 Relative rotation of BCS about the y-axis of the RM marker
6 Relative rotation of BCS about the z-axis of the RM marker
For Type_of_element=2 to 5, Element_coordinate is the sequence number in the set of states defining
that element.
For Type_of_element=6, the only permissible value for Element_coordinate is 1, that is, the alpha
parameter value that defines the contact point on the curve.
For Type_of_element=7, Element_coordinate may take on the value of 1 or 2, representing the parameter
values for the first (I) or second (J) curve in a CVCV statement that defines the contact point on the curve.
For Type_of_Element=8, the Element_coordinate can take on the values:
1 - 12 same as for Type_of_Element=1
1 E6 + n nth modal generalized coordinate
2 E6 + n first time derivative of the nth modal generalized coordinate
For Type_of_Element=9, the Element_coordinate can take on the following values:
4 - 6 Correspond to the respective derivatives
4 -6 Correspond to the respective derivatives
101 LINEAR
C++Commands
4 -6 Correspond to the respective derivatives
For Type_of_Element=10, the Element_coordinate takes the value 1.
For Type_of_Element=11, the Element_coordinate takes the value 2.
In the MATRIXX format, this data is organized in column order form so that the STATES matrix contains
three rows and number of columns is equal to the number of states in the model. In the MATLAB format,
this data is organized in the row order form. Therefore, the STATES file contains data organized in the
three columns and the number of rows is equal to the number of states in the model.
For example, find the states used by the linearization computation from the listing shown below (the
listing is obtained by using the FILE and MATRIXX options in a STATEMAT or MKB)
STATES 3 2 0( 3( 1PE25. 17) )
2. 10000000000000000e+01 3. 00000000000000000e+00 1. 20000000000000000e+01
2. 10000000000000000e+01 3. 00000000000000000e+00 6. 00000000000000000e+00
The first column shows a 21, which stands for a PART. No option RM was used in the linearization
command. The second column shows a 3 which stands for the ADAMS id of the PART. The third column
shows a 12 and a 6, therefore the states used by the linearization are:
1. Global rotation of the BCS of PART/3 about the global z-axis
2. The derivative of the global rotation of the BCS of PART/3 about the global z-axis.
5.2.7 Contents of the PINPUT and POUTPUT matrices
The first record in the PINPUT (or POUTPUT) exported matrix data contains the Adams/Solver (C++)
identifier of the PINPUT (or POUTPUT) statement that was used on the LINEAR command to generate
these state matrices. Subsequent records contain the Adams/Solver (C++) identifiers of the VARIABLE
statement identifiers used on these statements. In the MATRIXX as well as the MATLAB format, this
data is organized as a matrix with 1 column and number of rows equal to one plus the number of variables
on the PINPUT (or POUTPUT) statement.
All data for the STATES, PINPUT, and POUTPUT matrices is written as floating point data.
5.3 Nastran bulk data deck export
5.3.1 Scope
Using the EXPORT option Adams/Solver (C++) exports the linearized Adams model as a set of Nastran
bulk data deck files.
The syntax to invoke the EXPORT job calls for the type of export (WHITEBOX or BLACKBOX), the
name of the main bulk data deck file to be created (FILE argument), and an optional name for a
configuration file (CONFIG argument). The configuration file is useful to customize the export process.
It supports two types of EXPORT jobs, namely, a WHITEBOX option or a BLACKBOX option which
must be specified using the TYPE argument. These two types are conceptually different. Using the
BLACKBOX option, Adams/Solver (C++) computes the MKB matrices and exports the model as a set
Adams/Solver
C++Commands
102
of three DMIGs. Individual contributions to the MKB matrices from all of the inertial elements, applied
forces and constraints cannot be identified, hence the exported model is practically non modifiable. On
the other hand, using the WHITEBOX option, the linearized model is exported as a set of Nastran cards
where an element-to-element translation takes place; this option exports a model that can be further
edited and modified.
Using the EXPORT option, a configuration file can be specified to fine tune the export job. The syntax
of the configuration file allows the user to select the solution number, specify exported MARKERS,
single out applied forces, change the default numbering of GRID and other Nastran cards, select include
directories, choose a type of graphical output, select a style of file generation, etc.
5.3.2 Limitations
There are no limitations on the type of previous analysis prior to the invocation of the LINEAR/EXPORT
command if using the BLACKBOX export type. Also, eigenvalues computed by Nastran on the exported
model will match eigenvalues computed by Adams on the Adams model. In a few words, both, static and
dynamic operating points are supported by the BLACKBOX export.
When using the WHITEBOX export type, we guarantee matching eigenvalues computed by both,
Nastran and Adams, only if the operating point is a static one (if the previous simulation in Adams was
either STATIC or QUASISATIC). Notice that a STATIC simulation at time t=0 may not be a truly static
operating point because Adams/Solver restores the initial velocities found in the model. This restoration
of velocities after a STATIC simulation at time t=0 can be avoided by setting the environment variable
MSC_ADAMS_STATI CS_NO_RESTORE_VELOCI TI ES.
If the previous simulation done by Adams is a dynamic or kinematic analysis, the exported model
includes TIC cards defining the velocities of the model. However, eigenvalues computed by both,
Nastran and Adams will not necessarily match. This is not a limitation on the Adams side but a limitation
inherent to most linear/nonlinear Finite Element codes available in the market.
If the operating point is KINEMATIC (no degrees of freedom), the only type allowed is WHITEBOX.
No BLACKBOX export is possible for that type of operating point.
5.3.3 BLACKBOX and WHITEBOX exported cards
The BLACKBOX option exports the following cards:
1. One DMIG for each of the mass, stiffness, and damping matrices. The BLACKBOX option
exports the model as a state-space set of matrices.
2. A set of SPOINTs to define the states of the model and one GRID fixed to the origin.
The WHITEBOX option exports the following cards:
1. A set of GRID cards representing the center of mass of each PART, POINT_MASS and
FLEX_BODY in the Adams model. Depending of the style chosen by the user, this information
may be included in a single file or in a set of files. See directive file_name_styles for more
information below.
2. One GRID fixed to the origin.
103 LINEAR
C++Commands
3. A set of SPOINT cards representing differential states from DIF, LSE, TFSISO and GSE objects
in the Adams model.
4. A set of CONM2 cards representing PART and POINT_MASS objects in the Adams model.
5. As set of RJOINT and/or MPC cards representing each of the JOINTS, GCON, JPRIM and
MOTION objects in the model.
6. A set of DMIG cards representing the dynamic contributions from DIF, LSE, TFSISO and GSE
objects in the Adams model.
7. A set of DMIG representing the contribution of applied forces, gravity and flexible bodies. By
default, all applied force, gravity and flexible bodies are exported into a single DMIG. The
configuration file can be used to single out applied forces and flexible bodies. There are
configuration directives to export forces using CBUSH cards.
Both, BLACKBOX and WHITEBOX options export the following cards
1. If the configuration file defines outputs channels and solution 108 is specified, the bulk data will
include a set of CORD2R and GRID cards representing the output channels. Along with each
GRID card, a set of MPC cards are exported.
2. If the configuration file defines input channels and solution 108 is specified, the bulk data will
include a set of CORD2R and GRID cards representing each of the input channels. Along with
each GRID card, a set of MPC cards are exported.
3. If the configuration file defines subcases, the bulk data will include a FREQ1 (or FREQ2) card.
A set of TABLED1 cards to define the force magnitude of the actuators, and a set of DLOAD
cards and corresponding RLOAD1, FORCE, MOMENT and DPHASE cards defining the input
channels, are also included.
4. By default, solution 107 and corresponding cards are exported. The configuration file can be used
to select solution 108.
5. A set of CORD2R and GRID cards representing Adams MARKERS in the model. Each exported
Adams MARKER creates GRIDs (with corresponding RBE2 cards) or a set of required MPC
cards. MARKERS are not exported by default if BLACKBOX type is selected. See the syntax of
the configuration files to export Adams MARKERS.
5.3.4 Configuration file syntax
The configuration file is an ASCII file used to fine tune the export job. The file can be seen as a set of
configuration directives and data definitions. Configuration directives have the syntax:
KEY = VALUE1 [ , VALUE2]
Data definitions have the syntax:
DATA_NAME {
KEY = VALUE1 [ , VALUE2]
}
Adams/Solver
C++Commands
104
If a KEY is repeated, the latest definition is used. Comments start with the character $. The contents are
case sensitive.
Supported directives
The list of current supported directives, using the following format:
Syntax
Example
Explanation
actuator_swept_sine {
name = [string]
magnitude = [real]
phase_angle = [angle]
}
act uat or _swept _si ne {
name = act uat or _1
magni t ude = 2. 2
phase_angl e = 45D
}
Creates an actuator to be used in the creation of an input channel. Field
name is required and the value of the given name is case sensitive. The
phase_angle is to be given in radians. A "D" can be used to specify degrees.
Both magnitude and phase angle are optional; defaults are 1.0 and 0.0
respectively.
Ignored if solution 107 is specified.
Optional if solution 108 is specified.
105 LINEAR
C++Commands
add_space_before_names= {yes | no }
add_space_bef or e_names = yes
If this directive is set to yes, Adams/Solver adds a space between the
leading $ and the name of the Adams object when exporting its equivalent
Nastran cards.
Optional in all types of solution sequences.
Ignored if job is BLACKBOX
Default is no.
all_flexbodies_editable = [yes| no]
al l _f l exbodi es_edi t abl e = no
Specifies to export all flexible bodies one by one creating sets of DMIGs
per body.
Ignored if job is BLACKBOX.
Default is yes.
all_forces_editable = [yes|no]
al l _f or ces_edi t abl e = no
Specifies to export all forces creating a CBUSH and residual DMIGs per
forcing object.
Default is yes.
Adams/Solver
C++Commands
106
begin_frequency = [real]
begi n_f r equency = 1. 0
Sets the initial value of the frequency for a frequency response analysis.
Required if solution 108 is specified.
clan_region= [real], [real], [real], [real], [real], [integer]
cl an_r egi on= 1. 2, 4. 0, 6. 4, 4. 0, 1. 1, 20
Specifies the parameters ALPHAAJ, OMEGAAJ, ALPHABJ, OMEGABJ,
LJ and NDJ, defining a search region when using the eigc_method = clan
directive.
You may enter as many clan_region directives as needed.
cmethod_number = [integer]
cmet hod_number = 445
Sets the number of CMETHOD card.
Default is 101.
cbush_offset = [integer]
cbush_of f set = 7000000
Sets the offset number of the CBUSH card to be exported.
Optional if job is WHITEBOX.
Default is 6000000.
107 LINEAR
C++Commands
cord2r_offset = [integer]
cor d2r _of f set = 600
Sets the number of the first CORD2R card to be exported.
Default is 100.
Adams/Solver
C++Commands
108
debug = { yes | no }
debug = yes
Causes Adams/Solver (C++) to output each of the directives found in the
configuration file and print detailed information of each processed
directive.
Default is "no".
differentials_dmig_name = [string]
di f f er ent i al s_dmi g_name = ZQ
If job is WHITEBOX, defines the name of the DMIG used to export the
stiffness and damping contribution of all differential elements (DIFF, LSE,
TFSISO and GSE). Adams/Solver (C++) will append the given name to
predefined roots to form the names of the matrices to be exported.
Default is ZZZ.
disp_plot_punch = {string}
di sk_pl ot _punch = pl ot
Prints PLOT, PUNCH or both in the DISP cards. Options for the string:
plot, punch, and both.
Default is "both".
109 LINEAR
C++Commands
displacement_output_channel {
name = [string]
marker_id = [integer]
marker_name = [string]
mode = { local | global }
}
di spl acement _out put _channel {
name = oc_1
mar ker _by_name = model . MARKER_77
mode = l ocal
}
Creates an output channel.
Field name is required; the given name is case sensitive.
Either marker_id or marker_name must be specified to define the location
of the output channel.
Field mode is optional and it specifies whether the output channel reports
global or local information about the specified MARKER; the default value
is "local".
dload_card_number = [integer]
dl oad_car d_number = 558
Sets the number of the first DLOAD card. See
dload_card_number_increment.
Default is 100.
Adams/Solver
C++Commands
110
dload_card_number_increment = [integer]
dl oad_car d_number _i ncr ement = 2
Sets the increment when numbering DLOAD cards.
Default is 1.
dphase_card_number = [integer]
dphase_car d_number = 658
Sets the number of the first DPHASE card. See
dphase_card_number_increment.
Default is 400.
dphase_card_number_increment = [integer]
dphase_car d_number _i ncr ement = 2
Sets the increment when numbering DPHASE cards.
Default is 1.
111 LINEAR
C++Commands
eigc_method = [hess | clan]
ei gc_met hod = cl an
Specifies the method of eigenvalue extraction in the exported EIGC card.
Option hess refers to the upper Hessenberg method. Option clan refers to
the Complex Lanczos method. When using the clan option, use the
clan_region directive as many times as required.
Default is hess.
end_frequency = [real]
end_f r equency = 1. 0E+09
Sets the final value of the frequency for a frequency response analysis.
export_all_markers = { yes | no }
expor t _al l _mar ker s = yes
Causes to export all rigid and flexible MARKERS.
Ignored if job is WHITEBOX.
Default is "no".
Adams/Solver
C++Commands
112
export_cbush= {yes | no }
expor t _cbush = yes
If this directive is set to yes, Adams/Solver will attempt to export selected
forces using CBUSH cards. The selected forces are singled out using the
directives force_editable_by_id and force_editable_by_name. If the
attempt fails, the force will be exported using DMIG cards.
Default is yes.
export_external = { yes | no }
expor t _ext er nal = no
If this directive is set to yes, Adams/Solver exports EXTERNAL objects
using CTRIA3 elements.
Default is yes.
export_graphics = { yes | no }
expor t _gr aphi cs = no
If this directive is set to yes, Adams/Solver exports a set of cards defining
the geometric elements found in the Adams model. Cylinders, boxes,
spheres, etc. are exported as CQUAD4 elements fully constrained to the
corresponding exported parts. All the elements used to define the geometry
of the Adams model have negligible mass hence, results are not affected.
Default is "yes".
113 LINEAR
C++Commands
export_ground_markers = { yes | no }
expor t _gr ound_mar ker s = yes
Causes to export all ground MARKERS found in the Adams model.
Default is "no".
export_markers_by_id = [list of ranges]
expor t _mar ker s_by_i d = 1, 3, 45- 52, 88
Causes to export rigid, flexible or ground MARKERS. An error is triggered
if the given ID corresponds to a floating, curve or surface MARKER.
export_markers_by_name = [list of string]
expor t _mar ker s_by_name = model . MARKER_8,
model . MARKER_77
Causes to export rigid, flexible or ground MARKERS. An error is triggered
if the given name corresponds to a floating, curve or surface MARKER.
Adams/Solver
C++Commands
114
export_mode_shapes = [yes | no]
expor t _mode_shapes = yes
If this directive is set to yes, Adams/Solver exports a punch file (*.pch) with
mode shape information of a subset of GRIDs and SPOINTs of the model.
Only GRIDs corresponding to the CM of parts and SPOINTs
corresponding to flexible bodies and differential states are exported.
Default is no
export_rbe_connectivity = [yes | no]
expor t _r be_connect i vi t y = yes
If this directive is set to yes, Adams/Solver exports a file with RBE2 cards
restoring the connectivity lost when using the option file_name_style=C.
Default is "no"
115 LINEAR
C++Commands
export_residuals= {yes | no }
expor t _r esi dual s = yes
If this directive is set to yes, Adams/Solver exports the residual DMIG
cards obtained by subtracting the stiffness matrix of a CBUSH from the
exact DMIG matrix corresponding to the exact linearization of a force.
For example, assume we have a VFORCE/567 with its corresponding exact
linearization given by matrix K1. Assume Adams/Solver exports this force
as a CUBSH with a corresponding stiffness matrix K2. The residual is K1-
K2. Hence, if you use both, directive export_cbush = yes and directive
export_residual = yes, then the eigensolutions in both, Adams and Nastran
will match.
Notice the residuals are not always small due to an intrinsic limitation of
linear and non linear Finite Element codes performing a premature
linearization for eigenvalue computation.
Ignored if directive export_cbush is set to no.
Default is yes
export_spc_connectivity = {yes | no }
expor t _spc_connect i vi t y = yes
If this directive is set to yes and the directive file_name_style = C is used,
Adams/Solver exports breaks the topological connection created by
RJOINTs and CBUSH cards and exports a set of SPC cards to be used by
external scripts to restore the topological connections.
Ignored if directive file_name_style is not set to C.
Default is no.
Adams/Solver
C++Commands
116
export_spdp = {yes | no}
expor t _spdp = no
If this directive is set to yes, Adams/Solver exports graphical SPDP objects
using CQUAD4, RBE2, RJOINT and GRID cards to represent spring
damper graphics.
SPDP objects are not exported if using directive file_name_style = C.
Default is "yes".
export_tic_cards = {yes | no}
expor t _t i c_car ds = yes
If this directive is set to yes, Adams/Solver exports the cards corresponding
to transient initial conditions.
Default is "no".
file_include_extension= [string]
f i l e_i ncl ude_ext ensi on = . bdf 2
When using the directive file_name_style = A, it specifies the extension of
all included files except the main file defining the model.
Ignored if directive file_name_style is different than A.
Default is .bdf.
117 LINEAR
C++Commands
file_name_style= {A | B | C }
f i l e_name_st yl e = C
If this directive is set to A and the export command option FILE is FILE =
path, the exported files are:
path.dat (main file)
path_MODEL.nas (model file, all parts, flexible bodies and joints)
path_DMIGNAMES.bdf (several files, one file per DMIG)
Notice the ".dat", ".nas" and ".bdf" extensions are appended to the given
path. You may change the extensions using directives
main_file_include_extension, model_include_extension, and
file_include_extension.
If this directive is set to B and the export command option FILE is FILE =
path.ext, the exported files are:
path.ext
path_MODEL.ext
path_DMIGNAMES.ext
Notice that the extension is obtained from the LINEAR/EXPORT
command. The content of the exported files is identical to that of style A.
If this directive is set to C and the export command option FILE is FILE =
path, the exported files are:
path.dat
path_PROPERTY.nas
path_BODY.nas (several file, one per Adams PART)
path_CONNECTIVITY.nas
Notice the extension is appended to the given path.
Default is A.
Adams/Solver
C++Commands
118
flexbody_editable_by_id = [integer], [string]
f l exbody_edi t abl e_by_i d = 9900, FB9900
Causes to export a flexible body. The first argument corresponds to the ID
of the element. The second argument is a suffix used to create the DMIG
cards.
flexbody_editable_by_name = [string], [string]
f l exbody_edi t abl e_by_name = model . FLEX_BODY_9900,
FB9900
Causes to export a flexible body. The first argument corresponds to the
name of the element. The second argument is a suffix used to create the
DMIG cards.
force_card_number = [integer]
f or ce_car d_number = 558
Sets the number of the first FORCE or MOMENT card. See
force_card_number_increment.
Default is 300.
119 LINEAR
C++Commands
force_card_number_increment = [integer]
f or ce_car d_number _i ncr ement = 2
Sets the increment when numbering FORCE and MOMENT cards.
Default is 1.
force_editable_by_id = [string], [integer], [string]
f or ce_edi t abl e_by_i d = beam, 979, B979
Causes to export an applied force. The first string argument determines the
type of applied force. The available types are: sforce, springdamper,
bushing, beam, field, vforce, vtorque, friction, or gforce. The second
argument corresponds to the ID of the element. The third argument is a
suffix used to create the DMIG cards.
force_editable_by_name = [string], [string], [string]
f or ce_edi t abl e_by_name = beam, model . BEAM_979,
B979
Causes to export an applied force. The first string argument determines the
type of applied force. The available types are: sforce, springdamper,
bushing, beam, field, vforce, vtorque, friction, or gforce. The second
argument corresponds to the name of the element. The third argument is a
suffix used to create the DMIG cards.
Adams/Solver
C++Commands
120
force_input_channel {
name = [string]
marker_id = [integer]
marker_name = [string]
dof = { x | y | z | rx | ry | rz }
actuator_name = [string]
mode = { local | global }
}
f or ce_i nput _channel {
name = i c_1
mar ker _by_name = model . MARKER_88
dof = r x
act uat or _name = act uat or _1
mode = l ocal
}
Creates an input channel.
Field name is required; the given name is case sensitive.
Either marker_id or marker_name must be specified to define the location
of the input channel.
The dof field is optional and it specifies the coordinate where the input
channel is acting upon; default value is "x".
Field actuator_name is required and it must refer to a previously defined
actuator_swept_sine data.
Field mode is optional and it specifies whether the input force acts globally
or on the local coordinate system defined by the MARKER; the default
value is "local".
121 LINEAR
C++Commands
forces_dmig_name = [string]
f or ces_dmi g_name = FQ
If job is BLACKBOX, defines the name of the DMIG cards used to export
the stiffness matrix. If job is WHITEBOX, defines the name of the DMIG
used to export the stiffness contribution of all forces and flexible bodies
which have not been singled out by other directives. See for example
force_editable_by_name.
Default is VVV.
frequency_card_number = [integer]
f r equency_car d_number = 770
Sets the number of the FREQ1 or FREQ2 card to be exported.
Default is 600.
frequency_response_subcase {
number = [integer]
input_channel_names = [list of string]
output_channel_names = [list of string]
}
Adams/Solver
C++Commands
122
f r equency_r esponse_subcase {
number = 107
i nput _channel _names = i c_1, i c_2, i c_3
out put _channel _names = oc_7, oc_8
}
Creates a subcase for a frequency response analysis.
Field number is required; defines the number of the SUBACASE card.
Field input_channel_names is required and it is a list of input channels
names previously defined in the file. All names are case sensitive.
Field output_channel_names is required and it is a list of output channel
names previously defined in the file. All names are case sensitive.
graphics_grid_offset= [integer]
graphics_grid_offset = 5000
Specifies the grid point identification number of the first GRID card used
to export graphical information.
Default is 4000000.
grid_offset = [integer]
grid_offset = 1000
Specifies the grid point or spoint identification number of the first GRID or
SPOINT card exported. All other GRID and SPOINT identifications will
be sequentially numbered. This option is ignored if the directive
use_adams_ids is set to true.
Default is 1.
123 LINEAR
C++Commands
ignore_errors = { yes | no }
i gnor e_er r or s = yes
Causes Adams/Solver (C++) to ignore errors found processing the
configuration file. For example, if an export_marker_by_id directive
specifies a non existing MARKER, the directive will be ignored and the
export job will be performed.
Default is "no".
include_directory= [string]
i ncl ude_di r ect or y = myi ncl ude
Specifies the include directory to be used in all INCLUDE cards. Use a
blank string to override the default.
Default is the path of to the exported file used in the LINEAR/EXPORT
command.
initial_dmig_set = [integer]
i ni t i al _dmi g_set = 50
Specifies the number of the first SET to create a list of DMIG names.
Default 1
load = [integer]
l oad = 4
Sets the number of LOAD card.
Default is 1.
Adams/Solver
C++Commands
124
main_file_include_extension = [string]
mai n_f i l e_i ncl ude_ext ensi on=. dat a
When using the directive file_name_style = A, it specifies the extension of
the main exported file. This extension is appended to the name specified in
the LINEAR/EXPORT command.
Default is .dat
marker_offset = [integer]
mar ker _of f set = 30000
If using the directive use_adams_ids = yes, this offset is used to generate
the GRID identification numbers using the Adams IDs.
Default is 1000000
material_card_number= [integer]
mat er i al _car d_number = 500
Specifies the material identification number of the first MAT1 card used to
export graphical information.
Ignored if directive use_wireframe is set to true.
Default is 1000.
125 LINEAR
C++Commands
matrix_entry_zero_tolerance = [real]
mat r i x_ent r y_zer o_t ol er ance = 1. e- 06
Defines the tolerance Adams/Solver (C++) uses to determine whether a
matrix entry is zero.
Default is 1.E-08.
model_include_extension = [string]
model _i ncl ude_ext ensi on = . bdf
When using the directive file_name_style = A, it specifies the file extension
of the main included file defining the model.
When using the directive filename_style = C, it specifies the file extension
of all included files.
Caution: You should include a period when defining this extension.
Ignored if using directive file_name_style = B
Default is .nas
mpc_set = [integer]
mpc_set = 700
Defines the number of the MPC set.
Default is 1.
Adams/Solver
C++Commands
126
number_of_eigenvalues = [integer]
number _of _ei genval ues = 40
Sets the number of eigenvalues specified in the EIGC card.
Default is the size of the state matrix [A].
param_post = [integer]
par am_post = 1
Sets the value of the PARAM POST card.
Default is 0.
pointmass_offset = [integer]
poi nt mass_of f set = 30000
If using directive use_adams_ids = yes, this offset is used to generate the
GRID identification numbers using the Adams IDs of POINTMASS
objects.
Default is 2000000
127 LINEAR
C++Commands
remove_unused_items=[string] [,string]
r emove_unused_i t ems = cbush, gr i d
Removes empty CBUSH cards and/or GRID cards not being used.
By default, no cards are removed.
rload1_card_number = [integer]
r l oad1_car d_number = 558
Sets the number of the first RLOAD1 card. See
rload1_card_number_increment.
Default is 200.
rload1_card_number_increment = [integer]
r l oad1_car d_number _i ncr ement = 2
Sets the increment when numbering RLOAD1 cards.
Default is 1.
set_card_number = [integer]
Adams/Solver
C++Commands
128
set _car d_number = 558
Sets the number of the first SET card. See set_card_number_increment.
Default is 900.
129 LINEAR
C++Commands
set_card_number_increment = [integer]
set _car d_number _i ncr ement = 2
Sets the increment when numbering SET cards.
Default is 1.
single_included_dmig = {yes | no}
si ngl e_i ncl uded_dmi g = yes
Sets the flag to either create a single included file or multiple included files.
If the option "yes" is used, all DMIG and graphical information is exported
in a single included file.
Default is "no".
small_mass= [real]
smal l _mass = 1
Specifies the value of the small mass to be set to zero-mass parts during the
export process. After the export process is finished, zero-mass parts are
restored to their original configuration.
If this value is zero, Adams/Solver will use the smallest mass in the model
divided by 1000.
Default is 0.
Adams/Solver
C++Commands
130
solution_number = [integer]
sol ut i on_number = 108
Specifies the solution number to be exported.
Only solution 107 and 108 are currently supported.
Default is 107.
spacing_frequency = { log | linear }
spaci ng_f r equency = l og
spaci ng_f r equency = l i near
Sets the number of steps in which the frequency range is to be divided.
Default is "linear".
spc_set = [integer]
spc_set = 10
Specifies the set identification number of the SPC card.
Default is 1.
131 LINEAR
C++Commands
spc_set_connectivity= [integer]
spc_set _connect i vi t y = 1
Specifies the set identification number of the first SPC card used to export
the broken connectivity of the model when these two conditions met:
1. The directive export_spc_connectivity is set to true.
2. The directive file_name_style is set to C.
Default is 30000.
split_dmigs = [yes|no]
spl i t _dmi gs = no
Specifies whether DMIG matrices are split into a symmetric and an
antisymmetric matrices.
Optional if solution 108 is specified
Default is yes.
spoint_offset = [integer]
spoi nt _of f set = 30000
If using directive use_adams_ids = yes, this offset is used to generate the
SPOINT identification numbers using the Adams IDs.
Default is 3000000
Adams/Solver
C++Commands
132
steps_frequency = [integer]
st eps_f r equency = 50
Sets the number of steps in which the frequency range is to be divided.
subtitle = [string]
subt i t l e = Ann Ar bor r un - J . P. & L. L.
Defines the SUBTITLE card.
Default is a string showing the current simulation time.
tabled1_card_number = [integer]
t abl ed1_car d_number = 555
Sets the number of the first TABLED1 card. See
tabled1_card_number_increment.
Default is 500.
tabled1_card_number_increment = [integer]
t abl ed1_car d_number _i ncr ement = 3
Sets the increment when numbering TABLED1 cards.
Default is 1.
133 LINEAR
C++Commands
tic_set= [integer]
t i c_set = 500
Specifies the set identification number of the TIC cards used to export the
current velocities of the model.
Caution: Adams/Solver does not export the IC Case Control command.
Default is 2.
title = [string]
t i t l e = Expor t 1. 2. 22 - Type 722. 7- b
Defines the TITLE card.
Default is "ADAMS2NASTRAN Export Utility".
use_adams_ids = [yes | no]
use_adams_i ds = yes
If this directive is set to yes, Adams/Solver exports identification numbers
of GRIDS, RJOINTS, RBE2, etc. using the Adams IDs and an offset.
For example. GRIDs corresponding to the CM of PART/77 and PART/199
would be exported as GRID 100077 and GRID100199 respectively
(assuming the offset is 100000).
Default is yes.
Adams/Solver
C++Commands
134
use_damping = {yes | no }
use_dampi ng = no
Specifies to use damping in the linearization analysis.
Default is "yes".
use_includes = { yes|no}
use_i ncl udes = no
By default, all DMIG and graphical information is exported using included
files. You may have the export process export either a set of multiple files or
a single file. This option can be used to export a file without using included
files.
Default is "yes".
use_plotel = {yes | no }
use_pl ot el = yes
If this directive is set to yes, Adams/Solver exports linear graphical objects
using PLOTEL cards.
Ignored if using directive use_wireframe = yes.
Default is no.
135 LINEAR
C++Commands
use_rjoints={yes|no}
use_r j oi nt s = no
If this directive is set to yes, Adams/Solver exports Adams joints using
RJOINT cards, if possible. Otherwise, the Adams joint is exported using
MPC cards.
Default is yes.
use_short_part_file_names = [yes | no]
use_shor t _par t _f i l e_names = yes
Specifies using shorter file names for included files.
Default is no.
use_view_names = [yes | no]
use_vi ew_names = no
Specifies using Adams/View or Adams/Car names. If this directive is set to
"no", the exported names are a combination of the object type and its
Adams ID.
Optional in all solution sequences.
Default is "yes".
use_wireframe={yes | no }
Adams/Solver
C++Commands
136
5.3.5 Configuration file examples
A typical configuration file using solution 107 is the following:
$ Conf i gur at i on f i l e pr epar ed by J . Smi t h
$ Model 1. 45- 7- a_2. 33. XPRWS/ USA@@3410001109ABD- 7a' St r A7' / 88
$
use_wi r ef r ame = yes
If this directive is set to yes, Adams/Solver exports all graphical
information using PLOTEL cards.
Default is no.
verbatim {
}
ver bat i m{
$ Added t he f ol l owi ng cont r ol car ds
ECHO=BOTH
}
Adds a set of cards to the case control cards.
All lines between the curly brackets are printed to the exported file.
verbose_names=[ yes | no ]
ver bose_names = no
If this directive is set to yes, Adams/Solver exports names using a verbose
approach.
Default is yes.
137 LINEAR
C++Commands
use_dampi ng = yes
gr i d_of f set = 1000
$
$ Al l MARKERS i n speci f i ed r ange
expor t _mar ker s_by_i d = 1- 99
$
$ We need t hi s MARKER l ocat ed on gr ound
expor t _mar ker _by_name = model . PART_999. MARKER_919
$
$ Expor t SFORCE/ 7, t o be r epl aced by cust omf or ce
f or ce_edi t abl e_by_i d = sf or ce, 7, SF7
$ End
A typical configuration file using solution 108 is the following:
$ Conf i gur at i on f i l e pr epar ed by J . Smi t h J r .
$ Model 1. 45- 7- a_2. 33. XPRWS/ USA@@3410001109ABD- 7a' St r A7' / 89
$
$ One act uat or , t wo i nput s, one out put , t wo subcases
act uat or _swept _si ne {
name = act 1
magni t ude = 2. 2
phase_angl e = 45D $ 45 degr ees
}
name = i np1
mar ker _i d = 88
dof = X
act uat or _name = act 1
}
name = i np2
mar ker _i d = 88
dof = RZ
act uat or _name = act 1
}
di spl acement _out put _channel {
name = out 1
mar ker _i d = 77
}
number = 100
i nput _channel _names = i np1, i np2
out put _channel _names = out 1
}
number = 200
i nput _channel _names = i np1
Adams/Solver
C++Commands
138
out put _channel _names = out 1
}
begi n_f r equency = 1. 0
end_f r equency = 1000. 0
st eps_f r equency = 20
spaci ng_f r equency = l og
use_dampi ng = yes
gr i d_of f set = 1000
$
$ End
5.3.6 Theoretical background
The BLACKBOX option exports the state space matrix representation of the Adams model following an
exact approach mentioned in section 1.0 above. The BLACKBOX export is straight forward to
implement.
On the other hand, the WHITEBOX option poses a delicate problem. Next sections present the exact
linearization of the equations of motion, an approximate linearization method, and some issues related to
exporting the model to Nastran.
Exact linearization
Lagrange's equations of motion (as assembled by Adams/Solver (C++)) have the following partitioned
form:
Where the u's are the dependent coordinates and the v's are the independent coordinates. The independent
coordinates are not arbitrarily selected but chosen after performing a LU factorization of the constraint
equations using full pivoting. The LU factorization will select the best choice of coordinates for the
independent states.
The first step to exactly linearize the system is to define matrix P as:
Multiplying the top row of the equations of motion by P and summing it to the second one, the Lagrange
multipliers are eliminated:
( ) 0 ,
4
2
3
1
= u
)
`
=
(
(
(
u
u
+
)
`
v u
f
f
v
u
M
M
M
M
v
u
v
T
u
T

T
v
u
|
|
.
|
\
|
u u =
1
P
139 LINEAR
C++Commands
(Eq. 1)
Differentiating the constraint equations one time we obtain:
A second differentiation returns:
Partitioning the first term of the last equation we get:
Rearranging this result we find:
Putting this result into Eq. 1, the ODE (minimal representation) of the equations of motion is found to be:
Notice that this equation has a functional dependency on both u and its first derivatives. However, both
quantities can always be obtained from the constraint equations.
The final step is to perturb the ODE to obtain the linearized form:
(Eq. 2)
Adams/Solver (C++) computes the equation above by using a different yet equivalent approach. Equation
above is important because it shows that the contribution of each element can be singled out and
exported. However, for the general dynamical case, the contribution of each element (inertial element,
force or constraint) is heavily distributed all over the state matrices making very difficult the replacement
of say an exported force by a new set of Nastran cards.
Approximate linearization
An approach followed by several computer codes consists of first linearizing the constraint equations, the
equations motion and then assembling the ODE. The linearized constraints are:
(Eq. 3)
M
3
PM
1
+ ( )u
M
4
PM
2
+ ( )u
f
u
Pf
u
+ = +
u
q
q
u
t
0 = +
u
q
q
u
q
q
( )
q
q
2u
q
t
q
u
tt
0 = + + +
u
u
u
u
u
u
u
q
q
( )
q
q
2u
q
t
q
u
tt
0 = + + + +
P
2
1 1
+ =
|
|
.
|
\
|
+ +
|
|
.
|
\
|
=

v u
q q q v u
T
tt qt q q u v u

M
3
P
T
PM
1
P
T
M
4
PM
2
+ + + ( )u
M
3
P + M
1
( ) + + f
v
Pf
u
+ =
o M
3
P
T
PM
1
P
T
M
4
PM
2
+ + + ( )u
M
3
P + M
1
( ) + + { } o f
v
Pf
u
+ ( ) =
u
u
ou u
u
ou 0 = +
Adams/Solver
C++Commands
140
Redefining matrix P as
we obtain that

Notice that in this case matrix P is numerically equal to matrix P defined in the previous section.
However, in this case matrix P is a constant; therefore taking two time derivatives of the last expression
we arrive to:
(Eq. 4)
The linearized equations of motion have this form:
(Eq. 5)
Multiplying the first row by P and summing it to the second row we find:
Combining this result with Eq. 4 we arrive to:
(Eq. 6)
This is the set of assembled equations of motion obtained from the linearized constraint equations
(Eq. 3) and the linearized equations of motion (Eq. 5).
Feasibility of the export approach
Comparing Eq. 6 and Eq. 2 we notice that, in the general case, eigenvalues computed by those two
equations do not match. The complete variation of Eq. 2 involves terms that are missing in Eq. 2. (Notice
that matrix P in Eq. 6 is a constant.)
However, both Eq. 6 and Eq. 2 will produce the same eigenvalues only for the static case. If both
velocities and accelerations are zero, several terms drop from Eq. 2 and matching expressions are
obtained except for the right-hand side (applied forces). The variation of the right-hand side on Eq. 2 is:
T
v
u
|
|
.
|
\
|
u u =
1
P
ou P
T
ou =
ou
P
T
ou
=
)
`
o
o
= o
(
(
(
+
)
`
o
o
(
v
u
f
f
v
u
M
M
M
M
v
T
u
T
4
2
2
1

M
3
PM
1
+ ( )ou
M
4
PM
2
+ ( )ou
ofu Pofu + = +
M
3
P
T
PM
1
P
T
M
4
PM
2
+ + + ( )ou
of
u
Pofu + =
o f
v
Pf
u
+ ( ) of
v
Pof
u
oPf
u
+ + =
141 LINEAR
C++Commands
which compared with the right-hand side of Eq. 6 shows that there is a missing term a linear code can not
compute. The solution is to export applied forces as DMIG cards.
Some of the issues addressed during the export job (WHITEBOX option) are the following:
1. The linearization is internally performed using the same coordinates Nastran uses to assemble the
equations of motion. This is accomplished by using Adams/Solver (C++) capability to linearize
the system in terms of user-defined coordinates.
2. The linearized constraint equations (Eq. 3) are evaluated by a two-stages process and exported a
set of MPC cards.
3. The inertia elements (PARTS and POINT_MASS) are exported as CONM2 cards. This
information is taken directly from a mass matrix obtained by temporarily deactivating all
constraints. The mass matrices of flexible bodies are obtained in a similar way.
4. The stiffness and damping contribution of applied forces are computed and exported as DMIG
cards. By default all forces and flexible bodies contributions are dumped into the same set of
DMIGs. The configuration file can be used to single out the contribution of each applied force or
flexible body, however, each singled out element involves one extra linearization.
5. All differential states contributions to the equations of motion are dumped into a set of DMIGs
and SPOINT cards. Currently there are no tools to single out the contribution of differential states.
6. Examples
The command
LI NEAR/ EI GENSOL
computes an eigenanalysis for the Adams model. Adams/Solver (C++) writes the eigenvalues and mode
shapes to the Results file where they can be read and displayed by a postprocessor such as Adams/View.
The command
LI NEAR/ STATEMAT, PI NPUT=10, POUTPUT=20
, FORMAT=MATRI XX FI LE=STATES. MAT
computes state matrices for the Adams model, using PINPUT/10 as inputs and POUTPUT/20 as outputs.
The state matrices are written to file STATES.MAT in MATRIXX format.
7. Applications
There are several areas in which the LINEAR command is required. Some examples include:
1. Eigensolutions provide you with information that may be used in assessing stability of the Adams
model. If you import control systems descriptions or distributed elasticity data from external
sources, you can verify the stability of their Adams models.
2. Eigendata computed by Adams/Solver (C++) can be used to validate Adams models against
eigendata from external sources.
Adams/Solver
C++Commands
142
3. State matrices descriptions can be used in designing control systems for Adams models. This
description is suitable for computing frequency response data in matrix manipulation software
packages (see the PINPUT, POUTPUT, and VARIABLE statements).
4. State matrices output by Adams/Solver (C++) in the MATRIXX format are suitable for being read
into a second Adams model with a MATRIX statement. These matrices can form the definition
of a dynamical system defined by an LSE statement in the second Adams model.
5. Exported linearized model as Nastran bulk data decks using the "whitebox" option can be used in
eigensolutions, frequency response analysis using Nastran. The exported model can be further
edited to perform other types of solution sequences in Nastran.
7.1 Eigen analysis application
Consider a model of an inverted pendulum on a sliding cart as shown in the figure shown next. The listing
of the Adams/Solver (C++) dataset for this model is shown in Listing 1 (see Appendix).
Figure 8 Inverted Pendulum on Sliding Cart Model
The sliding cart in this model is represented by PART/1 and the inverted pendulum is represented by
PART/2. PART/1 slides along the global x axis in translational joint, JOINT/1, while PART/2 can rotate
about the axis of revolute joint, JOINT/2. PART/1 is connected to ground by a SPRINGDAMPER/1.
TFSISO/1 represents an actuator connected between PART/1 and PART/2. Force generated by this
actuator is applied on the two parts by SFORCE/1. No input is applied to the actuator for the present. To
assess stability of this model, execution of Adams/Solver (C++) is initiated. Once Adams/Solver (C++)
verifies that the model data is syntactically correct, issue the SIMULATE/STATIC command. On
achieving static equilibrium, issue the LINEAR/EIGEN command. Eigenvalues reported by
Adams/Solver (C++) are shown in the table below.
Model Eigenvalues
EIGENVALUES
Number Real (cycles/unit time) Imag. (cycles/unit time)
1 5.00909210E-02 0.00000000E+00
2 -5.00924580E-02 0.00000000E+00
143 LINEAR
C++Commands
The table shows that the system has three stable and one unstable mode. To determine the cause of this
instability, use the data produced by Adams/Solver (C++) (.res, .adm, and so on) in Adams to display the
deformed mode shapes of the model.
Figure 9 (a) and (b) show mode shapes for mode 1, which is unstable, and mode 4, which is stable.
Figure 9 Deformed Mode Shape 4(a) and Deformed Mode Shape 4 (b)
Figure 9 (a) shows that PART/1 is essentially stationary while PART/2 is moving. You can conclude that
PART/2 is the cause of the instability in this model. This is an expected result for this model, since the
inverted pendulum is at an unstable operating point. It is obvious that disturbing the pendulum will cause
it to swing about the revolute joint axis.
As illustrated by this example, viewing mode shapes in a graphical display can provide very significant
insight into the dynamic behavior of the model. In complicated Adams models, this insight is vital in
understanding the model dynamics. In Example 2: State Matrices Output below, based on the state
matrices computed for this model, a feedback control law will be designed to stabilize this model.
7.2 State matrices output
This section presents the design and implementation of a control system for the Adams model described
in Section 7.1. The purpose of the control design exercise is to design a feedback controller to attempt to
stabilize the inverted pendulum. For control design purposes, the state matrix representation of the
Adams model is required and is generated by the LINEAR/STATEMAT command.
3 -3.18309800E+01 0.00000000E+00
4 -3.17994185E-01 +/- 6.36188992E-01
Adams/Solver
C++Commands
144
Stabilization of this model requires that PART/2 maintain its inverted vertical position despite external
disturbances applied on it. External disturbances considered here are gravity acting vertically downwards
and an external force applied to the pendulum in the x-direction. On sensing a deviation of the pendulum
from the desired position, the control law determines an appropriate signal to apply to actuator TFSISO/1
to restore PART/2 to its desired position. The control law operates on the basis of measuring output
signals from the plant and then computes a signal to apply to the actuator.
As shown in Figure 10 for the present model, 3 signals are output by the plant. VARIABLE/10 is a
measurement of the relative x displacement between PART/1 and PART/2. VARIABLE/20 is a
measurement of the relative x velocities between the two parts. VARIABLE/30 is the integral of the
relative x displacements between the two parts. These 3 signals are designated as outputs from the plant
by POUTPUT/1.
Input to the plant, that is, input signal to the actuator, is defined as VARIABLE/2. This is designated as
input to the plant by PINPUT/1. Adams/Solver (C++) implementation of the input/output structure and
the external disturbances is shown in Listing 2: Plant Input/output Specification (see Appendix). This
implementation, when combined with the plant model as shown in dataset 1 in. This implementation,
when combined with the plant model as shown in dataset 1 in FILE=c results in the open-loop model.
When the open-loop model is complete, an Adams/Solver (C++) execution session is initiated.
Figure 10 Open-Loop Model
The model is read into Adams/Solver (C++). After Adams/Solver (C++) verifies the model data syntax,
issue the SIMULATE/STATIC command to determine the equilibrium position. On achieving the
equilibrium position, issue the LINEAR/EIGEN, NOVECTOR command to verify the eigenvalues of the
model. The next table shows the eigenvalues for the open-loop model.
Open-Loop Eigenvalues
EIGENVALUES
1 -2.66440631E-17 0.00000000E+00
2 5.00909210E-02 0.00000000E+00
3 -5.00924580E-02 0.00000000E+00
4 -3.18309800E+01 0.00000000E+00
5 -3.17994185E-01 +/- 6.36188992E-01
145 LINEAR
C++Commands
The table shows that the open-loop model has one eigenvalue more than the model in Eigenanalysis
Application. This is due to the introduction of the relative displacement integrator TFSISO/2 in the open-
loop model. To linearize the model and compute the state matrices, issue the LINEAR/STATEMAT,
PINPUT=1, POUTPUT=1, file=adams.mat command. Adams/Solver (C++) linearizes the model and
writes the state matrices in the default format to adams.mat file. Contents of the ADAMS.MAT file are
in Listing 3: State Matrices (FSAVE Format) for the Open-Loop Model (see Appendix). The Adams/Solver
(C++) session then terminates. You may design a controller by reading the ADAMS.MAT file into the
control design package exercising various control design methodologies. The description of the control
design step is beyond the scope of the present document. A text on this subject or documentation for
control design software packages should be consulted for further details.
Now that the feedback control has been designed, it needs to be implemented in Adams/Solver (C++) for
a closed-loop simulation (see Listing 4 in the Appendix). The controller designed for this example is a
dynamic compensator. As shown in Figure 11 below, this is implemented in Adams/Solver (C++) as
LSE/1. The A, B and C matrices associated with this LSE are defined by MATRIX/100, 200, and 300,
respectively. Adams/Solver (C++) reads the data for these matrices from a file named incomp.dat (see
Listing 5 in the Appendix). To connect this feedback compensator to the plant model, inputs to LSE/1,
ARRAY/303 are connected to outputs from the plant model. Also, ARRAY/1, which is input to the
actuator, TFSISO/1, is now defined as the output from the compensator, VARIABLE/2. This completes
the closed-loop Adams model. The complete Adams/Solver (C++) dataset for this model Listing 4 (see
Appendix).
Figure 11 Closed-Loop Model
To verify and simulate the closed-loop model, an Adams/Solver (C++) simulation is initiated. The
closed-loop model is first equilibrated in its static position. The eigenvalues for this model are computed
and represented in Table 4 shown next.
Adams/Solver
C++Commands
146
Closed-Loop Eigenvalues
Table 4 above shows that the closed-loop model is stable. The closed-loop model has more eigenvalues
than the open-loop model. This is due to the dynamical state variables introduced by LSE/1. Eigenvalues
for the closed-loop Adams model can be compared with the closed-loop eigenvalues computed in the
control design package. Now that the stability properties of the closed-loop Adams model have been
verified, it can be simulated to obtain its dynamic response. The time profile of the external disturbance
is as shown in Figure 12. The closed-loop model response to external disturbance is as shown in
Figure 13. As illustrated in this figure, the closed-loop model provides complete disturbance rejection for
displacement of PART/2.
Figure 12 Time Profile of External Disturbance
EIGENVALUES
1 -5.35233760E-01 0.00000000E+00
2 -3.18270747E+01 0.00000000E+00
3 -2.37397000E-01 +/- 7.54488218E-02
4 -7.37798519E-03 +/- 1.51611302E-01
5 -5.47796070E-01 +/- 5.12745191E-01
6 -2.43466412E-01 +/- 5.71313964E-01
7 -2.46528313E+01 +/- 1.00614794E+01
147 LINEAR
C++Commands
Figure 13 Closed-Loop System Response
The input signal applied to the actuator and the force generated by the actuator are shown in Figure 14
and Figure 15, respectively.
Adams/Solver
C++Commands
148
Figure 14 Input Signal to Actuator
Figure 15 Force Generated by Actuator
The process of control design and simulation is an iterative one. If the closed-loop system does not
perform as expected, the control design specifications may have to be changed and a new controller
designed to achieve better performance.
149 LINEAR
C++Commands
8. Appendix
Listing 1: Inverted Pendulum Model
ADAMS I nver t ed pendul ummodel .
!
pa/ 99, gr ound
ma/ 99, qp=0, 0, 0, zp =1, 0, 0
!
! ===> Sl i di ng car t <===
pa/ 1, ma=10, i p=10, 10, 10, cm=10
ma/ 10, qp=5, 0, 0 ! CM mar ker .
ma/ 11, qp=5, 0, 2, zp=5, 1, 2 ! r evol ut e j oi nt mar ker .
ma/ 12, qp=3, - 2, - 2 ! gr aphi cs mar ker .
ma/ 13, qp=5, 0, 0, zp=6, 0, 0 ! t r ansl at i onal j oi nt mar ker .
ma/ 14, qp=5, 0, 12
ma/ 15, qp=12, 0, 2 ! act ut at or at t achment poi nt
!
! ===> I nver t ed pendul um<===
pa/ 2, ma=1, cm=20, i p=1, 1, 1
ma/ 20, qp=5, 0, 12 ! CM mar ker .
ma/ 22, qp=5, 0, 12, zp=5, 1, 12 ! gr aphi cs mar ker .
!
j oi nt / 1, t r an, i =13, j =99
j oi nt / 2, r ev, i =11, j =21
!
! ===> Spr i ng damper bet ween car t and gr ound <===
spr i ngdamper / 1, t r an, i =99, j =13, k=200, c=40, l =5
!
gr a/ 2, ci r cl e, cm=20, r =1. 5, seg=20
gr a/ 3, ci r cl e, cm=22, r =1. 5, seg=20
gr a/ 4, cyl i nd, cm=24, l =8. 5, r =0. 25, seg=10, si de=10
gr a/ 5, box, cor n=12, x=9, y=4, z=4
!
! ===> Ext er nal di st ur bance <===
sf or ce/ 1001, i =20, j =99, act i on, t r an,
, f un=st ep( t i me, 0, 0, . 5, 10) - st ep( t i me, 1, 0, 1. 5, 10)
!
! ===>Act uat or Dynami cs<===
t f si so/ 1, num=10, den=1, 0. 005
, u=1, x=2, y=3
ar r ay/ 1, u, var =2 ! i nput si gnal t o act uat or
ar r ay/ 2, x ! act uat or st at e
ar r ay/ 3, y ! f or ce gener at ed by act uat or .
!
! ===>Act uat or f or ce<===
sf or ce/ 1, i =15, j =23, t r ans,
, f unct i on=ar yval ( 3, 1)
!
! ===>I nput t o Act uat or <===
var i / 2, f un=0
!
Adams/Solver
C++Commands
150
accgr av/ kg=- 1
r esul t / f or mat
!
end
Listing 2: Plant Input/output Specification
! ===> PLANT I NPUT/ OUTPUT def i ni t i on <===
! - - - - - - - - - - - - - - - - - - -
!
var / 1, f un=dx( 20, 14)
Di spl acement i nt egr at or
t f si so/ 2, num=1, den=0, 1
, u=20, x=21, y=22
ar r ay/ 20, U, VAR=1
ar r ay/ 21, X
ar r ay/ 22, Y
!
! ===> Out put s <===
var i / 10, f unct i on= var val ( 1) ! di spl acement
var i / 20, f unct i on= vx( 20, 14) ! vel oci t y
var i / 30, f unct i on= ar yval ( 22, 1) ! di spl . i nt egr at ed
!
!
! ===> Pl ant i nput desi gnat i on <===
pi nput / 1, var =2
!
! ===> Pl ant out put desi gnat i on <===
pout put / 1, var =10, 20, 30
!
Listing 3:State Matrices (FSAVE Format) for the Open-Loop Model
MATRI Xx VERSI ON 700 7 2005- 04- 21 19: 31: 36
A 6 6B 6 1C 3 6D 3 1
STATES 3 6PI NPUT 2 1POUTPUT 4 1
A 6 6 0( 3( 1PE25. 17) )
- 3. 99604352126607365e+00 1. 00000000000000000e+00 3. 95647873392680538e- 01
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
- 1. 99802176063303669e+01 0. 00000000000000000e+00 1. 97823936696340263e+00
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
1. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
- 9. 89119683481701345e- 02 0. 00000000000000000e+00 1. 08803165182987160e- 01
0. 00000000000000000e+00 0. 00000000000000000e+00 1. 00000000000000000e+01
4. 02439896739235914e- 02 0. 00000000000000000e+00 - 4. 42683886413159505e- 02
0. 00000000000000000e+00 - 2. 00000000000000000e+02 0. 00000000000000000e+00
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
B 6 1 0( 3( 1PE25. 17) )
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
0. 00000000000000000e+00 2. 00000000000000000e+03 0. 00000000000000000e+00
C 3 6 0( 3( 1PE25. 17) )
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
151 LINEAR
C++Commands
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
0. 00000000000000000e+00 1. 00000000000000000e+01 0. 00000000000000000e+00
1. 00000000000000000e+01 0. 00000000000000000e+00 0. 00000000000000000e+00
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
0. 00000000000000000e+00 0. 00000000000000000e+00 1. 00000000000000000e+00
D 3 1 0( 3( 1PE25. 17) )
0. 00000000000000000e+00 0. 00000000000000000e+00 0. 00000000000000000e+00
STATES 3 6 0( 3( 1PE25. 17) )
2. 10000000000000000e+01 1. 00000000000000000e+00 7. 00000000000000000e+00
2. 10000000000000000e+01 1. 00000000000000000e+00 1. 00000000000000000e+00
2. 10000000000000000e+01 2. 00000000000000000e+00 1. 10000000000000000e+01
2. 10000000000000000e+01 2. 00000000000000000e+00 5. 00000000000000000e+00
3. 00000000000000000e+00 1. 00000000000000000e+00 1. 00000000000000000e+00
3. 00000000000000000e+00 2. 00000000000000000e+00 1. 00000000000000000e+00
PI NPUT 2 1 0( 3( 1PE25. 17) )
1. 00000000000000000e+00 2. 00000000000000000e+00
POUTPUT 4 1 0( 3( 1PE25. 17) )
1. 00000000000000000e+00 1. 00000000000000000e+01 2. 00000000000000000e+01
3. 00000000000000000e+01
Listing 4: Closed-Loop Model
ADAMS I nver t ed pendul umcl osed- l oop model .
!
pa/ 99, gr ound
ma/ 99, qp=0, 0, 0, zp =1, 0, 0
!
! ===> Sl i di ng car t <===
pa/ 1, ma=10, i p=10, 10, 10, cm=10
ma/ 10, qp=5, 0, 0 ! CM mar ker .
ma/ 12, qp=3, - 2, - 2 ! gr aphi cs mar ker .
ma/ 13, qp=5, 0, 0, zp=6, 0, 0 ! t r ansl at i onal j oi nt mar ker .
ma/ 14, qp=5, 0, 12
!
! ===> I nver t ed pendul um<===
pa/ 2, ma=1, cm=20, i p=1, 1, 1
ma/ 20, qp=5, 0, 12 ! CM mar ker .
!
j oi nt / 1, t r an, i =13, j =99
j oi nt / 2, r ev, i =11, j =21
!
! ===> Spr i ng damper bet ween car t and gr ound <===
spr i ngdamper / 1, t r an, i =99, j =13, k=200, c=40, l =5
!
gr a/ 2, ci r cl e, cm=20, r =2, seg=10
gr a/ 3, ci r cl e, cm=22, r =2, seg=10
gr a/ 4, cyl i nd, cm=24, l =8, r =0. 5, seg=10, si de=10
gr a/ 5, box, cor n=12, x=9, y=4, z=4
!
! ===> Ext er nal di st ur bance <===
Adams/Solver
C++Commands
152
sf or ce/ 1001, i =20, j =99, act i on, t r an,
, f un=st ep( t i me, 0, 0, . 5, 10) - st ep( t i me, 1, 0, 1. 5, 10)
!
! ===>Act uat or Dynami cs<===
t f si so/ 1, num=10, den=1, 0. 005
, u=1, x=2, y=3
ar r ay/ 1, u, var =2 ! i nput si gnal t o act uat or
ar r ay/ 2, x ! act uat or st at e
ar r ay/ 3, y ! f or ce gener at ed by act uat or .
!
! ===>Act uat or f or ce<===
sf or ce/ 1, i =15, j =23, t r ans,
, f unct i on=ar yval ( 3, 1)
!
!
! ===> PLANT OUTPUT def i ni t i on <===
! - - - - - - - - - - - - - - - - - - -
!
var / 1, f un=dx( 20, 14)
Di spl acement i nt egr at or
t f si so/ 2, num=1, den=0, 1
, u=20, x=21, y=22
ar r ay/ 20, u, var =1
ar r ay/ 21, x
ar r ay/ 22, y
!
! ===> Out put s <===
var i / 10, f unct i on= var val ( 1) ! di spl acement
var i / 20, f unct i on= vx( 20, 14) ! vel oci t y
var i / 30, f unct i on= ar yval ( 22, 1) ! di spl . i nt egr at ed
!
!
!
! ===> Pl ant out put desi gnat i on <===
pout put / 1, var =10, 20, 30
!
! ===>Feedback compensat or <===
! - - - - - - - - - - - - - - - - - - - -
!
l se/ 1, a=100, b=200, c=300,
, x=101, y=202, u=303, i c=404
!
ar r ay/ 101, x ! compensat or st at e
ar r ay/ 202, y ! compensat or out put
ar r ay/ 303, u, var = 10, 20, 30 ! compensat or i nput
ar r ay/ 404, i c, num=0, 0, 0, 0, 0, 0
!
mat r i x/ 100,
, f i l e=i ncomp. mat , name=ac
mat r i x/ 200,
, f i l e=i ncomp. mat , name=bc
mat r i x/ 300,
, f i l e=i ncomp. mat , name=cc1
!
153 LINEAR
C++Commands
! ===> Feedback si gnal f r omcompensat or t o act uat or <===
var i abl e/ 2, f un=- ar yval ( 202, 1)
!
accgr av/ kg=- 1
r esul t / f or mat
!
End
Listing 5: "incomp.mat" Input Data file
MATRI Xx VERSI ON 700 3 04- OCT- 91 15: 27
AC 6 6BC 6 3CC1 1 6
AC 6 6 0( 1P3E25. 17)
- 1. 00799962154710574E+01 9. 75162440467575053E- 01 9. 98460749273361898E+01
9. 61406957584617916E- 01 3. 11437948419828955E- 03 - 1. 78574044858736743E+04
- 8. 50683303123077716E- 01 - 4. 98921809045884790E- 01 1. 01587769607181722E+00
1. 14325442554075640E+00 - 4. 49484043101296749E- 01 - 1. 69576019090885748E+04
9. 98009512743940519E+00 2. 48375595324249708E- 02 - 9. 98470640470196713E+01
3. 85930424153820839E- 02 - 3. 11437948419828955E- 03 1. 79036593612407414E+04
- 1. 48327577193440696E- 01 4. 98921809045884790E- 01 - 1. 02576889290663420E+00
- 1. 14325442554075640E+00 4. 49484043101296749E- 01 1. 74318979368853470E+04
- 1. 20450308829068348E- 01 7. 73595535159733033E- 02 - 1. 23564688768258060E- 01
- 4. 73156382486152438E- 01 - 1. 34087821455120393E+00 2. 82840625758381648E+04
4. 02439896739235914E- 02 0. 00000000000000000E+00 - 4. 02439896739235858E- 01
0. 00000000000000000E+00 0. 00000000000000000E+00 - 2. 09248210623341492E+02
BC 6 3 0( 1P3E25. 17)
1. 38436380363864547E- 01 - 4. 98921809064772792E- 01 1. 12468086129738198E+00
1. 14325442558403734E+00 5. 50515956881686863E- 01 - 9. 30005800767228163E- 01
- 9. 98009512743940519E+00 - 2. 48375595324249708E- 02 9. 98470640470196713E+01
9. 61406957584617916E- 01 3. 11437948419828955E- 03 - 1. 36246052474731605E+04
1. 20450308829068348E- 01 - 7. 73595535159733033E- 02 1. 23564688768258060E- 01
4. 73156382486152438E- 01 1. 34087821455120393E+00 2. 08671855656208993E- 01
CC1 1 6 0( 1P3E25. 17)
2. 11639961920025588E+00 8. 47833595164392051E+00 - 2. 13952705688378986E+00
- 8. 71548396554230820E+00 - 1. 41421356238469098E+01 4. 62410531167074812E- 03
Adams/Solver
C++Commands
154
LSOLVER
The LSOLVER command allows the user to change the linear solver used by the Adams/Solver (C++).
The linear solver is invoked multiple times throughout the simulation to compute corrections in the
system state.
Format
Arguments
Prior to Adams 2012, the Calahan solver was the default solver for all Adams models. This solver
performs a symbolic factorization of the linear system and is consequently very fast and accurate and for
all models except those that are very large.
The UMF solver (Unstructured Multi-Frontal) uses a very different solution technique than the Calahan
solver. The advantages of the UMF solver are 1) reduced memory use for large models, 2) better
performance for large models and 3) ability to use SMP parallelism for the linear system solution. Very
generally, the UMF solver begins to show an advantage over the Calahan solver when the number of
degrees of freedom in the model exceeds 5,000. Note, however, that for some models, like simply-
connected long chains, the Calahan solver can be superior even when the number of degrees of freedom
is much larger.
When the LSOLVER/ is set to AUTO (the default) the particular solver used depends only on the number
of equations in the system. The user can determine this transition with the environment variable
ADAMS_SPARSE_SOLVER_SWI TCH_AT
AUTO Specifies that Adams/Solver (C++) is to automatically choose the most appropriate
solver based on the model being solved. This is the default setting.
CALAHAN Specifies that Adams/Solver (C++) is to use the CALAHAN solver exclusively. The
Calahan solver is usually fastest for most models.
UMF Specifies that the Adams/Solver (C++) is to use the Unstructured Multi-Frontal sparse
matrix solver. This solver is faster for very large models.
155 LSOLVER
C++Commands
For models with number of equations smaller than the ADAMS_SPARSE_SOLVER_SWI TCH_AT, the
Calahan solver will be used. Models with more equations will use the UMF solver. If the environment
variable is not explicitly set it will default to 1 million.
Tip: The CALAHAN and UMF solvers use different strategies for picking pivots during the
linear solution. One may work better on a particular model than the other and the
simulation results from the different solvers may have small differences.
The UMF solver is built on the BLAS (Basic Linear Algebra Subprograms) library and
comes with a generic implementation of the BLAS library for all architectures.
However, using a BLAS library that is optimized for the specific architecture will
usually result in a substantial performance benefit. These optimized BLAS libraries are
typically supplied by the hardware vendor.
On Linux systems, the UMF solver will automatically search for the Intel MKL BLAS
libraries in locations defined by the LD_LIBRARY_PATH environment variable.
On Windows and other Unix systems, or if a non Intel MKL BLAS library is desired on
Linux, the environment variable BLASLIB should be defined giving the full path to the
desired library. If the BLAS implementation is dependent on multiple libraries, (as is
the case for MKL 10+) then BLASLIB should be defined as the paths to all of the
necessary libraries (using semicolon separators on Windows architectures and colon
separators on all other architectures).
A maximum of six libraries can be specified in the BLASLIB environment variable.
Caution: Note that the UMF solver does not support all of the capability that is supported by the
Calahan solver. In these cases, such as redundant constraint analysis, the appropriate solver
(Calahan) will automatically be used.
Adams/Solver
C++Commands
156
MARKER
The MARKER command moves and/or reorients an existing fixed Adams/Solver (C++) marker. (See the
MARKER statement for more information). You may also list information about the position of the
marker.
Format

Arguments
LIST Lists the current values of the MARKER data. The data is with respect to the body
coordinate system (BCS) coordinates.
QP=x,y,z Redefines the the x-, y-, and z-coordinates of the origin of the MARKER with
respect to the PART on which it lies. The coordinates are specified in the body
coordinate system (BCS) of the PART to which it belongs. For markers associated
with CURVES and SURFACES, the coordinates are specified in the RM coordinate
system and are susceptible to change as Adams/Solver (C++) iteratively solves for
initial conditions that satisfy all constraints while maintaining the marker on the
curve.
157 MARKER
C++Commands
REULER=a,b,c Redefines the three-dimensional spatial orientation of the marker axes relative to the
axes of the BCS. For markers associated with CURVES and SURFACES, the
orientation is relative to the natural coordinate system of the CURVE or SURFACE.
The a, b, and c values represent a set of body-fixed 3-1-3 Euler angles expressed in
radians. These angles can be interpreted as follows:
To orient a marker, first align the marker axes identically to the BCS axes.
Perform a right-handed rotation of the marker x- and y-axes by a radians about
the positive z-axis of the marker.
Rotate the marker y- and z-axes by b radians about the current marker positive x-
axis.
Perform a right-handed rotation of the x- and y-axes of the marker by c radians
about the current z-axis of the marker.
This technique can be used to define any arbitrary orientation of the marker relative
to the part BCS. To enter the Euler angles in degrees instead of radians, add a D after
each value.
RM Redefines a reference marker with respect to which Adams/Solver (C++) interprets
QP, XP, ZP, and REULER.
USEXP When using the x-point-z-point method of orientation, USEXP causes the marker to
be oriented with the x-axis lying on XP and ZP lying in the positive x-z plane. This
is useful to orient markers for use in BEAM statements.Examples of using the ZP,
XP and USEXP.
Adams/Solver
C++Commands
158
Extended Definition
The MARKER command allows you to reposition and/or reorient a fixed marker with respect to the body
coordinate system (BCS) of the element to which the marker is attached, or to another nonfloating marker
on the same element. You may use any of the standard Adams/Solver (C++) methods to specify the
location and orientation of the marker. Floating markers may not be moved, but their current information
may be listed. For more information on BCS, see Coordinate Systems and Local Versus Global
Geometric Data.
After a change to a MARKER, Adams/Solver (C++) reprocesses the model at the next SIMULATE
XP=x,y,z By default, redefines the BCS coordinates of any point in the positive x-z plane of
the marker, but not on the z-axis of the marker. A point on the positive x-axis may
be the most convenient. When used with USEXP, XP defines the BCS coordinates
of any point on the positive x-axis of the marker.
If the marker is associated with a FLEX_BODY or PART, the x-, y-, and z-
coordinates are specified in the BCS. For markers associated with CURVES and
SURFACES, the x-, y-, and z-coordinates are specified in the natural coordinate
system of the CURVE or SURFACE.
For every point on a CURVE or SURFACE, Adams/Solver (C++) computes a
natural coordinate system defined by tangent, normal, and binormal orthonormal
vectors. In general, as the solution progresses and the marker moves along the
CURVE or SURFACE, the orientation of the natural coordinate system changes, but
the orientation of the marker relative to the natural coordinate system remains fixed.
The fixed orientation of the marker relative to the natural coordinate system is
specified with XP and ZP arguments. Examples of using the ZP, XP and USEXP.
ZP=x,y,z By default, redefines the BCS coordinates of any point in the positive z-axis of the
marker. When used with USEXP, ZP defines the BCS coordinates of any point in the
positive x-z plane of the marker, but not on the x-axis of the marker.
If the marker is associated with a FLEX_BODY or PART, the x-, y-, and z-
coordinates are specified in the BCS. For markers associated with CURVES and
SURFACES, the x-,y- and z-coordinates are specified in the natural coordinate
system of the CURVE or SURFACE.
For every point on a CURVE or SURFACE, Adams/Solver (C++) computes a
natural coordinate system defined by tangent, normal, and binormal orthonormal
vectors. In general, as the solution progresses and the marker moves along the
CURVE or SURFACE, the orientation of the natural coordinate system changes, but
the orientation of the marker relative to the natural coordinate system remains fixed.
The fixed orientation of the marker relative to the natural coordinate system is
specified with XP and ZP arguments. Examples of using the ZP, XP and USEXP.
159 MARKER
C++Commands
While checking, Adams/Solver (C++) verifies that the model is still valid with the new MARKER
positions. If a JOINT is now misaligned, for instance, Adams/Solver (C++) issues a warning or error.
Adams/Solver (C++) also reinitializes user subroutines to re-establish functional dependencies. For each
element that refers to a user-written subroutine, Adams/Solver (C++) calls the user-written subroutine
with IFLAG set to true.
If you have run a previous simulation, Adams/Solver (C++) begins with the final displacements and
velocities. Adams/Solver (C++) then adjusts the initial conditions to ensure that they are consistent with
the model constraints. If this is the first simulation, Adams/Solver (C++) also maintains any user supplied
joint initial-conditions and positions specified as EXACT.
If you change a MARKER in the middle of a simulation, by default Adams/Solver (C++) splits the
tabular, request, graphics, and results output into two separate sets of output concatenated together. This
ensures that the output correctly reflects the new system geometry.
The OUTPUT/NOSEPARATOR argument prevents Adams/Solver (C++) from splitting the file. This
allows you to plot or animate the output continuously from beginning to end, but may result in misleading
graphics during postprocessing. See the OUTPUT statement for more information on the
NOSEPARATOR argument.
Examples
MARKER/ 10, REULER=15D, 0, 0
This MARKER command reorients marker 10.
MARKER/ 10, QP=2, 15, 0
Tip: You can use the QP argument to translate the marker while maintaining the existing
orientation. If you use only the REULER argument, Adams/Solver (C++) reorients the
marker while maintaining the existing position.
Caution: When reorienting a marker, you should completely specify the necessary information
for the selected orientation method. Adams/Solver (C++) uses the new orientation
information; it does not try to combine it with old information from the dataset
statement or a previous command. For example, if you supply ZP but not XP,
Adams/Solver (C++) uses a default position for the x-axis. Adams/Solver (C++) does
not use a value of XP from the statement or an earlier command.
When you change a marker, Adams/Solver (C++) updates all elements that depend on
that marker. Moving a marker may have subtle effects since many Adams/Solver (C++)
elements rely on them. Be careful when moving markers as unintended side effects (for
example, moving both a joint and force that share a common marker) may occur.
Adams/Solver
C++Commands
160
This MARKER command relocates marker 10.
MARKER/ 10, QP=2, 15, 0, ZP=3, 15, 0
This MARKER command relocates and reorients marker 10.
MARKER/ 18, QP=0, 0, 0, REULER=0d, 0d, 0d, RM=8
This MARKER command repositions/reorients Marker 18 so that it has the same location and orientation
as Marker 8.
See other bordered commands available.
161 MENU
C++Commands
MENU
The MENU command lists all of the Adams/Solver (C++) interactive commands.
Format
MENU
Adams/Solver
C++Commands
162
MOTION
The MOTION command redefines and/or lists the characteristics of a MOTION statement which
specifies a system degree of freedom as an explicitly function of time. For more information, see the
MOTION statement.
Format

Arguments
ACCELERATION Respecifies that the FUNCTION argument defines the motion
acceleration as a function of time.
B1 Respecifies the first angle of the Body 1-2-3 Euler angle
sequence as a function of time.
Range: None
B2 Respecifies the second angle of the Body 1-2-3 Euler angle
Range: None
163 MOTION
C++Commands
B3 Respecifies the third angle of the Body 1-2-3 Euler angle
Range: None
DISPLACEMENT Respecifies that the FUNCTION argument defines the motion
displacement. This is the default.
Respecifies an expression or redefines and passes constants to
a user-written subroutine to determine the motion. The motion
must be a function of time only and not a function of the state
variables.
ICDISP Respecifies the initial displacement of the motion, when the
motion is defined in terms of velocity or acceleration.
ICVEL Respecifies the initial velocity of the motion, when the motion
is defined in terms of acceleration.
I=id, J=id Respecifies the identifiers of the two markers whose
displacement is being controlled.
Range: Any valid non-floating marker not belonging to a
flexible body
JOINT Respecifies the identifier of the joint to which the motion is
assigned. The joint must be translational, revolute, or
cylindrical.
LIST Lists the current values of the data in the MOTION statement.
ROTATION Respecifies that Adams/Solver (C++) is to apply a rotational
motion. The type of motion is ambiguous for cylindrical joints
only.
ROUTINE=libname::subname Specifies an alternative library and name for the user
subroutine MOTSUB.
TRANSLATION Respecifies that Adams/Solver (C++) is to apply a translational
motion. The type of motion is ambiguous for cylindrical joints
only.
VELOCITY Respecifies that the FUNCTION argument defines the motion
velocity.
X Respecifies DX(I,J,J) as a function of time. Range: None
Y Respecifies DY(I,J,J) as a function of time. Range: None
Z Respecifies DZ(I,J,J) as a function of time. Range: None
Adams/Solver
C++Commands
164
Extended Definition
The MOTION command allows you to list or modify the characteristics of an existing MOTION
statement. You can change the motion definition, change the joint to which the motion is being applied,
and/or change the type of motion on a cylindrical joint.
After a change to a MOTION, Adams/Solver (C++) reprocesses the model at the next SIMULATE
While checking, Adams/Solver (C++) verifies that the model is still valid with the new MOTION. If, for
example, the new MOTION conflicts with another MOTION at the same joint, Adams/Solver (C++)
issues an error.
with IFLAG set to true.
constraints. If this is the first simulation, Adams/Solver (C++) also maintains any user-supplied joint
initial-conditions and part positions specified as EXACT.
Examples
MOTI ON/ 3, J OI NT=21
This MOTION command applies Motion 3 to Joint 21.
MOTI ON/ 11, FUNCTI ON=5+2*TI ME
This MOTION command specifies, as a function of time, the translation or rotation for Motion 11.
165 OUTPUT
C++Commands
OUTPUT
The OUTPUT command redefines and/or lists the data for an OUTPUT statement.
Format

Arguments
Extended Definition
Like the OUTPUT statement, the OUTPUT command controls the generation of the request file and
graphics file.
See other Output available.
GRSAVE Resaves graphics output in the Graphics file so that you can use a postprocessor to
display graphics.
LIST Lists the current values of the data in the OUTPUT statement.
NOGRSAVE Stops saving graphics output in the Graphics file.
NOREQSAVE Stops saving request output in the Request file.
REQSAVE Resaves the request output in the Request file so you can use a postprocessor to
display x-y plots.
Adams/Solver
C++Commands
166
PART
The PART command redefines and/or lists the data for a PART statement. Although you cannot redefine
the center-of-mass markers, the inertia markers, you are free to move and reorient those markers using
the MARKER command. You can also redefine the mass of the part and the 6 values of the inertia tensor.
Format
PART/id [,MASS=r] [,IP=xx,yy,zz [, xy,xz, yz] [,LIST]
167 PART
C++Commands
Arguments
Examples
PART/ 2, MASS=10
This PART command respecifies the mass of Part 2.
IP=xx,yy,zz Specifies the mass-inertia tensor as computed about the origin of the IM marker,
expressed in the coordinate system of the IM marker.
You can compute the individual terms of the IP argument as:
In the above formulae, x, y, and z are the components of the displacement of the center
of an infinitesimal volume of mass dm, measured from the origin of the inertia marker
in the coordinate system of the inertia marker. The integral is performed over the entire
volume of the body. If the inertia marker was not specified by the PART statment for the
part, the IM marker defaults to the CM marker. In that case, these quantities are
computed about the origin of the CM marker in the coordinate system of the CM marker.
Note: Adams/Solver (C++) defines Ixy, Ixz, and Iyz as positive integrals, as shown.
Some references define these terms as the negative of these integrals. Be sure
to compute these values as shown above.
LIST Lists the current values of the data in the PART statement.
MASS=r Respecifies the part mass.
Ixx y
2
z
2
+ ( ) m d
}
=
Iyy x
2
z
2
+ ( ) m d
}
=
Izz x
2
y
2
+ ( ) m d
}
=
Ixy xy m d
}
=
Ixz xz m d
}
=
Iyz yz m d
}
=
Caution: Unlike Adams/Solver (FORTRAN) the PART command in Adams/Solver (C++) is
followed by an initial condition analysis and an integrator restart, if applicable. This is a
consequence of the added freedom in respecifying inertia properties and the location and
orientation of inertia markers.
Adams/Solver
C++Commands
168
PART/ 5, I P=0, 3, 6, LI ST
This PART command respecifies the moments of inertia of Part 5 as principal moments of inertia and lists
all the data for the Part. If the original definition of Part 5 included an IM marker the moments of inertia
are w.r.t. this marker, otherwise the CM marker. If the original definition of Part 5 specified all 6 inertia
tensor values, the off-diagonal values are set to zero as a consequence of not being respecified.
169 PREFERENCES
C++Commands
PREFERENCES
The PREFERENCES command controls general options that apply to the model defined in the
Adams/Solver (C++) dataset or the commands defined in the Adams/Solver (C++) command file.
Format

Adams/Solver
C++Commands
170
Arguments
Specifies the geometry library to be used to 3D
contact determination:
Parasolid - Specifies the Parasolid
geometry library to be used for 3D contact
determination.
Default_library - Specifies that the
default geometry library to be used for 3D
contact determination.
For more on the different libraries, see the
PREFERENCES statement.
CONTACT_FACETING_TOLERANCE=value Specifies the resolution of the mesh that is to be
created from the solid geometries in the model.
Contact kinematics are calculated by intersecting
the meshes corresponding to two solid geometries.
A finer mesh will result in more accurate contact
calculations. However, calculations may be
slower, and computer memory requirements will
increase as the mesh resolution increases.
The faceting tolerance is defined as the maximum
error between the true surface and the surface of
the faceted representation of the geometry. The
maximum error is guaranteed not to exceed
(1/value) * the minimum dimension of each
geometry's bounding box.
The default value of this parameter is 300.
The faceting tolerance has no effect on inherently
polygonal surfaces such as boxes.
171 PREFERENCES
C++Commands
Specifies whether or not to stop command-file
execution when a simulation fails.
A value of STOPCF indicates that Adams/Solver
(C++) should stop if a static, quasi-static,
kinematic, or dynamic analysis fails to find a
solution or reach the specified end time.
Adams/Solver (C++) finishes writing output and
exit, just as if a STOP command were the next
command in the command file.
A value of NOSTOPCF indicates that
Adams/Solver (C++) should continue to process
commands from a command file even after a
simulation fails.
Adams/Solver
C++Commands
172
When you run Adams/Solver, this specifies which
version of Adams/Solver to run: C++ (Cxx),
FORTRAN (F77), or none. Adams/Solver only
runs the version if it supports your model. For
example, the Adams/Solver (FORTRAN) supports
some statements that are not supported in
Adams/Solver (C++). If "none" is selected,
Adams/Solver uses the default solver.
If the simulation is being run with an command file
(.acf) and the .acf file has a
Preferences/SolverBias={Cxx,F77,none}
command in it, Adams/Solver runs with the
specified solver. If more than one
Preferences/SolverBias commands is present, it
uses the first command it finds. Issuing this
command during a simulation has no effect. This
argument is only useful when executing
Adams/Solver from a command file.
When you are running Adams/Solver
(FORTRAN), and issue
Preferences/SolverBias=Cxx, Adams/Solver
returns the following warning:
---- WARNING ----
Once the Solver session is executing it is not
possible
to change to the Cxx Solver. Solverbias=cxx is
being
ignored, and the simulation is proceeding with the
F77
Solver.
If you are running Adams/Solver C++, and issue
Preferences/SolverBias=F77, Adams/Solver
ignores the command.
173 PREFERENCES
C++Commands
Examples
Using the Parasolid geometry library provided by MSC:
PREFERENCES/ CONTACT_GEOMETRY_LI BRARY=Par asol i d
LIST Lists the current values of the PREFERENCES
statement.
STATUS_MESSAGE Controls the presence of two status messages in the
.msg file produced by Adams/Solver (C++). These
status messages mimic status messages produced
by Adams/Solver (FORTRAN). This preference
has no effect on Adams/Solver (FORTRAN).
Default: OFF
The first status message is sent after every
simulation and has the form Simulate status =i.
The second message is sent when Adams/Solver
(C++) terminates and has the form Termination
status = i.
In both cases i is an integer number reporting the
status.
Caution: CONTACT_GEOMETRY_LIBRARY and CONTACT_FACETING_TOLERANCE
parameters are accepted only at the start of the simulation. Once the simulation starts
changing these parameters will not affect the simulation.
Adams/Solver
C++Commands
174
RELOAD
The RELOAD command restarts a simulation from a previously saved model or simulation state.
Format
RELOAD/SYSTEM, FILE=c, [OUTPUT_PREFIX=c] [TITLE=c]
Arguments
FILE=c Specifies the complete name of a file you created with the SAVE command.
names, such as UNIX. There is no default extension for this file. Because the
FILE argument and value can be at most eighty characters long, the file name
and path name are limited from seventy-five characters (if you do not
abbreviate FILE=) to seventy-six characters (if you abbreviate FILE= to
FIL=).
OUTPUT_PREFIX=c Optionally specifies a new base (root) name for output files (.req, .res, .gra, and
so on) from simulations which follow this RELOAD command. If you do not
specify the OUTPUT_PREFIX argument, Adams/Solver (C++) appends the
output to the currently-open output files after writing a special delimiter line
into the file. Because the OUTPUT_PREFIX argument and value can be at
most eighty characters long, the basename and path are limited from sixty-six
characters (if you do not abbreviate OUTPUT_PREFIX) to seventy-six
characters (if you abbreviate OUTPUT_PREFIX to OUT=).
175 RELOAD
C++Commands
Extended Definition
Using the RELOAD command with the SYSTEM argument allows you to reload the entire saved system,
including the model definition (parts, markers, joints, and so on), simulation time and state values
(displacements, velocities, force values, user-defined variable values, and so on), and solver data
(integrator parameters, state derivatives, and so on). Adams/Solver (C++) completely resets all model,
simulation, and solver data to that stored in the file. Except for interactive plotting, Adams/Solver (C++)
responds to subsequent commands just as it would have at the time the file was saved. (Because past
simulation results are not stored in the Save file, they cannot be plotted when the file is restored.)
SYSTEM Specifies that Adams/Solver (C++) reloads the entire saved system, including
the model definition (parts, markers, joints, and so on), simulation time and
state values (displacements, velocities, force values, user-defined variable
values, and so on), and solver data (integrator parameters, state derivatives,
and so on). This completely replaces the existing model and simulation
conditions with the saved model and simulation conditions.
TITLE=c Optionally specifies a new title for the model in output from simulations which
follow this RELOAD command. The title string may not contain any special
Adams/Solver (C++) characters and must fit on a single line (no
continuations). If not the last argument, the title is terminated by the last non-
blank prior to the following comma. Because the TITLE argument and value
can be at most eighty characters long, the file name and path name are limited
from seventy-four characters (if you do not abbreviate TITLE=) to seventy-six
characters (if you abbreviate TITLE= to TIT=).
Tip: Except for the leading delimiter line, the appended sections of the output files are complete
(that is, they may be extracted with any editor, renamed, and handled like any other
Adams/Solver (C++) output).
Caution: Files are saved in a machine- and code-dependent binary format. They are not
portable across platforms or between versions of Adams/Solver (C++).
Save files generated by Adams/Solver (FORTRAN) cannot be reloaded by
Adams/Solver (C++). Similarly, save files generated by Adams/Solver (C++)
cannot be reloaded by Adams/Solver (FORTRAN).
Save files generated by a specific version of Adams/Solver (C++) (for example,
2005r2) cannot be reloaded by any other version of Adams/Solver (C++) such as
2005 r1. This also applies to any service packs that may be applied to
Adams/Solver (C++).
RELOAD/STATES is not supported by Adams/Solver (C++).
Adams/Solver
C++Commands
176
Examples
RELOAD/ SYSTEM, FI LE=TCT1. SAV, TI TLE=TEST#2
This RELOAD command reloads the model and simulation states saved in file TCT1.SAV. Adams/Solver
(C++) appends subsequent output to the currently open output files with the new title TEST#2.
The SAVE and RELOAD commands can help simulate several versions of the same model when used
with other interactive Adams/Solver (C++) commands. SAVE/SYSTEM creates a baseline configuration
that you can then reload and simulate repeatedly without leaving Adams/Solver (C++). After each
RELOAD/SYSTEM, you may modify the model, and use the ACTIVATE and DEACTIVATE
commands to switch sets of loads on and off, for example.
The following command file uses the SAVE/SYSTEM and RELOAD/SYSTEM commands to run three
simulations from the same input file, creating three sets of output files: case1, case2, and case3. The
command file loads example.adm, the original model, that contains three sets of forces. After
deactivating all the forces and performing a static solution, the SAVE command saves the whole system.
ACTIVATE commands then turn on one set of forces at a time.
Between simulations, the RELOAD command restores the saved version of the model. Reloading the
save file returns the model to the conditions at the time of the save. In this case, the saved version of the
model is at static equilibrium with all the forces inactive.
exampl e
case1
dea/ sf o, i d=101, 102, 201, 202, 301, 302 ! Deact i vat e al l f or ces
si m/ st at i c ! Fi nd st at i c equi l br i um
save/ syst em, f i l e=ex. sav ! Save syst emat st at i c, no f or ces
act / sf o, i d=101, 102 ! Act i vat e f i r st set of f or ces
si m/ dyn, end=. 25, st eps=100 ! Si mul at e
r el / syst em, f i l e=ex. sav, out =case2 ! Rel oad( now back at st at i c, no f or ces)
act / sf o, i d=201, 202 ! Act i vat e second set of f or ces
act / sf o, i d=301, 302 ! Act i vat e t hi r d set of f or ces
st op
177 REQUEST
C++Commands
REQUEST
The REQUEST command redefines and/or lists the data for a REQUEST statement, and/or redefines the
function expressions for a REQUEST statement.
Format

Arguments
F2=e Redefines a component of the request that is being specified. If the
F2 argument is used, it must either be the last argument in the
REQUEST statement or be followed by a backslash (\) (not a
comma).
comma).
comma).
comma).
Adams/Solver
C++Commands
178
Examples
REQUEST/ 21, F4=DX( 2110, 409) / F8=DX( 2115, 409)
This REQUEST command changes the channels F4 and F8 expressions for REQUEST/21. The other
function expressions remain as they were.
See other Output available.
comma).
comma).
FUNCTION=USER(r1[,...,r30])[/] Redefines and passes constants (r1[,...,r30]) to the user-written
subroutine REQSUB to define the request (see REQSUB Using
Adams/Solver Subroutines). If the FUNCTION argument is used,
it must either be the last argument in the REQUEST statement or
be followed by a backslash (\). Because of compatibility
requirements, REQSUB can define 8 columns of data, but only
columns 2, 3, and 4 and columns 6, 7, and 8 are written in the
request file.
LIST Lists the current values of the data in the REQUEST statement.
REQSUB.
179 SAVE
C++Commands
SAVE
The SAVE command stores the current Adams/Solver (C++) model and simulation conditions or only
the current simulation states. This allows you to return to the model or states at a later time using the
RELOAD command.
Format
SAVE/SYSTEM, FILE=c
Arguments
Extended Definition
You can use the SAVE command with the SYSTEM argument to save the entire current system, including
the model definition (parts, markers, joints, and so on), simulation time, state values (displacements,
velocities, force values, user-defined variable values, and so on), and solver data (integrator parameters,
state derivatives, and so on). SAVE/SYSTEM creates a complete record of the current model and
simulation conditions. You can later return to this point by reloading the conditions using the
RELOAD/SYSTEM command.
When you reload a system file, Adams/Solver (C++) completely resets all model, simulation, and solver
data to that stored in the file. Except for interactive plotting, Adams/Solver (C++) responds to subsequent
commands just as it would have at the time the file was saved. (Because past simulation results are not
stored in the save file, they cannot be plotted when the file is restored.)
FILE=C Specifies the complete file name where Adams/Solver (C++) writes the SAVE
command information. The file name may include the directory on operating systems
that support such path names, such as UNIX. There is no default extension for this file.
SYSTEM Specifies that Adams/Solver (C++) saves the entire current system, including the
model definition (parts, markers, joints, and so on), simulation time and state values
(displacements, velocities, force values, user-defined variable values, and so on), and
solver data (integrator parameters, state derivatives, and so on). SYSTEM creates a
complete record of the current model and simulation conditions. The
RELOAD/SYSTEM command can later reload this record to return to these model and
simulation conditions.
Adams/Solver
C++Commands
180
Examples
SAVE/ SYSTEM, FI LE=BASE1. SAV
This SAVE command saves the current model and simulation information in file BASE1SAV. When this
file is reloaded with the RELOAD command, Adams/Solver (C++) returns to this exact configuration.
Used with other interactive Adams/Solver (C++) commands, SAVE and RELOAD can help simulate
several versions of the same model. SAVE/SYSTEM creates a baseline configuration which you can then
reload and simulate repeatedly without leaving Adams/Solver (FORTRAN). After each
RELOAD/SYSTEM, you may modify the model. This can be done by using the ACTIVATE and
DEACTIVATE commands to switch sets of loads on and off, for example.
The following command file uses the SAVE/SYSTEM and RELOAD/SYSTEM commands to run three
simulations from the same input file, creating three sets of output files: case1, case2, and case3. The
command file loads example.adm, the original model, which contains three sets of forces. After
deactivating all the forces and performing a static solution, the SAVE command saves the whole system.
ACTIVATE commands then turn on one set of forces at a time.
Between simulations, the RELOAD command restores the saved version of the model. Reloading the
save file returns the model to the conditions at the time of the save. In this case, the saved version of the
model is at static equilibrium with all the forces inactive.
Caution: Files are saved in a machine- and code-dependent binary format. They are not portable
across platforms or between versions of Adams/Solver (C++).
Save files generated by Adams/Solver (FORTRAN) cannot be reloaded by
Adams/Solver (C++). Similarly, save files generated by Adams/Solver (C++) cannot be
reloaded by Adams/Solver (FORTRAN).
SAVE/STATES is not supported by Adams/Solver (C++).
exampl e
case1
dea/ sf o, i d=101, 102, 201, 202, 301, 302 ! Deact i vat e al l f or ces
si m/ st at i c ! Fi nd st at i c equi l i br i um
save/ syst em, f i l e=ex. sav ! Save syst emat st at i c, no f or ces
act / sf o, i d=101, 102 ! Act i vat e f i r st set of f or ces
act / sf o, i d=201, 202 ! Act i vat e second set of f or ces
181 SAVE
C++Commands
act / sf o, i d=301, 302 ! Act i vat e t hi r d set of f or ces
st op
Adams/Solver
C++Commands
182
SENSOR
The SENSOR command lists the data for a SENSOR statement, and/or redefines the function expression.
Format
Arguments
EVALUATE_ROUTINE=libname::subname Specifies an alternative library and name for the user
subroutine SEVSUB.
Respecifies an expression or defines and passes
constants to a user-written subroutine to define the
sensor. To define the sensor with an expression, follow
FUNCTION with an equal sign and the expression (e).
To define the sensor with a user-written subroutine,
follow FUNCTION with an equal sign, the character
string USER, and the values (r1[,...,r30]) that you want
Adams/Solver (C++) to pass to the user-written
subroutine SENSUB (see the SENSUB subroutine). If
the FUNCTION argument is used, it must either be the
last argument in the SENSOR statement or be followed
by a backslash (\).
Range: An expression or a user parameter list of 1 to 30
real values
LIST Lists the current values of the data in the SENSOR
statement.
subroutine SENSUB.
183 SENSOR
C++Commands
Examples
SENSOR/ 231, FUNCTI ON=DX( 0202, 0307)
This SENSOR command changes the function for SENSOR/231 to DX(0202,0307).
Adams/Solver
C++Commands
184
SFORCE
The SFORCE command lists or changes the characteristics of an SFORCE statement.
Format

Arguments
ACTIONONLY Respecifies an action-only force. Adams/Solver (C++)
applies no reaction at the J marker.
Respecifies an expression or redefines and passes constants to
a user-written subroutine to redefine a single-component
force. To redefine the force with an expression, follow
FUNCTION with an equal sign and the expression. To
redefine the force with a user-written subroutine, follow
FUNCTION with an equal sign, the character string USER,
and the values (r1[,...,r30]) that you want Adams/Solver
(C++) to pass to the user-written evaluation subroutine
SFOSUB (see the SFOSUB subroutine). If the FUNCTION
argument is used, it must either be the last argument in the
SFORCE statement or be followed by a backslash (\). The
force function may be changed from an expression to the
subroutine or the reverse. If neither argument is given, the
force definition does not change. FUNCTION must either be
the last argument given, or be followed by a backslash (\).
185 SFORCE
C++Commands
Extended Defintion
The SFORCE command lists or changes the characteristics of an existing SFORCE element. You can
alter one or both points of force application, change the force from ACTIONONLY to ACTION-
REACTION, or the reverse, or change the force from TRANSLATION to ROTATION, or the reverse. In
addition, you can change the force definition function expression or SFOSUB parameter list, or switch
the definition between function expression and subroutine.
After a change to an SFORCE, Adams/Solver (C++) reprocesses the model at the next SIMULATE
While checking, Adams/Solver (C++) verifies that the model is still valid with the new SFORCE. If, for
example, the SFORCE function expression refers to an inactive element, Adams/Solver (C++) issues an
error.
I=id,J=id Respecifies the identifiers of two markers necessary to define
the force. If the SFORCE command defines a translational
action-reaction force, I and J specify the identifiers of the two
markers between which you want to exert the force.
Adams/Solver (C++) applies the translational action-reaction
force along the line of action defined by the line segment
connecting I and J. If the SFORCE command defines an
action-only force, I specifies the point of application, and the
z-axis of J specifies the direction of the force. If SFORCE
defines a torque, the z-axis of the J marker specifies the axis
of rotation. In the case of action-reaction torques, the z-axis of
the J marker must be parallel to, and pointed in the same
direction, as the z-axis of the I marker.
LIST Lists the current values of the data in the SFORCE statement.
REACTION Respecifies an action-reaction force. Adams/Solver (C++)
applies reaction forces or torques at the J marker.
subroutine SFOSUB.
Adams/Solver
C++Commands
186
Examples
SFORCE/ 201, FUNCTI ON=- 10. *VR( 101, 201)
This SFORCE command changes the force definition for SFORCE 201.
SFORCE/ 6, I =28
This SFORCE command applies SFORCE 6 to Marker 28, leaving the J marker unchanged.
187 SHOW
C++Commands
SHOW
The SHOW command lists statistics for any of these topics: CPU time, graphics options, status, and time.
Format
Arguments
ALL
SHOW [CPUTIME] [GROPTIONS] STATUS= ,GRAPHICS [TIME]
,REQUESTS
,SIMULATION
CPUTIME Lists the current total use of CPU time for the execution.
GROPTIONS Lists the options controlling graphics display.
Lists the statistics for each GRAPHICS statement, the statistics for
each REQUEST statement, or the statistics for the simulation, or
all of these statistics.
TIME Lists the current time and date.

Adams/Solver
C++Commands
188
SIMULATE
The SIMULATE command specifies the type of simulation you want Adams/Solver (C++) to run. It also
defines the run time and the number or size of the output steps.
Format

Arguments
ACCELERATION Specifies that initial displacement, velocity, and acceleration analyses of
the mechanism are to be performed if such analyses have not already been
performed at the current time step and with the current model.
DISPLACEMENT Specifies that an initial displacement analysis of the mechanism is to be
performed if such an analysis has not already been performed at the current
time step and with the current model.
DTOUT=r Specifies the size of the output step for the analysis in model time units.
Range: DTOUT > 0
DURATION Specifies the duration of the analysis in model time units.
Range: DURATION > 0
189 SIMULATE
C++Commands
DYNAMICS Specifies that Adams/Solver (C++) is to integrate the dynamics equations.
If a dynamic analysis is requested for a system with zero degrees of
freedom, Adams/Solver (C++) issues a warning message and integrates the
equations instead of using kinematic analysis. Kinematic analysis is faster.
END Specifies the end time for a dynamic, a kinematic, or a quasi-static
equilibrium analysis.
Range: END > Begin Time > 0
INITIAL_CONDITIONS Specifies that an initial-conditions analysis of the mechanism is to be
performed. All three initial-conditions analyses are performed if 1) no
DISPLACEMENT, VELOCITY, or ACCELERATION argument or if 2)
the ACCELERATION argument is specified and no initial condition
analyses have been performed at the current time step with the current
model. Displacement and velocity initial conditions are performed if the
VELOCITY argument is specified and no initial condition analyses have
been performed at the current time step with the current model.
Displacement initial conditions are performed if the DISPLACEMENT
argument is specified and no initial-conditions analyses have been
performed at the current time step with the current model.
KINEMATICS Specifies that Adams/Solver (C++) is to run a kinematic analysis. If a
kinematic analysis is requested for a system with one or more degrees of
freedom, Adams/Solver (C++) issues a warning message and switches to
dynamic analysis.
SETTLE Specifies that Adams/Solver (C++) is to run a steady-state analysis. This
type of analysis consists of modifying the states of all differential elements
until all first order derivatives of the said states are zero. Only differential
states are modified during this simulation. If the model has no differential
states, for example, DIFF, LSE, GSE, TFSISO, this simulation has no effect
on the model.
The current simulation time of the model does not change during this type
of analysis.
Adams/Solver
C++Commands
190
Extended Definition
Adams/Solver (C++) allows you to do one or more analyses on the same dataset until the STOP
command is issued. These analyses can be different types as long as they meet the degree-of-freedom
requirements for that type of analysis. For example, it is often useful or necessary to do a static
equilibrium analysis on a model to establish equilibrium conditions before doing a dynamic analysis.
STATICS Specifies that Adams/Solver (C++) perform either a static equilibruim
simulation or a quasi-static equilibrium simulation. Adams/Solver (C++):
Performs a static equilibrium simulation at the current time if you
use the STATICS argument and you do not specify an end time or
steps.
Performs a quasi-static equilibrium simulation if you use the
STATICS argument and specify an end time and steps.
Uses kinematic analyses to perform static simulations for models
that have zero degrees of freedom. If you request a quasi-static
simulation on a model that has zero degrees of freedom,
Adams/Solver (C++) computes the same motion as in a kinematic
analysis, but ignores (set to zero) velocities and accelerations.
STEPS=i Specifies the number of output steps wanted for the analysis.
Range: STEPS > 1
TRANSIENT Specifies that Adams/Solver (C++) is to run a kinematic analysis if the
system has zero degrees of freedom or a dynamic analysis if the system has
one or more degrees of freedom.
VELOCITY Specifies that initial displacement and velocity analyses of the mechanism
are to be performed if such analyses have not already been performed at the
current time step and with the current model.
Tip: Note the distinction between END and DURATION. At time zero, a SIMULATE
command with END=1 or DURATION=1 indicates an end time of one second. At time one
second, a SIMULATE command with END=1.5 indicates an end time of 1.5 seconds; a
SIMULATE command with DURATION=1.5 indicates an end time of 2.5 seconds.
191 SIMULATE
C++Commands
Examples
SI MULATE / KI NEMATI CS, END=5, STEPS=200
This SIMULATE command instructs Adams/Solver (C++) to perform a kinematic analysis from the
begin time to 5 time units with 200 output steps. If this is the first analysis on this dataset in this session,
the begin time is 0 time units. Adams/Solver (C++) can execute this command only if the system has zero
degrees of freedom.
SI MULATE / KI NEMATI CS, DURATI ON=2, DTOUT=. 025
This SIMULATE command instructs Adams/Solver (C++) to perform a kinematic analysis for 2 time
units with one output step every .025 time units.
See other Simulation commands available.
Caution: Before a dynamic simulation that follows a static simulation, Adams/Solver (C++)
computes the velocity and acceleration initial conditions even if they were
computed prior to the static simulation. This ensures that the velocity and
acceleration initial conditions are consistent with the displacements from the static
simulation.
When you use END and STEPS parameters with the SIM/STAT command, time
increments past time = 0. As such, initial velocities are no longer valid and are not
considered in subsequent dynamic analyses.
If a static simulation directly follows a dynamic simulation, Adams/Solver (C++)
sets the velocities and accelerations (except gravity) to zero and repeats the
displacement initial conditions.
Adams/Solver (C++) automatically performs a dynamic analysis for kinematic
systems that include DIFFs and sets the MODE analysis constant to 4 (not 1).
The STEPS and DTOUT arguments can indirectly affect the accuracy of the
results computed by the integrator. Under these circumstances, Adams/Solver
(C++) controls solution error by adjusting the integration time step to meet the
error tolerance specified by the integrator or default values. These integrators do
not use a time step greater than the interval to the next output time, however. The
output times are determined by STEPS or DTOUT in combination with END or
DURATION. Specifying a smaller output step than the integrators would
ordinarily take results in more integrator steps than actually required to meet the
error tolerance. In this case, varying the output step may vary the accuracy of the
computed results, although all results are within the specified error tolerance. If the
computed solution changes greatly when you change STEPS or DTOUT, the error
tolerance is too large. You should reduce the error tolerance. If you set the error
tolerance properly, the number of output steps should have very little effect on the
computed results.
Adams/Solver
C++Commands
192
SPLINE
The SPLINE command modifies or lists an existing SPLINE statement. You can change the values of the
SPLINE data, and in the process increase or decrease the number of X data or the number of curve
families. You cannot change the extrapolation method, nor can you read data from a file.
For information on the corresponding statement, see the SPLINE statement
For information on the corresponding subroutine, see the SPLINE_READ subroutine.
Format
SPLINE/id
, X=x1, x2, x3, x4 [, . . . , xn]
, Y=y1, y2, y3, y4 [, . . . , yn]
, LIST
or
SPLINE/id
, X=x1, x2, x3, x4 [, . . . , xn]
, Y=z1, y11, y12, y13, y14 [, . . . ,y1n], Y=z2, y21, y22, y23, y24 [, . . . ,y2n], Y=z3, y31, y32, y33, y34 [, .
. . ,y4n], Y=z4, y41, y42, y43, y44 [, . . . ,y4n][, . . . , Y=zm, ym1, ym2, ym3, ym4,[, . . . ,ymn]]
, LIST
Arguments
X=x1,x2,x3,x4[ , . . . , xn] Specifies at least four x values. The maximum number of
x values, n, depends on whether you specify a single curve
or a family of curves.
Values must be constants; Adams/Solver (C++) does not
allow expressions.
Values must be in increasing order: x1< x2 < x3, and so
on.
Y=y1,y2,y3,y4 [ , . . . , yn] Approximates a single curve by specifying the
corresponding y value: y1,y2,y3,y4[, . . . ,yn] for each x
value.
allow expressions.
193 SPLINE
C++Commands
Y=z1,y11,y12,y13,y14 [ , . . . , y1n]
,Y=z2,y21,y22,y23,y24 [ , . . . , y2n]
,Y=z3,y31,y32,y33,y34 [ , . . . , y3n]
,Y=z4,y41,y42,y43,y44 [ , . . . , y4n]
[ ,...,Y=zm,ym1,ym2,ym3,ym4 [ , . . . ,
ymn]]
Approximates a family of curves by specifying the
corresponding y values, y1,y2,y3,y4[, . . . ,yn], for the x
values at unique z values (z1[, . . . ,zm]).
allow expressions.
Values for z must be in increasing order: z1 < z2 < z3, and
so on.
LIST Lists the current SPLINE data.
Adams/Solver
C++Commands
194
SPRINGDAMPER
The SPRINGDAMPER command redefines and/or lists the data for a SPRINGDAMPER statement. You
cannot redefine the I and J marker defining the springdamper or the translational/rotational characteristic,
but you can redefine other characteristics.
Format

Arguments
ANGLE=r Respecifies the reference angle for the torsional spring. If the reference torque of the
spring is zero, ANGLE equals the free angle. Adams/Solver (C++) assumes ANGLE is
in radians unless a D is added after the value.
C=r Respecifies the viscous damping coefficient for the force. The force due to damping is
zero when the system is at rest. C must be greater than or equal to zero.
CT=r Respecifies the viscous damping coefficient for the torque. The torque due to damping
is zero when the system is at rest. CT must be in units of torque per radian per unit of
time.
Range: CT > 0
FORCE=r Respecifies the reference force at LENGTH.
K=r Respecifies the spring stiffness coefficient for the force.
Range: K > 0
KT=r Respecifies the spring stiffness coefficient for the torque. KT must be in units of torque
per radian.
Range: KT > 0
195 SPRINGDAMPER
C++Commands
LENGTH=r Respecifies the reference LENGTH for the spring. If the reference force of the spring is
zero, LENGTH equals the free length.
Range: LENGTH > 0
LIST Lists the current values of the data in the SPRINGDAMPER statement.
TORQUE=r Respecifies the reference torque of the torsional spring at ANGLE.
Adams/Solver
C++Commands
196
STOP
The STOP command terminates execution of Adams/Solver (C++) in the interactive mode and returns
control to the operating system.
Format
STOP
197 STRING
C++Commands
STRING
The STRING command redefines and/or lists the data for a STRING statement.
Format
STRING/id [,STRING=c] [,LIST]
Arguments
STRING=c Respecifies the string to be stored. The STRING argument and value must appear
together on one 80-character line. If STRING is abbreviated to S and starts a line, the
supplied string can be as long as 1024 characters.
LIST Lists the string in storage.
Caution: The following characters are not permitted in a STRING argument because they are
delimiters in the Adams/Solver (C++) command language: comma (,), semicolon (;),
ampersand (&), and exclamation point (!). This is because the comma indicates that
additional Adams/Solver (C++) arguments follow, the semicolon indicates that additional
Adams/Solver (C++) statements follow on the same line, the ampersand indicates that the
next line is a continuation of the statement on this line, and the exclamation point indicates
that Adams/Solver (C++) is to stop reading the line.
Adams/Solver
C++Commands
198
TIME
The TIME command shows the simulation time, integration step size, number of function evaluations
completed, and number of integration steps completed.
Format
TIME
Examples
TIME
Current Simulation Time = 5.0E-02
Current Integration Step Size = 1.0E-03
Number of Function Evaluations = 133
Number of Integration Steps = 59
199 VARIABLE
C++Commands
VARIABLE
A VARIABLE command redefines or lists data for a VARIABLE statement that defines a variable in terms
of a scalar algebraic equation. The variable can be either independently used, or as part of the PINPUT,
POUTPUT, or ARRAY statement.
Format

Arguments
Extended Definition
The VARIABLE command redefines or lists a user-defined algebraic equation and its initial value. After
a change to a variable, Adams/Solver (C++) reprocesses the model at the next SIMULATE command, as
if it had just been read in from the dataset. During the reprocessing, Adams/Solver (C++) checks the
entire model for consistency, reinitializes user subroutines, and recomputes initial conditions.
Respecifies an expression or redefines and passes constants to a
user-written subroutine to define a variable. If you want to define
the variable with an expression, FUNCTION must be followed
with an equal sign and the expression. If you want to define the
variable with a user-written subroutine, FUNCTION must be
followed with an equal sign, the character string USER, and the
selected values (r1[,...,r30]) that Adams/Solver (C++) passes to
the user-written subroutine VARSUB (see the VARSUB
subroutine).
IC=r Respecifies an approximate initial value for the VARIABLE.
Adams/Solver (C++) may adjust the value of IC when it
performs an initial condition analysis. Entering an accurate value
for IC may help Adams/Solver (C++) converge to the initial
conditions solution.
LIST Lists the current values of the VARIABLE arguments.
VARSUB.
Adams/Solver
C++Commands
200
with the IFLAG argument set to true.
Tip: Consider using ARRAY instead of VARIABLE if the function is a constant value
Caution: Caution should be used when defining a VARIABLE statement that is dependent
on another VARIABLE statement or on an Adams/Solver (C++) statement that
contains functions. If a defined system of equations does not have a stable
solution, convergence may fail for the entire Adams/Solver (C++) model. The
following example refers to this type of VARIABLE statement:
VARIABLE/1, FUNCTION= VARVAL(1)+1
When looked at as an algebraic equation, it looks like the following:
V=V+1.
However, when Adams/Solver (C++) tries to solve this equation using the
Newton-Raphson iteration, the solution diverges and a message appears on the
screen indicating that the solution has failed to converge.
The IC argument can be altered only prior to a simulation. If you run a simulation
and then try to alter IC, Adams/Solver (C++) rejects the entire VARIABLE
command.
The IC argument should be used whenever a zero value might cause a floating
point exception or lead Adams/Solver (C++) away from the desired solution.
201 VFORCE
C++Commands
VFORCE
The VFORCE command redefines and/or lists the data for a VFORCE statement that defines a
translational vector force element as specified using three orthogonal components.
Format

Arguments
FX=e Respecifies the magnitude and sign of the x component of the
VFORCE translational force. The direction of this component is
parallel to the x-axis of the RM marker.
FY=e Respecifies the magnitude and sign of the y component of the
parallel to the y-axis of the RM marker.
FZ=e Respecifies the magnitude and sign of the z component of the
parallel to the z-axis of the RM marker.
FUNCTION=USER(r1[,...,r30]) Respecifies up to 30 user-defined constants for use in computing the
force components in a user-defined subroutine VFOSUB (see
theVFOSUB subroutine).
I=id Respecifies the marker at which Adams/Solver (C++) applies the
action force. You must ensure that the I marker is a fixed marker and
on a different part than the JFLOAT marker. Because I is a fixed
marker, Adams/Solver (C++) always applies the force at a fixed
point on the part.
Adams/Solver
C++Commands
202
Extended Definition
The VFORCE statement lists or redefines a force element that consists of three mutually orthogonal
translational force components. You can alter one or both points of force application, change the force
reference marker, and change the force function expressions or the parameters passed to the VFOSUB
user-written subroutine.
After a change to a VFORCE, Adams/Solver (C++) reprocesses the model at the next SIMULATE
While checking, Adams/Solver (C++) verifies that the model is still valid with the new VFORCE. If, for
example, the VFORCE function expression refers to an inactive element, Adams/Solver (C++) issues an
error.
JFLOAT=id Respecifies the marker at which Adams/Solver (C++) applies the
reaction force. You must ensure that the JFLOAT marker is a floating
marker and on a different part than the I marker. Adams/Solver
(C++) moves the JFLOAT marker to keep it superimposed on the I
marker, which means that the reaction force may move with respect
to the part. Adams/Solver (C++) does not calculate reaction forces
when the JFLOAT marker is on the ground part.
LIST Lists the current values of the VFORCE arguments.
RM=id Respecifies the marker that determines the orientation of the force
components. You must ensure that RM is a fixed marker. RM may
be the same as I and may be on any part in your system.
VFOSUB.
Tip: Depending on the nature of the desired force relationship, the RM marker may belong to
the same part as the I marker, or the JFLOAT marker, or to a third, unrelated part.
203 VFORCE
C++Commands
Example
VFORCE/ 10, LI ST &
, FX= - 90. 5*Dx( 109, 102, 102) - 9. 05*Vx( 109, 102, 102, 102) \ &
, FY= - 90. 5*Dy( 109, 102, 102) - 9. 05*Vy( 109, 102, 102, 102) \ &
, FZ=- 750. 8*Dz( 109, 102, 102) - 75. 08*Vz( 109, 102, 102, 102)
Caution: The user-defined functions FX, FY, and FZ should be smooth, continuous, and single-
valued. These conditions make the solution process very effective.
Adams/Solver
C++Commands
204
VTORQUE
The VTORQUE command redefines and/or lists the data for a VTORQUE statement that defines a vector
torque that consists of three orthogonal components.
Format

Arguments
FUNCTION=USER(r1[,...,r30]) Respecifies up to thirty user-defined constants used to compute the
torque components in an externally-defined subroutine VTOSUB
(see the VTOSUB subroutine).
JFLOAT=id Respecifies the marker on the part to which Adams/Solver (C++)
applies the reaction torque. You must ensure that the JFLOAT marker
is a floating marker and on a different part than the I marker.
Adams/Solver (C++) moves the JFLOAT marker to keep it
superimposed on the I marker. Adams/Solver (C++) does not
calculate reaction forces when the JFLOAT marker is on the ground
part.
I=id Respecifies the marker on the part to which Adams/Solver (C++)
applies the action torque. You must ensure that the I marker is a fixed
marker and on a different part than the JFLOAT marker.
LIST Lists the current values of the VTORQUE arguments.
VTOSUB.
RM=id Respecifies the marker that determines the orientation of the torque
components. You must ensure that RM is a fixed marker. RM may be
the same as I and on any part in the system.
205 VTORQUE
C++Commands
Extended Definition
The VTORQUE command lists or redefines a force element that consists of three mutually orthogonal
translational torque components. You can alter one or both points of torque application, change the torque
reference marker, and change the torque function expressions or the parameters passed to the VTOSUB
user-written subroutine.
After a change to a VTORQUE, Adams/Solver (C++) reprocesses the model at the next SIMULATE
While checking, Adams/Solver (C++) verifies that the model is still valid with the new VTORQUE. If,
for example, the VTORQUE function expression refers to an inactive element, Adams/Solver (C++)
issues an error.
TX=e Respecifies the magnitude and sign of the x component of the torque
exerted by the VTORQUE element. The direction of this torque
component is parallel to the x-axis of the RM marker in the sense of
the right-hand rule (i.e., a positive torque causes a counterclockwise
rotation).
TY=e Respecifies the magnitude and sign of the y component of the torque
component is parallel to the y-axis of the RM marker in the sense of
the right-hand rule (that is, a positive torque causes a
counterclockwise rotation).
TZ=e Respecifies the magnitude and sign of the z component of the torque
component is parallel to the z-axis of the RM marker in the sense of
the right-hand rule (that is, a positive torque causes a
counterclockwise rotation).
Tip: Depending on the nature of the desired torque relationship, the RM marker may belong to
the same part as the I marker or the JFLOAT marker, or to a third, unrelated part.
Adams/Solver
C++Commands
206
Caution: The user-defined functions TX, TY, and TZ should be smooth, continuous, and single-
valued. These conditions make the solution process very effective.

C++ Commands Reference

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

C++ Commands Reference

Hochgeladen von

Copyright:

Verfügbare Formate

1

Das könnte Ihnen auch gefallen