The LINEAR command is divided into the following sections:

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 MATRIXx 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 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 "closedbox" sub option equivalent to a state space representation, and a "openbox" sub option in which an element-to-element export is performed. Using the "openbox" sub option, rigid Adams PARTS are exported as CONM2 cards, Adams JOINTS are exported as RJOINT cards or sets of MPC cards and so on. Both the "closedbox" and "openbox" 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.

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 OPENBOX option.

For theoretical details on the linearization algorithm, see the white paper in Simcompanion Article KB8016460.

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_STATICS_NO_RESTORE_VELOCITIES 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.

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:

where:

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 best choice. In rotational systems (turbines, helicopter blades and so on), 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:

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.

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:

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 α and u.

The exact equations of motion in terms of the shown coordinates are the following:

where:

 

Setting m1=m2=3, I1=I2=10, e=1, K=5, uo=10 and selecting an operating point defined by t=0, α =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:

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:

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:

Where MARKER/5 is located on the first link. The corresponding results are:

Notice that the selected states now coincide with α and u and that the results match the theoretical ones.

For an example of using RM, see Simcompanion Knowledge Base Article KB8016438.

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:

The following example illustrates these steps.

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:

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:

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:

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:

The corresponding results are:

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:

For an example of using PSTATE, see Simcompanion Knowledge Base Article KB8016414

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.

If you specify the COORDS, KINETIC, DISSIPAT, STRAIN, FCOORDS, FKINETIC, FDISSIPAT or FSTRAIN arguments, Adams Solver (C++) computes tabular output tables and writes them to an ASCII text file. The name of the text file has the same base name as the message file and it has an extension *.txt. For each mode in the specified mode range or frequency range, the printed output could consist of up to five sections.

The first section is a header that contains the mode number, undamped natural frequency, the absolute value of the damping ratio, generalized stiffness, generalized mass and model energy for the mode. Generalized stiffness and generalized mass are in user-specified units. See section Units in Coordinates, Kinetic, Dissipative and Strain modal tables for units used in the tables.

The following lines show the eigenvalues of simple model (this output is taken from a message file). In this particular case all eigenvalues have an imaginary part:

Assuming the above eigensolution was generated using the command:

The corresponding tabular output found in the text file for mode number 1 looks as follows:

 

For the case of a vibrational mode, Adams Solver (C++) defines the following quantities:

e = a + bi

damping ratio = abs(a / undamped natural freq.)

Undamped natural freg. =

Where e=a+bi is the corresponding eigenvalue. In case the magnitude of the eigenvalue is zero, the damping ratio is defined as zero. Notice above the printed value of the first eigenvalue's real part is zero. However, this is just a formatting choice to print zeros for very small numbers. The real part is very small hence the small value for the damping ratio printed in the header above.

The following lines show the eigenvalues of second simple model where all eigenvalues don't have imaginary parts:

This corresponding header for the first mode is now:

 

For the case of non-vibrational modes (imaginary part is zero), the damping ratio and undamped natural frequencies are defined by Adams Solver (C++) as:

Undamped natural freg. = abs(a)

In all cases (for either real-only or imaginary eigenvalues), the generalized stiffness, generalized mass and kinetic energy are defined as follows:

Generalized mass = 2 * (Total energy)

Kinetic energy = 2.0 * (Generalized mass) * (undamped freq)2 *

Generalized stiffness = 2 * (Kinetic energy)

Where a is real part of the corresponding eigenvalue. The Total energy is computed as the summation of all the kinetic energy corresponding to all rigid and flexible inertial objects in the Adams model. The kinetic energy is computed with the velocity entries in the corresponding eigenvector. See more details on the kinetic energy computation in Section 5.1.6.

The second section is a table of coordinates if the COORDS or FCOORDS argument is specified. This section is not output if the COORDS or FCOORDS argument is not specified or if the particular mode number is not within the range specified on the COORDS or FCOORDS 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 or FKINETIC 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 or FKINETIC 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 or FSTRAIN argument is 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 STRAIN or FSTRAIN 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.

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. An X indicates locations for contributions for individual elements. The column labeled Total contains a summation of the strain/dissipative power contribution due to the element in various directions.

The fifth section is a table of modal dissipative power distribution if the DISSIPAT or FDISSIPAT argument is 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 DISSIPAT or FDISSIPAT 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 power 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.

By default, all tabular real data is printed using a format displaying only two decimal values. If engineering format is required, use the TABLE_PRECISION option with a value bigger than 2. If the precision is set to 3 or bigger, an engineering (exponential) format is use. Moreover, option NAMES will force Adams Solver (C++) to add the Adams View names found in the Adams modeling database.

Modal energy tables are printed to an ASCII *.txt file when the options KINETIC or FKINETIC are used. This section provides more details on how the kinetic energy tables are computed for the case of rigid PARTs and FLEX_BODIES. The case of POINT_MASSs is handled similarly. Figure 8 (a) shows a typical PART at the moment a linearization command is issued. Notice the principal inertia frame 1-2-3 of this PART (in blue color) is not necessarily coincident with the global reference frame x-y-z shown in black. At the current principal orientation 1-2-3 the inertia tensor I (considering only the rotational coordinates) is the following:

The first step in preparing the contribution of this PART to the kinetic energy tables is to transform the principal inertia tensor expressing it in global coordinates coincident with the x-y-z frame as shown in Figure 8 (b).

The inertia tensor of this PART expressed in global coordinates x-y-z is the following:

.

Where A is the local kinematic transformation from the 1-2-3 frame to the global frame. Notice the terms , and can be negative. With the inertia tensor aligned with the global reference frame, the kinetic energy K has this expression:

In the above expression, a variable with an overbar represents the complex conjugate of z. In order to compute the kinetic energy, velocities and angular velocities are extracted from the corresponding mode shape. In general, these quantities are complex numbers. However, given the symmetry of the inertia tensors, it can be demonstrated that the above expression for the kinetic energy is always a real number bigger or equal than zero. Introducing the following terms:

,

.

the kinetic energy K can be rewritten as:

.

Notice that the terms associated with cross products (RXY, RXZ and RYZ) can be negative when the transformation of the principal moment of inertia from local to global coordinates results in negative products of inertia (off-diagonal terms).

Adams Solver computes the quantities X, Y, Z, RXX, RYY, RZZ, RXY, RXZ and RYZ and prints them as shown below.

 

The kinetic energy for FLEX_BODYs has the following expression:

.

Here v, w and stand for vector quantities (velocity, angular velocity and modal velocities respectively) and the overbar indicates a complex conjugate. The notation matches that of the FLEX_BODY theoretical documentation.

Notice matrix Mtt is a 3x3 diagonal matrix with the total mass of the body in the diagonal terms. Notice also that matrix Mrr is similar to the inertia tensor of a rigid PART. Hence, the contributions of the rigid body motion of the FLEX_BODY is computed exactly the same way as computed for a rigid PART. Therefore the kinetic energy of a FLEX_BODY is expressed as:

Where Modal has the following expression:

Previous to version Adams 2013, the Modal contribution was not reported; that was the reason the kinetic energy did not sum up to 100% in models having flexible bodies.

Starting Adams 2013, the energy tables do report the Modal values along with the total kinetic energy per body. An example typical table is shown below.

Notice in this example the RXY contribution of the rigid PART/2 is negative. Notice also the Modal contribution is particularly important in this case.

Previous section describes the ASCII *.txt output generated by Adams Solver in batch mode or when running the external solver from Adams View. When running the internal solver, the Modal kinetic energy reported by Adams View is split into two terms. The Modal contribution is rewritten as follows:

Where

Term Modal1 is displayed in a two-column table showing the contribution of each individual mode i and corresponding value . Term Modal2 is lumped into a single number called Offset Diagonal Coupling.

For a general linear system of equations:

,

where is the generalized coordinates (S_variables), is the modal coordinates (natural coordinates), is displacement modal matrix and is the displacement mode shape vector i. and and are square matrices with dimensions similar to S_variables vector dimension.

Now define

And furthermore,

, and

The modal coordinates and modal velocities are obtained from

and

And the modal mass, stiffness and damping matrices are obtained from,

, and

The kinetic energy is defined as,

The kinetic energy per mode i is computed as,

The potential energy is defined as,

The potential energy per mode i is computed as,

The dissipative power is defined as,

The dissipative power per mode i is computed as,

cannot be determined, modal energies cannot be computed and Adams solver will issue an error.

The vector of modal participation factor is defined as,

The modal participation factor for mode i is defined as,

The vector of modal participation factor is defined as,

Then the effective mass per mode is calculated as,

Here, the superscript C stands for the complex conjugate

Adams Solver FORTRAN uses an old linearization technology limited to providing good results for static cases only. Adams Solver FORTRAN finds the linearization matrix by assembling the static equations and extracting the linearization matrix from the statics equations to solve. Perhaps the major limitation of Adams Solver FORTRAN is that the linearization matrix is obtained in terms of the simulation states only (global translations and global Euler angles). Adams Solver C++, on the other hand, uses a modern and general algorithm suitable for all operating points (static and dynamic) with no simplifications. Moreover, Adams Solver C++ can linearize the system in terms of arbitrary coordinates; its algorithm is not constrained to use the coordinates used in formulating the equations of motion, any coordinate definition can be chosen. Users may also define the linearization states to be used in the linearization and obtain custom linear representations for the system.

Regardless of the implemented linearization algorithm, the first step is the selection of the independent states for the linearization. The independent states correspond to the minimal state-space representation of the system. When using Adams Solver FORTRAN, the independent states are a subset of the coordinates used to solve the equations of motion (global translations, global Euler angles, differential states). When using the Adams Solver C++, the default linearization states are a subset of global translations and instantaneous global rotations about GROUND origin. The decision was made based on the popularity of global rotations in FEA codes. Hence, the main difference between Adams Solver FORTRAN and Adams Solver C++ is the set of linearization states. Although linearization states may be different, eigenvalues may match (see reference mentioned in Section 1.0). However, modal table results may be different but both are correct. To illustrate this point the model in Figure 9 shows a simple model of a vertical pendulum (red box with a hinge on top) connected by a spring-damper to GROUND (blue box on the right).

The data set describing this model is presented in the Appendix, Listing 6, Listing 7 and Listing 8 show the command files *.acf used to linearize this model using Adams Solver FORTRAN and Adams Solver C++ respectively. Running both solvers the reader can verify both solvers provide the same eigensolution but different results in selected linearization states and different results in modal tables (generalized mass, general stiffness). Observing the message files created by both solvers we first notice the following. The FORTRAN solver reports:

 

Notice the FORTRAN solver selected the horizontal displacement of PART/2 while the C++ solver selected the instantaneous rotation of PART/2 as the respective linearization states. Notice although different, the selected states provide the same eigenfrequency. However, inspecting the *.out file created by the FORTRAN solver, we find:

While the results printed by the C++ solver (in an *.txt) file are:

These results while different are correct given that the generalized mass and generalized stiffness are based on the mode shape which in turn depend on the selected linearization states. Nevertheless, the C++ solver can match the results of the FORTRAN solver by using the PSTATE option. In that regard, Listing 9 shows the command file used to run the C++ solver. Listing 9 executes the linearization using a custom coordinate defined by VARIABLE/5:

 

VARIABLE/5 defines the global horizontal translation of PART/2 (used by the FORTRAN solver). Running the C++ solver and observing the message file we find:

 

This message means the C++ solver honored the request of the PSTATE option in the LINEAR command. The reader can now verify the *.txt created by the C++ solver matches the computation of the FORTRAN solver.

In case you need to compare the computed eigensolution with results from another software package, you may export the linearization matrices using the LINEAR/STATEMAT option. The exported [A] matrix is the one we send to the eigensolver.

In general, the issues affecting the quality of the eigensolution are the following:

The technical literature usually makes no difference between an eigenvector and a mode shape by using the terms interchangeably. In Adams, however, we use the term eigenvector for the vectors z in the solution of the complex eigenproblem:

where matrix A corresponds to the minimum state-space representation of the model. The size of array z, in the most general case, has this value:

where is the number of degrees of freedom and is the number of differential equations in the model. The number of degrees of freedom is computed from:

where is the number of coordinates used to define the model and m is the number of constraint equations. Adams Solver C++ does not scale the eigenvectors z nor makes them available for the user. If there is a need to obtain the z eigenvectors, the user may obtain the A matrix using the STATEMAT option and compute the eigenvectors using a third party code. Notice that which implies only a subset of all coordinates is used perform the linearization. Moreover, the user may define linearization states using the PSTATE option. In any case, the list of linearization states is printed in the message file and exported to a text file when using the STATEMAT option.

When using the Post-processor, the raw eigenvectors z are not usable for visualizing the vibrations of the model. In order to visualize the vibrations of the model, Adams defines the mode shapes as follows:

where matrix T is a transformation from the minimal state-space representation to the full set of coordinates used in the model. Matrix T is obtained during the reduction from the full Lagrange equations of motion to the minimum state-space representation. Mode shapes are scaled by searching for the entry with the largest modulus and dividing the vector by the entry with the largest modulus.

The size of the mode shapes is given by the following expression:

Mode shapes are available to the user in the results files and they are used by the Post-processor to perform animations of the vibrating model. Mode shapes are also printed to a text file when using the COORD option in the LINEAR command.

Given that Modal coordinates tables, as well as kinetic, dissipative and strain energy tables are computed using normalized eigenvectors, length units have been dropped out.

For example, the generalized stiffness and the kinetic energy are displayed using units of User-mass/time^2:

Theoretically, energy has units of mass times velocity square. Dropping the length dimension, we obtain mass/time^2.

There are three important differences between the Adams Solver C++ and Adams Solver FORTRAN regarding the linearization implementation. Nevertheless, these differences can be controlled by the keyword ORIGINAL and/or three environment variables. The environment variables can be used independently in any combination.

Specifying option ORIGINAL is equivalent to setting the above three environment variables.

If you issue the LINEAR/STATEMAT command, Adams Solver (C++) computes the state matrices representation of the Adams model. The linearized Adams model is represented as:

where:

Matrices A, B, C and D are exported to the text file specified in the FILE option of the command. The exported text file includes a STATES matrix with information on the state vector s. Moreover, the export will create matrices PINPUT and POUTPUT with information on the inputs and outputs to the plant.

Vector s stands for the minimum state-space realization of the model. If you do not specify RM nor PSTATE options, Adams Solver (C++) will select the best choice of the coordinates in order to perform the linearization of the model. In general, vector s will have this format:

Where xi stands for a position state, vi stands for the corresponding time derivative, and zi stands for a differential state in the model. You could inspect vector s in the output file under the STATES matrix. See Section 5.2.6 for more information on the contents of the STATES matrix.

By default all exported matrices (A, B, C, D, STATES, PINPUT, POUTPUT) are exported in a single file using the MATRIXX format. If you specify the FORMAT=MATLAB option in the command, then Adams Solver C++ will export up to seven files named xxxa, xxxb, xxxc, xxxd, xxxst, xxxpi and xxxpo, where 'xxx' stands for the root filename specified in the mandatory FILE=filename option of the LINEAR/STATEMAT command.

If you specify the MKB option, Adams Solver (C++) computes an alternative form of the state matrices representation for an Adams model. In this case, the linearized Adams model is first linearized in this format:

Where x are the position level linearization states and z stands for the differential states. Defining:

The state vector s is defined now as:

With this definitions the first equations of the state representation can be written as follows:

Defining:

We obtain:

where:

Matrices M, KB, P, C and D are exported to the text file specified in the FILE option of the command. The exported text file includes a STATES matrix with information on the state vector s. Moreover, the export job will create matrices PINPUT and POUTPUT with information on the inputs and outputs to the plant.

The MKB option is useful if you need to export the Adams model to be a subsystem of an MSC.NASTRAN model.

See sections Using the RM and PSTATE options.

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

Following the above recommendation you may properly model both open-loop and close-loop control systems.

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.

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, 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.

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 can take on the following values:

Element_identifier is the eight-digit Adams Solver (C++) identifier of the element.

If Type_of_element=1, the Element_coordinate can take on the values:

If Type_of_element=21, the Element_coordinate can take on the values:

If Type_of_element=31, the Element_coordinate can take on the values:

If Type_of_element=27, the Element_coordinate can take on the values depending on the DOF index in the FE_Part.

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:

For Type_of_Element=28, the Element_coordinate can take on the values:

For Type_of_Element=38, the Element_coordinate can take on the values:

For Type_of_Element=9, the Element_coordinate can take on the following values:

For Type_of_Element=29, the Element_coordinate can take on the following values:

For Type_of_Element=39, the Element_coordinate can take on the following values:

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)

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:

The first entry in the PINPUT (or POUTPUT) exported data contains the Adams Solver (C++) identifier of the PINPUT (or POUTPUT) statement that was used on the LINEAR command to generate the state matrices. Subsequent entries contain the Adams Solver (C++) identifiers of the VARIABLEs defining the PINPUT (or POUTPUT) statement. Using either the MATRIXX or the MATLAB format option, 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.

Using the EXPORT option Adams Solver (C++) exports the linearized Adams model as a set of Nastran bulk data deck files. The Nastran bulk data deck export is also known as "Adams-to-Nastran". In a few words, this option creates an equivalent Nastran model (linear model) equivalent to the Adams model at the operating point when the export command is executed. Adams-to-Nastran can be seen as a model translation process. The translation process is done with high fidelity. For medium to small models, eigenvalues computed in the Adams environment will match eigenvalues computed in the Nastran environment.

The syntax to invoke the EXPORT job calls for the type of export (OPENBOX or CLOSEDBOX), 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.

The translation process supports two types of EXPORT jobs, namely, a OPENBOX option or a CLOSEDBOX option which must be specified using the TYPE argument. These two types are conceptually different. Using the CLOSEDBOX option, Adams Solver (C++) computes the MKB matrices and exports the model as a set 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 OPENBOX 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.

There are no limitations on the type of previous analysis prior to the invocation of the LINEAR/EXPORT command if using the CLOSEDBOX 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 CLOSEDBOX export.

When using the OPENBOX 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_STATICS_NO_RESTORE_VELOCITIES.

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 OPENBOX. No CLOSEDBOX export is possible for that type of operating point.

The CLOSEDBOX option exports the following cards:

The OPENBOX option exports the following cards:

Both, CLOSEDBOX and OPENBOX options export the following cards

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:

Data definitions have the syntax:

If a KEY is repeated, the latest definition is used. Comments start with the character $. The contents are case sensitive.

The list of current supported directives, using the following format:

 

 

 

 

 

 

 

 

 

 

 

 

 

 

A typical configuration file using solution 107 is the following:

A typical configuration file using solution 108 is the following:

The CLOSEDBOX option exports the state space matrix representation of the Adams model following an exact approach mentioned in section 1.0 above. The CLOSEDBOX export is straight forward to implement.

On the other hand, the OPENBOX 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:

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 Equation  (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:

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:

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:

The linearized equations of motion have this form:

Multiplying the first row by P and summing it to the second row we find:

Combining this result with Equation  (4) we arrive to:

This is the set of assembled equations of motion obtained from the linearized constraint equations
(Equation  (3)) and the linearized equations of motion (Equation  (5)).

Feasibility of the export approach

Comparing Equation  (6) and Equation  (2) we notice that, in the general case, eigenvalues computed by those two equations do not match. The complete variation of Equation  (2) involves terms that are missing in Equation  (2). (Notice that matrix P in Equation  (6) is a constant.)

However, both Equation  (6) and Equation  (2) will produce the same eigenvalues only for the static case. If both velocities and accelerations are zero, several terms drop from Equation  (2) and matching expressions are obtained except for the right-hand side (applied forces). The variation of the right-hand side on Equation  (2) is:

which compared with the right-hand side of Equation  (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 (OPENBOX option) are the following:

The command

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

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.

There are several areas in which the LINEAR command is required. Some examples include:

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

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.

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 11 (a) and (b) show mode shapes for mode 1, which is unstable, and mode 4, which is stable.

Figure 11 (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.

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.

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 12 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.

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.

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 13 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).

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.

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 14. The closed-loop model response to external disturbance is as shown in Figure 15. As illustrated in this figure, the closed-loop model provides complete disturbance rejection for displacement of PART/2.

The input signal applied to the actuator and the force generated by the actuator are shown in Figure 16 and Figure 17, respectively.

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.

Listing 6: Input data file used in Section Differences in results compared with Adams Solver FORTRAN

 

Listing 7: Adams Solver FORTRAN command file used in section Differences in results compared with Adams Solver FORTRAN.

 

Listing 8: Adams Solver C++ command file used in Section Differences in results compared with Adams Solver FORTRAN.

 

Listing 9: Adams Solver C++ command file used in Section Differences in results compared with Adams Solver FORTRAN using PSTATE.

 

See other Simulation available.