You use an environmental variable, MDI_SOLVER_SELECT, to choose the solver. If you don’t specify the solver you want, ADAMS/Solver (FORTRAN) is automatically used.

When you select ADAMS/Solver (C++), a checking function is invoked to see if it can handle the model (.adm file) being analyzed. If ADAMS/Solver (C++) cannot handle the model, control is automatically passed to ADAMS/Solver (FORTRAN). When an unsupported command (in the .acf file) is encountered, ADAMS/Solver (C++) issues an error message and subsequently halts the simulation.

The following steps show how specify the environment variable for UNIX and Windows.

To select ADAMS/Solver (C++) on UNIX, do one of the following:

• In the MSC.ADAMS Toolbar, change the Solver Select setting to C++.

• Set the following environment variable using the appropriate shell commands for your version of UNIX:
  
       Set MDI_SOLVER_SELECT to CXX.
  

To select ADAMS/Solver (C++) on Windows:

1. From the Start menu, point to Settings, and then select Control Panel.

2. In the Control Panel dialog box, select the System icon.

3. In the System Properties dialog box, select the Advanced tab.

4. In the Advanced tab container, select Environment Variables.

5. In the Environment Variables dialog box, create a new user variable as follows:

        Variable Name = MDI_SOLVER_SELECT
        Variable Value = CXX (for ADAMS/Solver (C++))
   

To specify ADAMS/Solver (C++) in ADAMS/View:

1. From the Settings menu, point to Solver, and select
   Solver Executable.

2. Set Choice to C++.
   
   This executes the command simulation set choice = cplusplus.

To specify ADAMS/Solver (C++) in an ADAMS/Solver .acf file:

• Use the PREFERENCES/SOLVER=CXX command.
  
  This is an undocumented feature and additional details can be found in the Knowledge Base Article 10431.

GCON Generalized CONSTRAINT statement (C++ only)

A new, expression-based constraint element, GCON, is available in the 2003 release. Nonstandard, user-defined constraints may be defined right inside the dataset as:

GCON/id, [I=id,] fun=expression

User-defined constraints may be holonomic (defined in terms of displacements only), or non-holonomic (linearly depending on velocities).

User-defined constraints are allowed to also depend on VARIABLES, provided the VARIABLES only depend on time, positions, and velocities. This was not possible in the past.

Note: Use of the GCON statement is limited to the .adm file. Currently there is no ADAMS/View graphical user interface or command language support associated with this statement. However, models and simulation results can be imported into ADAMS/View for visualization purposes.

Vector operators added to expression language (C++ only)

This release marks the introduction of a new concept in the expression language of ADAMS/Solver. The function expression language has been enhanced with several new functions and operators. Function expressions can now use vector operations, as long as the final value of the expression is scalar. This often simplifies expression writing and is convenient when using the expression-based GCON constraint.

With these new functions and operators in place, you can now use 3D expressions. At this time, however, this 3D expression feature has limited availability and is only accessible from the GCON statement and command.

The new operators and functions are:

Examples:

DXYZ(1,2) is equivalent to [ DX(1,2), DY(1,2), DZ(1,2) ]

UV(DXYZ(1,2)) is equivalent to DXYZ(1,2)/DM(1,2) except that UV handles more gracefully the case where DM goes to zero.

MAG ( DXYZ(1,2) % DXYZ(3,4)) is the magnitude of the cross-product between two displacement vectors.

SURFACE statement (C++ only)

A new SURFACE entity is now supported. You can specify surface through data that is contained in a Parasolid file (sheet body), or user-defined subroutine (SURSUB). Surfaces are used to define SURFACE markers. These are then used to create a wide variety of constraints, previously not possible. Note that the surface must consist of only a single face.

The ADAMS/Solver (C++) uses the face (u-v) parameters as states for the surface marker, so they must be continuous in the region in which the surface marker moves (the parameters can be bounded or periodic).

CURVE and SURFACE markers (C++ only)

MARKERS can be defined to act like a CURVE or a SURFACE. These MARKERS can be used in any context where a regular MARKER could be. A variety of new and useful constraints can be modeled by defining standard "lower pair" constraints combined with CURVE and SURFACE MARKERS.

Some examples include: 

All standard kinematic measures (DX(…), VZ(…)) work as expected with CURVE and SURFACE markers. Using these measures, it is possible to obtain curve/surface tangent and normal directions, slip velocities, and so on, very easily.

PLANAR argument for PART statement (C++ only)

A new argument, PLANAR, indicates that a PART only has three degrees-of-freedom (global X and Y translations, and a rotation about the global Z axis). It is best to think of the planar as a regular 3D part with a built-in planar joint. This is a combination of elements often found in certain models that contain 2D subsystems, such as belts or chains. Unlike a part and a planar joint pair which combine to add 18 equations to an index 3 dynamic analysis in ADAMS/Solver, the planar part only adds 6 equations. Fewer equations can improve performance, but since the planar part can be contained in a full 3D MSC.ADAMS model, coexist with and connected to 3D part elements, performance will not match software for 2D dynamics analysis.

ADAMS/Solver (C++) alternative for ADAMS/Car and ADAMS/Chassis (C++ only)

Previously, models created with ADAMS/Car or ADAMS/Chassis could only run using ADAMS/Solver (FORTRAN). Now, the functionality gap between ADAMS/Solver (C++) and ADAMS/Solver (FORTRAN) has decreased significantly. This allows ADAMS/Solver (C++) to run models created in ADAMS/Car or ADAMS/Chassis. This progress is part of the continuation of our long-term transition plan for advancement of ADAMS/Solver (C++).

The performance of ADAMS/Solver (C++) has improved since version 12.0. Our work up to this point has focused on functionality (getting everything working and making sure the answers are correct). You can now run most car models with ADAMS/Solver (C++) except those that use compliance matrix interface or that have the unsupported features outlined earlier (see table above).

MOTION statement may be dependent on VARVAL (C++ only)

You are no longer required to use ADAMS/Solver (FORTRAN) when using a VARVAL function to define a MOTION element. In fact, it works considerably better in ADAMS/Solver (C++). For example, in ADAMS/Solver (C++) during velocity ICs, the motion will be subject to the time derivative of the variable. ADAMS/Solver (FORTRAN) just uses zero. In order to preserve legacy behavior, MOTION will not transmit reaction forces through its function expression.
For this reason, you are still not encouraged to introduce state dependencies through motion functions. You should use the new GCON element to create complex constraints rather than the MOTION element.

MFORCE support (C++ only)

It is no longer a requirement to use ADAMS/Solver (FORTRAN) when using the MFORCE. For details see What's New in ADAMS/Flex.

MARKERs on flexible bodies (C++ only)

It is no longer a requirement that the location of a marker on a flexible body be coincident with a node. For details see What's New in ADAMS/Flex.

Extended modeling element compatibility for flexible bodies
(C++ only)

All joints, joint primitives, and motion generators can now be attached directly to a flexible body. For details see What's New in ADAMS/Flex.

Modal coordinate function expressions for flexible bodies
(C++ only)

New function expressions are now available for flexible body modal coordinates and their first two time derivatives. It is no longer a requirement to use a user-written subroutine. For details see What's New in ADAMS/Flex.