MotionView 2017 Tutorials PDF

HyperWorks 2017
MotionView
Tutorials
Learn more at altairhyperworks.com

Copyrights, Trademarks, Patents and Third Party Licenses
Intellectual Property Rights Notice:
Copyrights, Trademarks, Trade Secrets, Patents & Third Party Software Licenses
Altair HyperWorks v.2017
A Platform for Innovation
Copyright 1986-2016 Altair Engineering Inc. All Rights Reserved.
Special Notice: Pre-release versions of Altair software are provided as is, without warranty of any
kind. Usage is strictly limited to non-production purposes.
HyperWorks 2017 Products

HyperMesh 1990-2016; HyperCrash 2001-2016; OptiStruct 1996-2016; RADIOSS 1986-2016;
HyperView 1999-2016; HyperView Player 2001-2016; HyperMath 2007-2016; HyperStudy
1999-2016; HyperGraph 1995-2016; MotionView 1993-2016; MotionSolve 2002-2016;
HyperForm 1998-2016; HyperXtrude 1999- 2016; Process Manager 2003-2016; Templex
1990-2016; TextView 1996-2016; MediaView 1999-2016; TableView 2013-2016; BatchMesher
2003-2016; HyperWeld 2009-2016; HyperMold 2009-2016; Manufacturing Solutions 2005-2016;
solidThinking Inspire 2017 2009-2016; solidThinking Evolve 2017 1993-2016; Durability Director
2009-2016; Suspension Director 2009-2016; AcuSolve 1997-2016; AcuConsole 2006-2016;
SimLab 2004-2016; Virtual Wind Tunnel 2012-2016; FEKO (1999-2014 Altair Development S.A.
(Pty) Ltd.; 2014-2016 Altair Engineering, Inc.); ConnectMe 2014-2016.
Additional Altair Products:

Multiscale Designer 2011-2016; Flux v.12.2 1983-2016; InCa3D v.3.1 1996-2016; CDE v.2
2012-2016; Got-It v.3 2002-2016; WinProp v.14 2000-2016
Altair Packaged Solution Offerings (PSOs) Copyright 2008-2016

Automated Reporting Director 2008-2016; GeoMechanics Director 2011-2016; Impact Simulation
Director 2010-2016; Model Mesher Director 2010-2016; Model Verification Director 2013-2016;
NVH Director 2010-2016; Squeak and Rattle Director 2012-2016; Virtual Gauge Director
2012-2016; Weight Analytics 2013-2016; Weld Certification Director 2014-2016
Altair Simulation Cloud Suite:

Simulation Manager 2003-2016; Compute Manager 2003-2016; Display Manager 20032016;
and Process Manager 2003-2016.
Altair PBS Works:

Compute Manager 2012-2016; Display Manager 2013-2016; PBS 1994-2016; PBS
Pro 1994-2016; PBS Professional 1994-2016; PBS Application Services 2008-2016; PBS
Analytics 2008-2016; and PBS Desktop 2008-2012; e-Compute 2000-2010; OpenPBS
1994-2003 and Personal PBS 2008-2012.
Software products of solidThinking, Inc., a wholly owned subsidiary of Altair Engineering:

solidThinking Inspire 2017 2009-2016; solidThinking Evolve 2017 1993-2016; solidThinking
Compose 2017 2007-2016; solidThinking Activate 2017 1989-2016; solidThinking Embed 2017
1989-2016; solidThinking Embed SE 2017 1989-2016; Click2Extrude Metal 2017 1996-2016;
Click2Extrude Polymer 2017 1996-2016; Click2Cast 14.0 2011-2016; Click2Form 2017
1998-2016; Envision 2013-2016.
ALTAIR ENGINEERING INC. Proprietary and Confidential. Contains Trade Secret

Information.
Not for use or disclosure outside of Altair and its licensed clients. Information contained in Altair
software shall not be decompiled, disassembled, unlocked, reverse translated, reverse engineered, or
publicly displayed or publicly performed in any manner. Usage of the software is only as explicitly
permitted in the end user software license agreement. Copyright notice does not imply publication.
Third party software licenses

AcuConsole contains material licensed from Intelligent Light (www.ilight.com) and used by permission.
Software Security Measures:

Altair Engineering Inc. and its subsidiaries and affiliates reserve the right to embed software security
mechanisms in the Software for the purpose of detecting the installation and/or use of illegal copies of
the Software. The Software may collect and transmit non-proprietary data about those illegal
copies. Data collected will not include any customer data created by or used in connection with the
Software and will not be provided to any third party, except as may be required by law or legal process
or to enforce our rights with respect to the use of any illegal copies of the Software. By using the
Software, each user consents to such detection and collection of data, as well as its transmission and
use if an illegal copy of the Software is detected. No steps may be taken to avoid or detect the
purpose of any such security mechanisms.
Technical Support
Altair provides comprehensive software support via web FAQs, tutorials, training classes, telephone,
and e-mail.
Altair Support on the World Wide Web
The Altair web site is a valuable online companion to Altair software. Visit www.altairhyperworks.com
for tips and tricks, training course schedules, training/tutorial videos, and other useful information.
Altair Training Classes
Altair training courses provide a hands-on introduction to our products, focusing on overall
functionality. Courses are conducted at our main and regional offices or at your facility. If you are
interested in training at your facility, please contact your account manager for more details. If you do
not know who your account manager is, please send an e-mail to training@altair.com and your account
manager will contact you.
Telephone and e-mail
When contacting Altair support, please specify the product and version number you are using along
with a detailed description of the problem. Many times, it is very beneficial for the support engineer to
know what type of workstation, operating system, RAM, and graphics board you have, so please have
that information ready. If you send an e-mail, please specify the workstation type, operating system,
RAM, and graphics board information in the e-mail.
To contact an Altair support representative, reference the following table or the information available
on the HyperWorks website:
http://www.altairhyperworks.com/ClientCenterHWSupportProduct.aspx
Location Telephone e-mail
Australia 64.9.413.7981 anzsupport@altair.com
Brazil 55.11.3884.0414 br_support@altair.com
Canada 416.447.6463 support@altairengineering.ca
China 86.400.619.6186 support@altair.com.cn
France 33.1.4133.0992 francesupport@altair.com
Germany 49.7031.6208.22 hwsupport@altair.de
India 91.80.6629.4500 support@india.altair.com

1.800.425.0234 (toll free)
Italy 39.800.905.595 support@altairengineering.it
Japan 81.3.5396.2881 support@altairjp.co.jp
Korea 82.70.4050.9200 support@altair.co.kr
Mexico 55.56.58.68.08 mx-support@altair.com

New Zealand 64.9.413.7981 anzsupport@altair.com
North America 248.614.2425 hwsupport@altair.com
Scandinavia 46.46.460.2828 support@altair.se
Spain 34.910.810.080 support-spain@altair.com
South Africa 27.21.8311500 support@altair.co.za
United Kingdom 01926.468.600 support@uk.altair.com
For questions or comments about this help system, send an email to hwsupport@altair.com.
In addition, the following countries have resellers for Altair Engineering: Colombia, Czech Republic,
Ecuador, Israel, Russia, Netherlands, Turkey, Poland, Singapore, Vietnam, Indonesia
Official offices with resellers: Canada, China, France, Germany, India, Malaysia, Italy, Japan, Korea,
Spain, Taiwan, United Kingdom, USA
See www.altair.com for complete contact information.
MotionView Tutorials
Access the Model Files

..........................................................................................................................2
Introduction
..........................................................................................................................3
MV-100: Introduction to the MotionView Environment

........................................................................................................................................................4
Interactive
..........................................................................................................................33
MV-1000: Interactive Model Building and Simulation

........................................................................................................................................................34
MV-1035: Importing CAD or FE into MotionView

........................................................................................................................................................68
MV-1011: Extension and Retraction Analysis of the Main Landing Gear of an Aircraft
........................................................................................................................................................84
Animation
..........................................................................................................................94
MV-5000: Rigid body Animation - Basic

........................................................................................................................................................95
MV-5010: Rigid body Animation - Advanced

........................................................................................................................................................101
Plotting
..........................................................................................................................106
MV-6000: Plotting Basics

........................................................................................................................................................107
Model Definition Language

..........................................................................................................................112
MV-1060: Introduction to MDL

........................................................................................................................................................113
MV-1070: Creating a Simple Pendulum System using MDL

........................................................................................................................................................128
MV-1080: Creating an Analysis using MDL

........................................................................................................................................................145
MV-1090: Creating a Dataset using MDL

........................................................................................................................................................151
MV-1030: Creating a System Definition Using the MotionView GUI

........................................................................................................................................................155
Contact Simulation
..........................................................................................................................168
MV-1010: 3D Mesh to Mesh Contact Simulation

........................................................................................................................................................169
MV-1012: Analytical Contact Simulation using MotionView and MotionSolve

........................................................................................................................................................188
MV-1020 Modeling 2D Rigid to Rigid Contact Simulation

........................................................................................................................................................203
Flexible Body Modeling and Simulation using MotionView and

..........................................................................................................................226
MotionSolve
Altair Engineering MotionView 2017 Tutorials i

Proprietary Information of Altair Engineering
MV-2000: Introduction to Flexible Bodies
........................................................................................................................................................227
MV-2010: Flexbody Generation using Flex Prep and Optistruct

........................................................................................................................................................231
MV-2020: Use of Flexbody in MBD Models

........................................................................................................................................................248
MV-2021: Simulating an Automotive Door Closure Event

........................................................................................................................................................254
MV-2035: Solving Flexbody ADM/ACF in MotionSolve

........................................................................................................................................................264
MV-2040: Load Estimation for a Fore Canard Actuator Mechanism under Aero-dynamic
........................................................................................................................................................269
Loads
Automated
..........................................................................................................................294
MV-1032: Model Building and Simulation using Wizards

........................................................................................................................................................295
MV-1040: Model Building using Tcl

........................................................................................................................................................304
MV-1050: Automation Using TCL

........................................................................................................................................................313
MV-1051: Understanding Sequential Simulation

........................................................................................................................................................316
Optimization-DOE-Stochastics
..........................................................................................................................323
MV-3000: DOE using MotionView - HyperStudy

........................................................................................................................................................324
MV-3010: Optimization using MotionView - HyperStudy

........................................................................................................................................................345
Durability - Fatigue
..........................................................................................................................351
MV-3030: Load Export

........................................................................................................................................................352
MV-3040: Durability and Fatigue Tools

........................................................................................................................................................359
Non-Linear Finite Elements

..........................................................................................................................367
MV-2100: Introduction to Non-Linear Finite Element (NLFE) Analysis in MotionSolve

........................................................................................................................................................368
MV-2110: Using an NLFE Helical Spring in a Cam-Follower Mechanism

........................................................................................................................................................388
Advanced Simulation
..........................................................................................................................408
MV-1015: Using Spline3D to Model Combustion Forces in an Engine

........................................................................................................................................................409
MV-1023: Using Python Subroutines in MotionView Model Building

........................................................................................................................................................426
MV-1024: Using User Subroutines in MotionSolve Models

........................................................................................................................................................443
MV-1025: Modeling Point-to-Curve (PTCV) Higher-Pair Constraint

........................................................................................................................................................450
MV-1026: Modeling Curve-to-Curve (CVCV) Higher-Pair Constraint

........................................................................................................................................................466
MV-1027: Modeling Point-to-Deformable-Curve (PTdCV) Higher-Pair Constraint

........................................................................................................................................................485
MV-1028: Modeling Point-to-Deformable-Surface (PTdSF) Higher-Pair Constraint

........................................................................................................................................................494
ii MotionView 2017 Tutorials Altair Engineering

MV-1029: Modeling Point-to-Deformable-Surface Force (PTdSF)
........................................................................................................................................................503
MV-7000: Modeling Differential Equations Using MotionView and MotionSolve

........................................................................................................................................................512
MV-7001: Building User Subroutines in Altair MotionSolve

........................................................................................................................................................519
MV-7003: Simulating a Single Input Single Output (SISO) Control System Using
........................................................................................................................................................529
MotionView and MotionSolve
MV-7004: Inverted Pendulum Control Using MotionSolve and MATLAB
........................................................................................................................................................533
MV-7005: Linking Matlab/Simulink Generated Code (Simulink Coder) with MotionSolve

........................................................................................................................................................540
MV-7006: Python UserSub for MotionSolve

........................................................................................................................................................551
MV-7007: Adding Friction to Joints

........................................................................................................................................................557
MV-7008: Co-simulation with AcuSolve

........................................................................................................................................................575
MV-7002: Co-simulation with Simulink SMP Approach

........................................................................................................................................................594
MV-7009: Co-simulation with Simulink IPC Approach

........................................................................................................................................................606
Working with External Codes

..........................................................................................................................620
MV-4000: Eigen Analysis using ADAMS/Linear

........................................................................................................................................................621
MV-4010: Working with ADAMS

........................................................................................................................................................626
MV-4020: Solver Neutral Modeling

........................................................................................................................................................630
MV-4030: Flexible Bodies for MotionView with Abaqus

........................................................................................................................................................633
Vehicle Simulation using Altair Advance Driver

..........................................................................................................................641
MV-8000: Open Loop Events

........................................................................................................................................................642
MV-8001: Path and Velocity Following

........................................................................................................................................................660
MV-8002: Multi-Maneuver Events

........................................................................................................................................................674
MV-8003: Gear and Clutch Control

........................................................................................................................................................680
Altair Engineering MotionView 2017 Tutorials iii

MotionView Tutorials
See the full listing of available tutorials:
Introduction
Interactive
Animation
Plotting
Contact Simulation
Flexible Body Modeling and Simulation using MotionView and MotionSolve
Automated
Durability Fatigue
Advanced Simulation
Vehicle Simulation using Altair Advance Driver
1 MotionView 2017 Tutorials Altair Engineering

Access the Model Files
Required model files for the tutorials are available online.
1. To access model files, visit Altair Connect or the Altair Client Center.
A user ID and password are required to access the model files. Follow the instructions at the
website to obtain login credentials.
2. Select the required file package and download it onto your system.
Note that the files may require unzipping before proceeding with the tutorials. When extracting
zipped files, preserve any directory structure included in the file package.
Altair Engineering MotionView 2017 Tutorials 2

Introduction
MotionView is one of the applications within HyperWorks Desktop. The following tutorials will introduce
you to model building for multi-body applications using MotionView.
It is recommended that you complete the HWD-0010: HyperWorks Desktop Environment tutorial (in
order to familiarize yourself with the HyperWorks Desktop graphical user interface) prior to going
through the exercises in these tutorials.

This tutorial contains an introduction to the MotionView graphical user interface.
Invoking MotionView:
In Windows - go through the Start Menu (Start Menu > Programs > Altair HyperWorks
installation > MotionView).
OR
In Linux - invoke ~hw_install/altair/scripts/mview in an "open terminal" (where

~hw_install is the location where HyperWorks is installed).
The MotionView interface:
MotionView is one of the clients that reside under the HyperWorks Desktop (HWD) framework. The
framework provides a common layout for all clients. Other clients that are available under this
framework are: Hypermesh, HyperView, HyperGraph 2D, HyperGraph 3D, MediaView, TextView, and
TableView. The client is selected, or changed, using the Client selector drop-down menu:

The image below shows the HWD graphical user interface with MotionView activated as the client:
The HWD graphical user interface can be broadly categorized into six segments:
Main Menu
The Main menu bar includes all functionalities that are available through the various toolbars.
Additionally, the Main menu contains other useful utilities like FlexPrep, Import CAD/FEM, Macros,
etc.
Note - The Main menu varies between the different clients of HyperWorks Desktop.
The following table summarizes the functionalities available in the Main menu of MotionView:
Main Menu Item Functionality Alternatives
File Provides options to manage The same options are available through
files (Creating new models, HWD Standard Toolbar also.
Opening and Saving models/
Sessions, Importing and
Exporting a Solver Deck,
etc.).

Edit Provides options to manage Same options are available through

the pages and windows of a Page Edit Toolbar also.
session (Cut, Copy, Paste,
and Overlay of the page and
window).
View Allows you to manage the

display of the graphical user
interface (the display of
Browsers, Command Window,
Panel Area, Tab Area,
Toolbars, etc.).
Solver Mode Allows you to switch

between solvers modes
(MotionSolve, ADAMS, and
ABAQUS).
Model Allows you to access the

following:
Assembly Wizard
Attachment Wizard
Set Wizard Paths
Implicit Graphics
Data Summary
Topology Summary
Analysis Allows you to access the

following:
Task Wizard
View Reports
Tools Provides you with access to Check Model Available in Run panel.
various tools and special
utilities: Import CAD or Fem Available in
the Main menu (File > Import >
Check Model Import Geometry) and also in the
Freeze Output Ids HWD Standard Toolbar .
Import CAD or FE
Model Identification Tool
CG/Inertia Summary

Custom Wizards
Reports
MS UserSub Build Tool
Templex Functions
Options
FlexTools Provides you with access to

various utilities:
Flex Prep Used for

generation and translation
of flexbody files.
Flex File Gen - Generates

an animation file for ADAMS
flexbody results.
Fatigue Prep Helpful in

the translation of MBD
result files to other formats
useful in fatigue analysis.
Load Export Allows you

to export loads from an
MBD analysis.
Macros Provides you with access to

macros that are useful for
modeling and model
debugging.
Applications Allows you to invoke other

HyperWorks applications from
the MotionView graphical
user interface.
Help Provides you with access to

the online help.

HWD Standard Toolbars
Toolbars provide quick access to commonly used features. HyperWorks Desktop toolbars are
static and will not change, regardless of which application is active. Some of the toolbars
become inactive when different clients are selected. In the table below, all of the HWD toolbars
are introduced. Please be sure to note the toolbars that are not applicable to the MotionView
client.
Toolbar Purpose Image
Client Selecting the HWD client

Selector from the drop-down list.
Standard Options for file

management (Creating,
Editing, Saving, Importing,
and Exporting of files
etc.).
Page Controls Options to:
Create and Delete pages

and windows.
Expand, Swap, and

Synchronize selected
windows.
Note - To navigate
through different pages of
a session, use the
Previous Page or
Next Page buttons

(located at the upper right
corner of the window,
below the menu bar area
and above the graphics
area). See the Page
Display and Navigation
Area topic for additional
information.
Page Edit Options to manage pages

and windows of a session
(Cut, Copy, Paste, and
Overlay of a page and
window).

Animation Provides controls for the

Toolbar animation of results.
Note - Available in HyperView and HyperGraph

only.
Standard Options to view model in

Views different orthogonal views.
3D View Options to control the 3D

Controls view of the model (Rotate,
Pan, Zoom, etc.).
2D View Options to control the 2D

Controls view of plots (Pan, Zoom,
etc.).
Note - Available in HyperGraph only.
Reports Options to Create/Open/

Define Report Templates.
Scripting Options to Create/Open/

Debug/Run Tcl and
HyperMath scripts.
Note - Not available in MotionView.
Image Capture Image/Video of

Capture the active page.
Note - Please refer to the Hyperworks Desktop Users Guide > Graphical User Interface >
Toolbars topic for a detailed explanation of each toolbar listed above.

Client Specific Toolbars
Client specific toolbars provide access to options required for pre- or post-processing of FEA/MBD
models. MotionView has a set of toolbars for building an MBD model. Each MotionView toolbar group
provides access to entities with similar characteristics. For example, all entity such as Joints and
Motions are grouped in the Constraint toolbar. The table below shows MotionView toolbars with a
brief explanation of their usage.
General Actions Options to render graphics,

provide access to the Run
panel (change solver settings
and submit jobs to the solver),
and the Entity Selector.
Depressing the Entity Selector
icon indicates the graphic

screen is in entity selection
mode. If no other entity icons
are depressed, the selection is
not filtered to a particular
entity (any entity that has a
graphical representation on the
screen can be selected).
Container Entity Select/Add container entities

like Assemblies, Systems, and
Analyses.
Reference Entity Select/Add entities like Points,

Bodies, Vectors, Markers, etc.
Constraint Select/Add constraint entities

like Joints, Motions, Couplers,
etc.
Force Entity Select/Add force entities like

multi-axial Forces, Spring
Dampers, Bushings, Beams,
Contacts, etc.
Control Entity Select/Add entities like Solver

Variables, Solver Arrays, SISO
Controller, Differentials, and
Sensors which are useful in
defining controlled simulations.

General MDL Entity Select/Add general MDL

entities like Datasets,
Templates, Forms and Output
Requests.
Model Check Checks the model.
Point Macros Access point creation macros

useful in adding points with
respect to a reference frame,
along a vector, along a curve
and at an arc center.
Other Macros Other macros useful in modeling

and debugging: calculate
angles, find connected entities,
create markers for a
deformable surface and
contact properties editor.
A left click on an entity icon sets the filter to select that particular entity from the graphic screen,
while a right-click on a toolbar icon enables adding that entity to the model (see the Points
example below):
Left mouse click - Filters selection to a Point entity.

Right mouse click - Opens the Add Point dialog to add a Point.
Note - Mouse over the icons to display a tip about the type of entity that can be selected or
added.

Browsers
Tab Area
The tab area docks different browsers, the purpose of the browsers is to navigate through the
hierarchy tree and execute some operations specific to the selected items. Available for all clients
is the Session Browser, which allows you to browse to the different pages or windows in an HWD
session, as well as execute certain page and window operations. In addition to the Session
Browser, client specific browsers are shown based on the active window. For example, when the
MotionView is active client in the working window, the MotionView Project Browser is shown;
similarly, when HyperView is active, the Results Browser is shown. Specifically, the MotionView
Project Browser helps you browse/select different modeling entities, in addition to executing
certain modeling operations. Other browsers include the Organize Browser (used for data
management and collaboration) and the Process Manager (used for process automation). Please
refer to the client specific online help regarding the available browsers. Finally, browsers can be
placed on either side of the graphic window (Left/Right/Both) through the Menu bar by using the
View > Tab Area menu options.
Mouse Options in the Project Browser
A left mouse click on an entity in the Project Browser selects that entity and the details of entity
are displayed in the Panel area (see the example below):
A right click on an object brings up a context menu with options that are relevant to the selected
object.

For example, a right click on a Point entity brings up a context menu that provides options to
either Deactivate, Rename, Add, Delete, or Cut the point entity along with options to filter
entities.
Similarly, a right mouse click on the Model (the topmost folder in the browser hierarchy) displays
up a context menu with options useful in model building.

Panel Area
Below the client specific toolbar is the panel area where you can view and modify the various
values and properties of a selected entity. Panels may have several tabs which organize the
various properties and values of the entity type selected. For example, the Spring Damper panel
has the connectivity information and properties displayed in three tabs (as shown below):
Connectivity tab: Allows you to specify the type of spring, the bodies to attach, and the
attachment points.
Properties tab: Allows you to set the stiffness and damping properties of a spring.
Preload tab: Allows you to set a 'preload' on a spring by specifying a force value or spring free
length.

Graphics Window
Graphics window is the model visualization area where you can interactively work on the model.
The following table illustrates the various mouse clicks available for model visualization:
Operation Action
Left click on an entity like a Point, Selection (the selected entity is highlighted by
Graphic, etc. (while the Entity Selector a white boarder around it).
and an entity icon is depressed in the
toolbar).
Hold the left mouse button and move Displays the entity name on the mouse tooltip
over the model (while the Entity and selects the entity upon releasing mouse
Selector and an entity icon is depressed button.
in the toolbar).
Right-click on a model entity. Displays a context menu with various options:

Select, Cut, and Delete against each entity
name.
Ctrl + Left mouse button Rotates the model (observe the mouse
tooltip).
Ctrl + Left click Picks the center of rotation.
Ctrl + Right mouse button Translates/Pans the model.
Ctrl + Middle mouse button Selects the window to fit.
Ctrl + Middle click Fits the model to the window.

The controls for the mouse can be found under Tools > Options > Mouse:
You can customize the mouse controls using this dialog.
Note - The items under the Main Menu, Browser, and Client specific toolbars differ from client to
client.
Exercise:
In this exercise you will learn to:
Open and Save a model in MotionView.

Add a Page and change the Page Layout in a Session.
Change between HWD clients.
Open and Save a HWD session.
Prior to beginning this tutorial, please copy all of the files located in the mv_hv_hg\mbd_modeling
folder to your <working directory>. See Access the Model Files for additional information.

Step 1: Opening a MotionView model file.
1. Start MotionView:
In Windows - go through the Start Menu (Start Menu > Programs > Altair HyperWorks
installation > MotionView).
In Linux - invoke ~hw_install/altair/scripts/mview in an "open terminal" (where

In Mac - go through the Applications > Altair HyperWorks > installation version number >
MotionView
OR
invoke ~hw_install/altair/scripts/mview in an "open terminal" (where

2. Click the Open Model icon, , on the Standard toolbar.
OR
From the File menu select Open > Model.
3. From the Open Model dialog, locate and select the model definition file
SingleCylinderEngine_model.mdl, located in your working directory.

Note MDL stands for Model Definition Language. MDL is an ASCII programmable language for
modeling in MotionView. See the MotionView Reference Guide for details about the
different MDL statements.
4. Click Open.
The single cylinder engine model displays in the graphics window (fit to the window).
5. Upon successful loading of a model into MotionView, the status bar will display the Ready message
(in the lower left corner of the screen). The Project Browser lists all of the entities in the model.
Click on the Expand /Collapse button of each entity (Bodies, Points, Joints, Motions,
etc.) to browse through the entities. Use the mouse controls in the graphics area to rotate, pan,
and zoom the model.
6. Expand the Bodies folder in Project Browser by clicking on the next to Bodies (
).

7. Click on the CRANK_SHAFT body from the bodies listed to review its properties.
Note Each entity will have a label and a unique variable name. For example, the crank shaft
body has a label of CRANK_SHAFT and a variable name of b_CRANKSHAFT.
The corresponding entity panel (Bodies in this case) is displayed in the bottom of the window.
8. From the Properties tab, observe the Mass and Inertia properties of the body.

9. Click on CM Coordinates tab to review the CM point of the body and its orientation.
The Origin point defines the body CG location and the orientation is defined with respect to global
reference frame using direction cosines DxDyDz.
Step 2: Selecting and modifying a motion.

In this step you will modify the crank shaft rotational velocity to 10rad/sec.
1. Left click the Motion icon on the Constraint toolbar to change the graphical selection to a
motion entity. Move the cursor in the graphics area with left mouse button pressed to identify
the motion CrankShaft Rotation and release the mouse button to select it.
OR
Browse to the Motions entity in Project Browser and click on next to Motions and select
CrankShaft Rotation.
Note Implicit graphics are displayed for all applicable entities, allowing you to visualize their
location and orientation. See the MotionView Users Guide for details about controlling
the visualization of implicit graphics.

2. From the Motion panel, click on the Properties tab.
3. Enter 10 in the Value field.
Step 3: Saving a MotionView model.

1. From the File menu, select Save As > Model.
The Save As Model dialog is displayed.
Note You can also click the Save Model icon, , on the Standard toolbar to the save the
file in working directory with the existing name. If the model is new, you will be
prompted to input the name of the model.
2. Browse to your working directory and specify the File name: as

SingleCylinderEngine_model_10rad_per_sec.mdl.
3. Click Save.

Step 4: Solving the model.
1. Click the Run icon, , on the General Actions toolbar.
The Run panel is displayed.
2. Click the Run button to solve the model using MotionSolve.
Upon clicking Run, MotionSolve is invoked and solves the model. The HyperWorks Solver View
window appears which shows the progress of the solution along with messages from the solver
(Run log). This log is also written to a file with the extension .log to the solver file base name.
3. Once the job is completed, close the solver execution window.
4. Clear the message log.
Step 5: Adding pages to a session.

In this section you will learn how to add a page, change to different HWD clients, change the page
layout, and navigate between pages. You will also load the result files to view the animation and the
plot. Even though there are both Animate and Plot buttons in the MotionView Run panel, clicking
those buttons will result in the HyperView and HyperGraph clients opening automatically in different
windows on the same page, however in this exercise you will manually do the same on a different
page, in order to familiarize yourself with the concept of page and window within the HWD
environment.
1. Click on the Add Page icon from Page Controls toolbar.
A new page is added with MotionView as the client.
Note Please note that the Add Page option adds a page with the current client (MotionView
in this case).

2. From the Select application drop-down menu, select HyperView to change the current window
to HyperView.
3. From the Load Model panel, click on the Select file icon next to Load model.
The Load Model File dialog is displayed.

4. Browse to your working directory and select the animation results file
SingleCylinderEngine_model_10rad_per_sec.h3d.
The Load results field is automatically populated with

SingleCylinderEngine_model_10rad_per_sec.h3d.
Note H3D is an Altair binary file for HyperView. The H3D file contains both model and results
data from a solver run. Please see the Appendix (below) for various use cases of H3D
files in MotionView/MotionSolve.

5. Click Apply to load the results.
6. From the Animation toolbar, click the Start/Pause Animation button to animate the
results.
7. Rotate, pan, and zoom the model using the mouse controls for better visualization and
understanding of the results.
8. Click the Start/Pause Animation button to stop the animation.
9. Add a window to the current page to plot the results.
10. From the Page Controls toolbar, click the arrow next to the Page Window Layout button
and select the two window layout from the pop-up menu.
11. Click in the graphics area of second window in order to make it the active window.

12. Use the Select application drop-down menu to change the application from HyperView to
HyperGraph 2D .
Note The Client selector displays the icon of the current client (HyperGraph in this case).
13. Click the Build Plots icon, , on the Curves toolbar.
14. From the Build Plots panel, click the Open File icon, , next to Data file.
The Open Data File dialog displays.
15. Browse to your working directory and select the MotionSolve results file
SingleCylinderEngine_model_10rad_per_sec.abf.
Note ABF is the Altair Binary File for HyperGraph. Other output files from MotionSolve (.mrf
and .plt) can also be used for reading results into HyperGraph.
16. Click Open.

17. Plot the angular velocities of the crank shaft:
For X Type, select Time.
For Y Type, select Marker Velocity.
For Y Request, select REQ/70000002.
For Y Component, select Wx.
18. Click Apply and observe Wx = 10 rad/sec.
Two Window Layout (with HyperView and HyperGraph 2D)

results.
20. Click on Expand/Reduce Window icon, to expand or reduce an active window.
21. Observe the top right corner of the page which displays the current page (2 of 2). Click on
Previous Page icon, or Next page icon, to navigate to page 1 (the MotionView model).
MotionView with Single C ylinder Engine Model

Step 6: Saving a session file.
1. From the File menu, select Save As > Session.
The Save Session As dialog is displayed.
2. Browse to your working directory and specify the File name as mywork.mvw.
Note A session file saves the complete HWD data (the page, window, client, and results
information). Please refer to the Appendix below for details regarding the different types
of HyperWorks Desktop files.
3. Click Save.
Your work is saved as a session file.

Step 7: Opening a session file.
1. From the File menu, select New > Session to start a new session.
Click Yes to the message asking if you would like to discard all of the current session data and
start new session.
2. From the File menu, select Open > Session.
The Open Session File dialog is displayed.
3. Browse to your working directory and select the session file saved in previous step mywork.mvw.

4. Click Open.
5. Browse through the pages to look at the model, plots, and animation that you worked on during
the exercise using the icons
Appendix
HyperWorks Desktop file types:
The following table summarizes the different file types in HWD and the location where the file can
be loaded and saved.
File Type Extension Window Mode
Session script .mvw Any
Report template .tpl Any
MDL .mdl MotionView
Animation .gra, .res (Adams and Optistruct), HyperView

h3d, .flx, .mrf
Plot .req, .mrf, .abf, .plt, .res (ADAMS) HyperGraph
Templex script, .tpl, .txt TextView

any text file
Options for loading and saving different file types
H3D file use cases in MotionView/MotionSolve:
H3D is an Altair format for storing model and result information. In general, an H3D file is used for
post-processing results in HyperView; however the H3D file has a few other use cases in
MotionView/MotionSolve.
Graphic H3D File This type of H3D contains Model information only. A graphical H3D file
is an imported geometry into MotionView for visualization of a body.
Flexbody H3D File This type of H3D contains Model and Flexible body information.
Therefore, MotionView can use it as a graphic, as well as to represent
a deformable body by accessing the modes, mass, and inertia
information. HyperView can read it as both Model and Results, and
also animate the mode shapes, modal displacements, stresses, etc. (if
available).
Results H3D File This type of H3D is written by MotionSolve. It contains Model and
Results information. HyperView can read it as both Model and Results,
and also animate the position, deformation, stresses, forces, etc.

H3D contains different blocks of information based on the above needs:
Model Information Nodes and Elements
Flexible Body Information Modes, Interface Nodes, Mass/Inertia

Results Position, Displacements, Stress, Strain, etc.

Interactive
MV-1011: Extension and Retraction Analysis of the Main Landing Gear of an Aircraft

Multi Body Dynamics (MBD) Overview

MBD Definition
Multi Body Dynamics (MBD) is defined as the study of dynamics of a system of interconnected
bodies. A mechanism (MBD system) constitutes a set of links (bodies) connected (constrained) with
each other to perform a specified action under application of force or motion. The motion of
mechanisms is defined by its kinematic behavior. The dynamic behavior of a mechanism results from
the equilibrium of applied forces and the rate of the change of momentum.
MBD Modeling
A classical MBD formulation uses a rigid body modeling approach to model a mechanism. A rigid body is
defined as a body in which deformation is negligible.
In general, in order to solve an MBD problem, the solver requires following information:
Rigid body inertia and location

Connections type, bodies involved, location, and orientation
Forces and motions bodies involved, location, orientation, and value
MotionView facilitates quick and easy ways of modeling items, such as a system, through graphical
visualization.
In this tutorial, you will learn how to:

Create a model of a four-bar trunk lid mechanism interactively through the MotionView
graphical user interface.
Perform a kinematic analysis on the model using MotionSolve.
Post-process the MotionSolve results in the animation and plot windows.
C ar Trunk-Lid Mechanism
The trunk-lid shown in the image above uses a four-bar mechanism for its opening and closing
motions.

A schematic diagram of the four-bar mechanism is shown below:
The four links (bodies) in four-bar mechanism are namely; Ground Body, Follower, Coupler, and Input
Link. In this example, the Ground Body is the car body and Input Link is the trunk-lid body. The
remaining two bodies (Follower and Coupler) form the part of the mechanism used to aid the opening
and closing of car trunk-lid.
The following entities are needed to build this model:
Points
Bodies
Constraints (Joints)
Graphics
Input (Motion or Force)
Output
Copy trunk.hm and trunklid.hm, located in the mbd_modeling\interactive folder, to the <working
directory>.

Exercise
Step 1: Creating points.

1. Start a new MotionView Session.
2. Add a point using one of the following methods:
From the Project Browser, right-click on Model and select Add > Reference Entity > Point
from the context menu.
OR
Right-click on the Points icon, , on the Reference Entity toolbar.
The Add Point or PointPair dialog is displayed.
Note Other entities like Bodies, Markers, etc. can also be created using either of the methods
listed above (Project Browser or toolbar).
3. For Label, enter Point A.

4. For Variable, enter p_a.
The label allows you to identify an entity in the graphical user interface, while the variable name
is used by MotionView to uniquely identify an entity.
Note When using the Add "Entity" dialog for any entity, you can use the label and variable
defaults. However as a best modeling practice, it is recommended that you provide
meaningful labels and variables for easy identification of the entities. For this exercise,
please follow the prescribed naming conventions.
5. Click OK.
The Points panel is displayed. Point A is highlighted in the Points list of the Project Browser.
Points Panel - Properties Tab

6. Enter the values for the X, Y, and Z coordinates for point A, listed in the table below.
The table below lists the coordinates of the points needed for this model:
Point Location
Label Variable X Y Z
Point A p_a 921 580 1124
Point B p_b 918 580 1114
Point C p_c 915 580 1104
Point D p_d 896 580 1106
Point E p_e 878 580 1108
Point F p_f 878 580 1118
Point G p_g 830 580 1080
Point H p_h 790 580 1088
Point I p_i 825 580 1109

7. Other (multiple) points can be entered using the following method:
Repeat steps 2 through 4 and click Apply to create points B through I. Remember to substitute
B, C, etc., for A when entering the label and variable names in the Add Point or PointPair
dialog. Clicking the Apply button allows you to continue to add points without exiting the Add
"Entity" dialog.
After keying in the label and variable name for Point I, click OK to close the dialog.
The points panel for Point I is displayed.
Click the Data Summary... button located in the upper right corner of the Points panel.
The Data Summary dialog shows the table of points and you can enter all the coordinates in
this table.
Data Summary Dialog

Since the Y value of all the points are the same, you can parameterize the value for the points
Point B to Point I to the Y value of Point A as follows:
Select the Y coordinate field along Point B.
Click on the button to invoke the Expression Builder.
Select the Y value of Point A as shown in figure below:
Expression Builder

Copy the above expression and paste it into the Y coordinate field of other remaining points.
Enter the X and Z coordinates as listed in the table above.
Note Press ENTER on the keyboard to move to the next field.
Click Close.
8. Change the view to left, by clicking on the XZ Left Plane View icon on the Standard Views
toolbar.
Step 2: Creating bodies.

The mechanism consists of four rigid-body links: Ground (car body), Input Link, Coupler, and Follower.
Ground Body is available by default when a new MotionView client is invoked, hence creating the
Ground Body separately is not required. In this step, you'll create the Input Link, Coupler, and
Follower rigid-body links in the mechanism.
1. Right-click on the Bodies icon, , on the Reference Entity toolbar.
The Add Body or BodyPair dialog is displayed.

2. Specify the label as Input Link and the variable name b_inputlink.
3. Click OK.
The Bodies panel is displayed. The new body that you just added is highlighted in the model tree
of the Project Browser.
4. Click the Properties tab.
5. Enter the following values for mass and inertia:
Mass = 1
Ixx, Iyy, Izz = 1000, Ixy, Ixz, Iyz = 0
Click the CM Coordinates tab to specify the location of the center of mass of the body.

6. Select the Use center of mass coordinate system check box.
7. Under the Origin, click the Point collector .
A cyan border appears around the collector indicating that the collector is now active for
selection.
8. From the graphics area, select Point G on the model by using the left click of the mouse. While
selecting, keep the left mouse button pressed and move the cursor over the points to see the
label. Release the mouse button when Point G is located.
OR
Click again to launch the Select a Point dialog.
Select Point G from the model tree.

Click OK.
Point G is selected as the origin of the center of mass marker for the input link.
Note - The above-mentioned methods for selecting a point can also be applied to other
entities such as: body, joint, etc. For selecting the Ground Body or the Global Origin,
you can click on the triad representing the Global Coordinate System on the screen
Retain the default orientation scheme (Orient two axes) and accept the default values for
.

9. Repeat steps 1 through 8 to create the two remaining links with the following label and variable
names:
Label Variable Name
Follower b_follower
Coupler b_coupler
10. Specify the mass and inertia for these links as:
Mass = 1
Ixx, Iyy, Izz = 1000, Ixy, Ixz, Iyz = 0
11. Specify points B and D as the origin of the center of mass marker for Follower and Coupler,
respectively.
12. Retain the default orientation (Global coordinate system) for the CM marker.
Step 3: Creating revolute joints.

The mechanism consists of revolute joints at four points: A, C, E, and F. The axis of revolution is
parallel to the global Y axis.
1. From the Project Browser, right-click on Model and select Add > Constraint > Joint from the
context menu.
OR
Click the Joints icon, , on the Constraint toolbar.
The Add Joint or JointPair dialog is displayed.
2. Specify the label as Follower-Ground and variable name as j_follower_ground for the new
joint.

3. Under Type, select Revolute Joint from the drop-down menu.
4. Click OK.
The Joints panel is displayed. The new joint you added is highlighted in the model tree in the
Project Browser.
5. Under the Connectivity tab, double click the first Body collector .
The Select a Body dialog is displayed.

6. From the model tree, select Bodies from the left-hand column and Follower from the right-hand
column.
7. Click OK.
Notice that in the Joints panel the Follower Body is selected for and the cyan border
moves to .
8. Click in the graphics window. With the left mouse button pressed move the cursor to the global
XYZ triad .

9. Release the left mouse button when Ground Body is displayed in the graphics window.
10. Under Origin, double click the Point collector .
The Select a Point dialog is displayed.
11. Select Point A as the joint origin.
12. Click OK.
13. To specify an axis of rotation, under Alignment Axis, click the downward pointing arrow next to
Point and select Vector.
14. Specify the Global Y axis vector as the axis of rotation of the revolute joint.
15. Repeat steps 1 through 14 to create the three remaining revolute joints: points C, E, and F.
Revolute Joint Label Variable Name Body 1 Body 2 Point Vector
Follower-Ground j_follower_ground Follower Ground A Global Y
Follower-Coupler j_follower_coupler Follower Coupler C Global Y
Coupler-Input j_coupler_input Coupler Input Link E Global Y
Input-Ground j_input_ground Input Link Ground F Global Y

Revolute joint information

Step 4: Specify a motion for the mechanism.
The input for this model will be in the form of a Motion. A Motion can be specified as Linear,
Expression, Spline3D, or Curve. In this step, a Motion is specified using an expression.
1. From the Project Browser, right-click on Model and select Add > Constraint > Motion from the
context menu.
OR
Right-click on the Motion icon, , on the Constraint toolbar.
The Add Motion or MotionPair dialog appears.
2. Specify the label as Motion_Expression and the variable name as mot_expr for the new motion.
3. Click OK.
The Motion panel is displayed. The new motion is highlighted in the model tree in the Project
Browser.
4. From the Connectivity tab, double click on the Joint collector .
The Select a Joint dialog is displayed.
5. From the model tree, select the revolute joint at Point F (Input-Ground) that you created in the
previous step.

6. Click OK.
The Motion panel is displayed.
7. From the Properties tab, select Expression by clicking on the downward arrow next to Linear.
8. Click in the Expression field.
The Expression Builder is activated.
9. Click on the button to open the Expression Builder and enter following expression between
the back quotes `60d*sin(2*0.1*PI*TIME)`.

The above expression is a SIN function with an amplitude of 60 degrees and frequency of 0.1 Hz.
With the above expression the trunk lid is opened to an angle of 60 degrees and back in a total
time period of 5 seconds.
10. Click OK.
Note This method of creating an expression can also be used for specifying non-linear
properties for other entities like Force, Spring Damper, Bushing, etc.
Step 5: Creating outputs.

You can create outputs using bodies, points and markers. You can also directly request force,
bushing, and spring-damper entity outputs. Another way to create outputs is to create math
expressions dependent on any of the above mentioned entities.
In this step, you will:
Add a displacement output between two bodies using the default entities.
Add another output to record the displacement of a particular point G on the input link relative
to the global frame based on Expressions.
1. From the Project Browser, right-click on Model and select Add > General MDL Entity >
Output from the context menu.
OR
Right-click on the Outputs icon, , on the General MDL Entity toolbar.
The Add Output dialog is displayed.
2. Specify the label as Input Link Displacement and the variable name as o_disp for the new
output.

3. Click OK.
4. To create a Displacement output between two points on two bodies:
For Body 1 and Body 2, select Input Link and Ground Body, respectively.
For Pt on Body 1 and Pt on Body 2, select point I and the Global Origin point, respectively.
Record the displacement on Both points, one relative to the other.
5. Add one more output with the label as Input Link CM Displacement and the variable name as
o_cm_disp to calculate the X displacement between the CM markers Input Link and the global
origin:
From the drop-down menu, select Expressions.
Click in the F2 field. This activates the button.
Click on the button.

The Expression Builder dialog is displayed.
From the Motion tab, select DX.
Place the cursor inside the brackets after DX.
From the Properties tab, expand the following trees: Bodies/Input Link/Marker CM.
Select idstring.

Click Add to populate the expression.
Add a comma to separate the next expression.
Add a pair of curly brackets "{}".
Place the cursor inside the added brackets.
From the Properties tab, expand the following items in the tree: Markers/Global Frame.
Select idstring.

Click Add to populate the expression.
6. Click OK.
7. To check for errors, go to the Tools menu and select Check Model. Any errors in your model
topology are listed in the Message Log.
The above function DX measures the distance between Input Links CM (center of mass) marker
and marker representing the Global Frame in the X direction of the Global Frame. Refer to the
MotionSolve Reference Guide for more details regarding the syntax and usage of this function.

Note The back quotes in the expression are used so that the MDL math parser evaluates the
expression. Entity properties like idstring, value, etc. get evaluated when they are
placed inside curly braces {}, otherwise they are understood as plain text. Refer to the
Evaluating Expressions in MotionView topic to learn more about various kinds of
expressions and form of evaluation adopted by MotionView.
Step 6: Add graphic primitives.

At this stage your trunk lid model does not contain any graphics, and the entities created in previous
steps are represented only by implicit graphics (which are not available in solver deck or results file).
Trunk-lid with only implicit graphics
In this step you will add graphics for visualization of a mechanism. MotionView graphics can be
broadly categorized into three types: implicit, explicit, and external graphics.
Implicit Graphics The small icons that you see in the MotionView interface when you
create entities like points, bodies, joints, etc. are called implicit
graphics. These are provided only for guidance during the model
building process and are not visible when animating simulations.
Explicit Graphics These graphics are represented in form of a tessellation, are written to
the solver deck and subsequently available in the results. Explicit
graphics are of two types.
Primitive Graphics These graphics help in better visualization of the model and are also
visible in the animation. The various types of Primitive Graphics in
MotionView are Cylinder, Box, Sphere, etc.
External Graphics One can import in various CAD formats or Hypermesh files into
MotionView. The Import CAD or FE.. utility in MotionView can be
used to convert a CAD model or a Hypermesh model to h3d graphic
format which can be imported into MotionView. One can also import .g,
ADAMS View .shl and wavefront .obj files directly into MotionView.

MotionView allows you to turn on and off implicit graphics for some of the commonly used modeling
entities.
1. To turn on all implicit graphics:
From the Model main menu, select Implicit Graphics...
Turn on the Visible check box.
Note - Implicit graphics of Individual entities can be turned on or off by using the Visible
check box for each entity.
Click Close.
The state of the implicit graphics (whether on or off) is not saved in your model (.mdl) or
session (.mvw) files. MotionView uses its default settings when:
You create a new model in another model window.
You start a new session.
You load an existing .mdl/.mvw file into a new MotionView session.

To visualize the four-bar mechanism, you need to add explicit graphics to the model. In this
step, you will add cylinder graphics for Follower, Coupler, and Input Links.

To add explicit graphics to your model:
From the Project Browser, right click on Model and select Add > Reference Entity >
Graphic from the context menu.
OR
Right-click on the Graphics panel icon, , on the Reference Entity toolbar.
The Add Cylinder or CylinderPair dialog is displayed.
2. In the Add Cylinder or CylinderPair dialog, enter the label as Follower Cylinder and the
variable name as gcyl_follower.
Note The name of the dialog changes with the graphic type. For example, the dialog name
changes to Add Box or BoxPair when the Box graphic type is selected.
3. From the Type drop-down menu, select Cylinder. Click OK.
4. In the Connectivity tab, double-click the Body button below Parent. Select the
Follower from the Select a Body list and click OK.
This assigns the graphics to the parent body.
5. To select the origin point of the cylinder, click below Origin.
6. Pick Point A in the graphics area.
7. Click under Direction.

8. Select Point C for .
9. From the Properties tab, enter 2 in the Radius 1: field.
Note The cylinder graphic can also be used to create a conical graphic. By default, the Radius
2 field is parameterized with respect to Radius 1, such that Radius 2 takes the same
value of Radius 1. Specify different radii to create a conical graphic.
10. For the remaining bodies in your model, follow steps 2 through 9 to create the appropriate explicit
graphics for other links.
Label Variable name Graphic type Body Origin Direction Radius
Follower gcyl_follower Cylinder Follower Point A Point C 2

Cylinder
Coupler gcyl_coupler Cylinder Coupler Point C Point E 2

Cylinder
Input Link gcyl_inputlink_1 Cylinder Input Link Point F Point E 2

Cylinder 1
Input Link gcyl_inputlink_2 Cylinder Input Link Point E Point G 2

Cylinder 2
Input Link gcyl_inputlink_3 Cylinder Input Link Point G Point H 2

Cylinder 3
Input Link gcyl_inputlink_4 Cylinder Input Link Point H Point I 2

Cylinder 4

After the addition of cylinder graphics for all three links, the Model will look as shown below:
Four-bar mechanism of the trunk-lid assembly
Step 7: Add external graphics and convert a HyperMesh file to an H3D file.
MotionView has a conversion utility that allows you to generate detailed graphics for an MDL model
using HyperMesh, Catia, IGES, STL, VDAFS, ProE, or Unigraphics source files. MotionView uses
HyperMesh to perform the conversion.
In this step, you will use this conversion utility to convert a HyperMesh file of a car trunk lid into the
H3D format.
1. From the Tools menu, select Import CAD or FE .
Or
Click on the Import Geometry icon on the Standard toolbar.
The Import CAD or FE dialog is displayed.
2. Activate the Import CAD or Finite Element Model Only radio button.
3. From the Input File option drop-down menu, select HyperMesh.
4. Click the browser button next to Input File and select trunklid.hm, located in <working
directory>, as your input file.
The Output Graphic File field is automatically populated with the trunklid.h3d file from the
<working directory>.

5. Click OK to begin the import process.
The Import CAD or FE utility runs HyperMesh in the background to translate the HyperMesh file
into an H3D file.
Note The H3D file format is a neutral format in HyperWorks. It finds wide usage such as
graphics and result files. The graphic information is generally stored in a tessellated
form.
6. When the import is complete the Message Log appears with the message "Translating/
Importing the file suceeded!". Clear the Message Log.
7. Use steps 1 through 6 to import the trunk graphics by converting the trunk.hm file to trunk.h3d.

Step 8: Attach H3D objects to the input link and ground bodies.
In this step, you will attach the trunk lid H3D object to the input link and the trunk H3D object to
Ground.
1. Click the Graphics icon on the Reference Entity toolbar.
2. Select g_trunklid - from the graphics area.
3. In the Connectivity tab, double click the Body collector under Parent. Select Input
Link from the Select a Body list.

4. Click OK.
The Graphics panel is displayed.
Note Observe the change in the trunk lid graphic color to the Input Link body color.
5. Similarly, select the newly created g_trunk graphic from the Project Browser and set the
as Ground Body.
6. Click the Save Model icon on the Standard toolbar.
If the model is new you will be prompted to input the name of the model, otherwise the model will
be saved in the working directory with the existing name.
Note Existing models can be saved to another file using the Save As > Model option located
in the File menu.
7. From the Save As Model dialog, browse to your working directory and specify the File name: as
trunklid_mechanism.mdl.

8. Click Save.
Trunk-lid mechanism
Step 9: Solve the model with MotionSolve.

MotionSolve can be used to perform kinematic, static, quasi-static, and dynamic analyses of multi-
body mechanical systems. The input file for MotionSolve is an XML file called MotionSolve XML. The
solution in MotionSolve can be executed from MotionView.
In this step, you will use MotionSolve to perform a kinematic simulation of the mechanism for a
simulation time of 5 seconds, with a step size of 0.01 second.
2. Click on the Check Model button on the Model Check toolbar to check the model for errors.
3. From the Main tab of the Run panel, specify Transient as the Simulation type.
4. In the field located to the right of the Save and run current model option, specify the name for
the XML file as trunklid_mechanism_run.
MotionView uses the base name of your XML file for other result files generated by MotionSolve.
See the MotionView Users Guide for details about the different result file types.

5. Activate the Export MDL snapshot check box (in order to save the model at the stage in which
the Run is executed).
6. Specify an End time of 5 for your simulation and a Print interval of 0.01 (the time unit is
second by default).
Note - You can access the Units form from the Forms panel, .
7. Click the Run button located on the right side of the panel to solve the model using MotionSolve.
8. Check the Message Log for more information.
Upon clicking Run, MotionSolve is invoked and solves the model. The HyperWorks Solver View
window appears which shows the progress of the solution along with messages from the solver
(Run log). This log is also written to a file with the extension .log to the solver file base name.
9. Review the window for solution information and be sure to watch for any warnings/errors.
Step 10: View animation and plot results on the same page.
Once the run is successfully complete, both the Animate and Plot buttons are active.
1. Click the Animate button.
This opens HyperView in another window and loads the animation in that window.
2. To start the animation, click the Start/Stop Animation icon, , on the toolbar.
3. To stop/pause the animation, click the Start/Stop Animation icon again, , on the toolbar.
4. Return to the MotionView window.
5. Click the Plot button.
This opens HyperGraph and loads the results file in a new window.
6. Leave the X-axis Data Type as Time.

7. Input the following y-axis data:
Y Type Marker Displacement
Y Request Displacement (on Input Link)
Y Component DM (Magnitude)
8. Click Apply.
This plots the magnitude of the displacement of Point I relative to the Global Origin.
Your session should look like the figure below:
Session with model, plot, and animation
Step 11: Save your work as a session file.

1. From the File menu, select Save As > Session File.
2. Specify the file name as trunklid_mechanism for your session.
3. Click Save.
Your work is saved as trunklid_mechanism.mvw session file.
Appendix
Evaluating Expressions in MotionView
Expressions in MotionView are evaluated by two kinds of parsers:

Math Parser
A MotionView parser that evaluates a MotionView expression as real/integer/string for a field as

appropriate.
Real
This type of field can contain a real number or the parametric expression that should evaluate to
a real number. This type of field is found in Points, Bodies , Force Linear. Note that only the
value of the expression as evaluated goes into the solver deck and not the parametric equation.
Example: p_a.x, b_0.mass
String
This type of field can contain a string or a parametric expression that should evaluate to a
string. This type of field is found in entity such as DataSets with strings as Datamember,
SolverString etc. As in case of Linear field, only the value of the expression as evaluated goes
into the solver deck and not the parametric expression.
Example: b_inputlink.label
Integer
This type of field can contain an integer or a parametric expression that evaluates to an integer.
This type of field is found such as DataSets with an integer as Datamember. Even in this case,
only the value of the expression as evaluated goes into the solver deck and not the parametric
equation.
Templex Parser
A math program available in HyperWorks that can perform more complex programming than the
math parser, other than evaluating a MotionView expression.
The following type of fields in MotionView are evaluated by the templex parser that evaluates a
parameterized expression:
Expressions
This type of field is different than the three listed above because it can contain a combination
of text and parametric expression. It is generally used to define a solver function (or a function
that is recognized by the solver). This type of expression is embedded within back quotes ( `
` ) and any parametric reference is provided within curly braces {}. The presence of back
quotes suggests the math parser to pass the expression through Templex. Templex evaluates
any expression within curly braces while retaining the other text as is.
For example in the expression ` DX({b_inputlink.cm.idstring},

{Global_Frame.idstring})` , the templex evaluates the ID (as a string) of the cm of the
Input link body (b_ inputlink) and that of marker Global Frame while retaining DX as is.
These fields are available in entity panels such as: Bushings, Motions, Forces with properties
that toggle to Expression, Independent variable for a curve input in these entities, and Outputs
of the type Expression.

This tutorial introduces you to an important modeling approach: Building an MBD model from CAD data.
In this tutorial, you will learn to:
Import a CAD assembly into MotionView.

Import a CSV file to create Points
Create an MBD model using the imported data.
Import CAD or FE Utility Introduction

The Import CAD or FE utility in MotionView allows you to import CAD or FE assemblies. CAD formats
include CATIA, Parasolid, Pro E, STEP, JT, SolidWorks and Unigraphics. FE formats include
HyperMesh, Optistruct, and Nastran. To access this utility, from the menu bar select Tools > Import
CAD or FE or File > Import > Geometry, . The Import CAD or FE dialog is displayed.
CAD or FE assemblies can be imported into MotionView as graphics only to be associated with existing
bodies, or as new bodies with calculated mass and inertia properties along with graphics.
The multi-body aspects of any CAD assembly that can be imported in MotionView are:
Component Mass
Component Moments of Inertia
Component Center of Gravity Location
Component Graphics
The CAD import utility calls HyperMesh in the background to write out graphic file (*.h3d) which holds
the geometry information in a tessellated form. While importing CAD or FE to create new bodies with
mass and inertia, the utility uses HyperMesh to calculate mass, inertia and CG location.
Exercise
In the following exercise, we will import a CAD assembly into MotionView, simplify the model from a
multi-body analysis point of view, and define constraints, model inputs and model outputs.
Please copy all of the files from the mbd_modeling\automation\CAD folder into your <working
directory>.
Step 1: Loading the CAD file into MotionView.

In this step, we will focus on understanding the process of import and model simplification.
1. Launch a New session, , of MotionView.

2. From the menu bar, select File > Import > Geometry,
Or
Click on the Import Geometry icon, , on the Standard toolbar.
3. Under Import Options, select Import CAD or Finite Element Model With Mass and Inertias.
4. From the Input File pull-down menu, select STEP.
5. Click the icon to select the STEP file.
6. Select the file Front_Assembly.step from your <working directory>.
7. Click Open.
The Output Graphic File field is automatically filled with Front_Assembly_graphic.h3d as the
H3D filename.

8. Click the plus button, , next to MDL Options and review the various options.
Note The MDL Options allow for flexibility while importing. The CAD file can be imported either
in an existing System/Assembly or a new System can be created
For this exercise, accept the defaults.
9. Review options under Meshing Options for Surface Data
Note This section helps control the size of mesh (or tessellation). When the MBD model being
created is used to solve non-contact problems, use the default option under Allow
Hypermesh to specify mesh options. The Launch Hypermesh to create MDL
points option allows you to select nodes in HyperMesh which can be imported into
MotionView as MDL points. This is not needed for this tutorial since you will be creating
these additional points using a Macro. For models that involves contacts, it is
recommended to use Control mesh coarseness for contacts The Interactive mesh
(launches HyperMesh) option can be used to mesh the surfaces manually. This is
particularly useful when a finer mesh may be needed, such as in case of contact
problems, to obtain better results.

10. Click the plus button, , next to Locator Points (Must be in source reference frame) and
review the options.
Note The Locator Points options can be used in cases where the CAD model being imported is
not in the same coordinate system as the MBD model in MotionView. This option gives
you control to specify three nodes or coordinates on the source graphic which can then
be used to orient using three points in MotionView after it's imported. This option is not
needed for tutorial as the imported graphic is in the required position. Select None from
the options
11. Click OK.
The Import CAD dialog is displayed.
Note This dialog helps to generate mass and inertia information. The table displays different
bodies or components being imported along with the volume and mass information based
on a default density of 7.83e-6. The density value can be modified for each of the
components. Alternatively, a CAD summary file can be used to extract mass/inertia
12. Set Input file length to Millimeter.

13. Under Component, select Wheel_body1. In the Apply density to selected components
field, change the value of the density to 8.5e-7 and click Apply.
Import C AD dialog
14. Leave the default value of the density for the other components. Click OK.
15. If the import into MotionView is successful, the message "Translating/Importing the file
succeeded!" is displayed in the Message Log.
16. Clear Message log.
The body, along with the associated graphics, is displayed in the graphics area.
Note The Extract mass/inertia data from CAD summary file: option can be used only for
CATIA summary file. Currently, summary files from other CAD packages are not
supported under this option.

Step 2: Consolidate and rename the suspension assembly bodies.
1. There are three bodies with their names prefixed with Strut_rod. These bodies in reality are
joined together and hence can be represented as one body. Having these bodies separate
increases the complexity of the model, and we are not interested in their interactions with each
other. We will merge these three bodies into one.
2. In the Project Browser, select these bodies: Strut_rod_1_body1, Strut_rod_body1 and

Strut_rod_body2. Right-click to bring up the context menu.
3. Select the Merge Bodies option. This option is used to merge two or more bodies into a single
body.
4. From the Merge Bodies dialog, enter Strut_rod as the label and b_Strut_rod as variable name.
Click OK.

5. The three selected bodies are deleted and replaced by a new body with the label and variable
names as entered in step 4. The mass and inertia values of this body are equivalent to the
effective mass and inertia of the bodies being replaced.
6. Repeat steps 2 to 4 for merging the bodies: Strut_tube_1_body1 and Strut_tube_body1. Enter
the label as Strut_tube and variable name as b_Strut_tube for the new body to be created..
7. From the Project Browser, select Wheel_body1 (Wheel part) .
8. Press F2 or right-click on Wheel_body1 and select Rename.
9. Change the label of the selected body to Wheel.
10. Similarly, rename the following parts:
S. No Original Label New Label
1 Wheel_Hub_body1 Wheel_Hub
2 Lower_Control_Arm_body1 Lower_Control_Arm
3 Axle_Shaft_body1 Axle_Shaft

11. Save the model as front_susp.mdl.
Notes on the Merge Bodies option:
o Mass and inertia of the newly created body upon Merge will be equal to the effective mass
and inertias of the bodies being merged.
o A new CG point is created at the effective CG location of the bodies being merged.
o Pair bodies cannot be merged.
o The Merge option works only within same container (System/Assembly/Analysis). Merging
bodies which belong to different container entities is not supported. The context menu item will
not appear in these cases.
o If the bodies that are being merged are referred to in expressions, post Merge these
expressions need to be corrected to point to the newly created body.
o Graphics that belong to bodies being merged are automatically resolved to the new body.
o Joints, bushings etc. that are associated with the bodies being merged if any, are
automatically resolved to the new body.

Step 3: Create points.
After creating the bodies, additional points are needed that will be used to specify joint locations and
joint orientations. These points can be created using the macros available in the Macros menu.
1. From the Macros menu, select Create Points > Using Coordinates or click the Create points
using Coordinates icon, .

2. Click to load a point table file.
3. Select the file suspension_points.csv from your working directory.

4. Click Open. All the point coordinates in the CSV file are imported into the utility.
5. Specify Varname prefix as p_susp.

6. Click OK.
The points are added to the model. These extra points will be used for defining joints,
orientations and other model inputs.
Note To use this macro import option, you have to create the *.csv file in the format shown
below:
1st Column - X coordinates.
2nd Column - Y coordinates.
3rd Column - Z coordinates.
7. Save the model, .
Step 4: Creating joints and spring damper.

In this step, we will add the joints to connect the bodies and a spring damper between Strut tube and
Strut rod.
1. From the Project Browser, right-click Model and select Add > Constraint > Joint (or right-click
the Joints icon, , from the toolbar).
2. Specify the Label and Variable as Wheel Spindle RJ and j_whl_spindle_revj, respectively.
3. For Type, select Revolute Joint.
4. Click OK.
5. For Body1 of the joint, specify Wheel.
For Body2, specify Wheel_Hub.
For Origin, specify Point7. (Point around the Wheel center).

For Axis, specify Point19. (Point around Axle Shaft center).
6. Add the rest of the joints of the model using the table below:
S.N Label Type Body 1 Body 2 Origin(s) Orientati Referenc Referenc

o on e1 e2
Method
1 Strut Hub Fixed Joint Wheel_Hub Strut_rod Point8

Fix
2 Strut Translation Strut_rod Strut_tube Point23 Axis(Pt) Point9

Trans Joint
3 Strut Universal Joint Strut_tube Ground Point9 Shaft(Pt) Point23 Global X

Tube Body
Ground UJ Shaft(Ve
ct)
4 Axle Hub Fixed Joint Axle_Shaft Wheel_Hub Point19

Fix
5 Hub Ball Joint Lower_Contr Wheel_Hub Point3

Control ol Arm
Arm Ball
6 Control Revolute Joint Lower_Contr Ground Point1 Axis(Pt) Point2

Arm ol Arm Body
Ground
Rev
7. From the Project Browser, right-click Model and select Add > Force Entity > Spring Dampers
(or right-click the Spring damper icon, , from the toolbar).
8. Specify the Label and Variable as Strut-SpringDamper and sd_strut, respectively.
9. Check Create explicit graphics check-box to create an explicit graphic for the spring damper
entity.
10. Click OK.
11. For Body1 and Body2, specify Strut_tube and Strut_rod, respectively.
12. For Point1 and Point2, specify Point9 and Point0, respectively.

13. Click the Properties tab and specify a stiffness (K linear) of 10 and damping (C linear) of
0.1.
14. Save the model.
Step 5: Add a Jack to the model.

1. Next, add a jack to this model and use the jack exercise the wheel through a vertical motion.
From the Project Browser, right-click Model and select
Add >Reference Entity > Body (or right-click the Bodies icon, , from the toolbar). Add a
body with Label and Variable as Jack and b_jack, respectively.
2. Click the body Properties tab and specify the Mass and the three principle inertia values of the
body as 0.01, 100, 100, and 100, respectively.
3. Click the CM Coordinates tab and select the Use CM Coordsys check box.
4. Pick Point10 (bottom of Wheel body)as the CM Origin point for the Jack body.
5. From the Project Browser, right-click Model and select Add > Reference Entity > Graphic (or
right-click the Graphic icon, , from the toolbar) to add a graphic. Specify the Label of the
graphic as Jack Plate and select the Type as Cylinder from the drop-down menu.
6. Accept the default variable.
7. From the Connectivity tab, select the Parent Body as Jack.
8. Pick Point10 as the Origin. For Direction, toggle to Vector and select Global Z.
9. Click the Properties tab. Specify a value of -30 in the field next to it.
10. Specify a value of 250 for Radius 1.
Notice that the Radius 2 field is updated with the same value as Radius 1.
11. From the Project Browser, right-click Model and select Add > Constraint > Joint (or right-click
the Joints icon, , from the toolbar). Specify the Label and Variable as Jack Wheel Inplane
and j_jack_wheel, respectively. For Type, select Inplane Joint from the drop-down menu.
12. Click OK.
13. From the Connectivity tab, select Wheel as Body1, select Jack as Body2, pick Point10 as
Origin and Vector Global Z as Normal.
14. Add another joint and specify the Label and Variable as Jack Ground Trans and j_jack_grnd,
respectively. For Type, select Translational Joint.
15. Click OK.
16. From the Connectivity tab, select Jack as Body1, Ground Body as Body2, pick Point10 as
Origin and Vector Global Z as the Alignment Axis.
17. All the joints required to complete the model are now in place.

18. Save the model.
Front suspension
Step 6: Specifying motion inputs and running the model in MotionSolve.

In this step, we will create a motion that is applied to the jack and solve the model.
1. From the Project Browser, right-click Model and select Add > Constraint > Motion (or right-
click the Motion icon, , from the toolbar) to add a motion. For Label, specify Jack Motion.
For Variable, specify mot_jack.
2. From the Connectivity tab, select Jack Ground Trans (the translation joint between Jack and
Ground Body) as the Joint.
3. From the Properties tab, change the property type to Expression from the pull-down menu.
Type in the expression `50*sin(TIME)` as the displacement Motion expression.
4. Add another motion to arrest the free spinning of the wheel. Add a motion and specify the label
and variable name as Wheel Spindle and mot_wheel, respectively.
5. From the Connectivity tab, select Wheel Spindle RJ as the Joint.
6. From the Properties tab, verify that the value of the Motion is 0.0.
This motion of 0.0 radians keeps the Wheel body from spinning freely about its axis.
7. Save the model.
8. Click Check Model toolbar. In the Message Log that is displayed, verify that there are no
warnings or errors. Clear the message log.

9. Go to the Run panel, .
10. Specify a name for the MotionSolve input XML file by clicking the Save and run current model
icon, .
11. From the Simulation type: drop-down menu, select Static+Transient.
12. Click Run.
13. Once the run is complete, click Animate to view the animation of the simulation.

MV-1011: Extension and Retraction Analysis of the
Main Landing Gear of an Aircraft
In this tutorial, you will learn how to create a sequential simulation script to simulate the extension
and retraction of the landing gear.
Sequential Simulation
Often, the total dynamic behavior of a multi-body model needs to be captured through more than one
solution sequence. Typical examples include:
1. The model configuration changes after a certain amount of time.
2. One type of analysis has to occur before the other. For example, a static solution is required
before a dynamic run.
3. Complex models may not solve with a single solver setting. The solver settings may need to be
changed for a certain period in the overall simulation time.
Such conditions may be simulated by providing a set of commands to the solver that achieves the
above type of sequences. Such simulations are referred to as sequential simulations. Generally,
the solver receives more than one solution (simulate) command. Youll learn to script such a
simulation sequence through this exercise.
Exercise
In this exercise, a landing gear mechanism is simulated for its extension and retraction. A sequence of
simulations need to be scripted such that the mechanism is retracted within a certain period of time at
which the simulation is halted, the model configuration is changed for retraction and the solution is
executed again for extension.

Main Landing gear of an aircraft
Note Copy the files MainLandingGear.mdl, Aircraft_Structure.hm and MainLandingGear.h3d,

located in the mbd_modeling\interactive\aero folder, to your <Working directory>.
Phase 1
In this phase, you will prepare the landing gear model to simulate the retraction of the landing gear.
Step 1: Opening the landing gear mechanism.

In this step, you will open a landing gear model and attach a graphic for the aircraft body.
1. From the Model-Main toolbar, click the Open Model icon, .
Or
Open model by selecting File > Open > Model.

2. From the Open model dialog, select the file MainLandingGear.mdl and click Open.
Once the model is loaded it will look as it does below. Review the model for its bodies and joints.
The model consists of linkages of the cylinder and piston that hold the wheel as well as linkages
for the extension and retraction of the whole landing gear unit within the aircraft body. The
model also contains a body defined for aircraft but without graphics. As a first step, youll add a
graphic for the aircraft body part for visual representation.
Main landing gear mechanism
Use a HyperMesh file to create a graphic for the aircraft body.
3. From the Tools menu, select the Import CAD or FE utility.
4. Select the option Import CAD or Finite Element Model Only. With this selection, only the
graphics will be imported without creating any bodies.
5. For Input File, select HyperMesh. For Output File, select H3D.
6. Click the Input File file browser icon, , and select the HyperMesh file
Aircraft_Structure.hm as the input file.
7. Save the file as Aircraft_Structure.H3D in the working directory.
8. Click OK.
9. When the H3D file is generated and the graphic is imported, the import success message is
displayed. Click OK.

10. Click the Graphics icon in the MotionView toolbar.
The model after importing a graphic for the aircraft body.
11. Select the just-added graphic from the Graphic area. The panel for the aircraft body is displayed
12. From the Connectivity tab
Resolve the Body collector to Aircraft 5.
The H3D file has only one component, (aircraft_body), so the Component list can be set to
All or use the drop-down menu to select the the sole component.

Step 2: Defining a motion to retract the landing gear.
In this step, define the motion to retract the landing gear.
1. From the Project Browser, right-click on Model and select Add Constraint > Motions (or right-
click the Motions icon, , from the toolbar). Add a motion with Label as Retraction Motion
and Varname as mot_ret. Resolve the Joint to the Cylindrical Joint ActPis_ActCyl_Cyl
(shown in the image below), which is defined between the bodies Activating Cylinder and
Activating Piston.
Rev joint
2. From the Motion panel > Properties tab, under Define by, select Expression. In the
Expression field, enter the expression `STEP(TIME,0,0,5,-750)`.
Note The above STEP expression ramps the value of motion from 0 at 0 second to -750 at 5
seconds. For more information on this solver function available within MotionSolve,
please refer the MotionSolve on-line help.

3. Add another motion and name it Aligning_Motion. Resolve the Joint to the Cylinderical Joint
LnkCyl_LnkPis_Cyl defined between the MLG Cyl and MLG Pis bodies (see the image below).
Translation joint
4. From the Properties tab of the panel, under Define by, select Expression. In the Expression
field, enter the expression `STEP(TIME,0,0,2,-100)`.
5. Save your model as landinggear_motion.mdl.
Step 3: Running a dynamic analysis to simulate the retraction of the main

landing gear.
In this step, run a transient analysis of the main landing gear mechanism.
1. In the Run panel, set the End time to 5 seconds.
2. Click the Save and run current model browser button and enter the name for the run file as
lg_retract.xml. Click Save.
3. Click Run. Once the simulation is completed, close the solver window and the Message Log.
4. From the Run panel, review the results animation by clicking on Animate button.
Phase 2
In this phase, write a Templex template to script and run a sequential simulation to simulate the
retraction and extension of the landing gear mechanism.

Step 1: Defining an extension motion for the landing gear.
In this step, model the extension motion of the landing gear.
1. From the Project Browser, right-click Model and select Add Constraint > Motions (or right-
click the Motions icon, , from the toolbar). Add another motion with Label as Extension
Motion and Variable Name as mot_ext. Resolve the motion to the same joint for which the
Retraction Motion has been defined.
2. From the Properties tab, set the type of motion as Expression and enter the following in the
Expression field: `STEP(TIME,5,-750,10,0) `.
Step 2: Defining a template to run the sequential simulation.

In this step, write a template to script a sequential simulation.
Template (or right-click the Template icon, , from the toolbar). Specify a Label and
Varname and click OK.
2. For Type, select Write text to solver command file.
3. Enter the script given below. The entries in the curly braces {}, refer to the idstring of either
Extension Motion or Retraction Motion. These idstring attribute can also be accessed using
the Expression builder, .
Note The following commands are MotionSolve command statements in the XML format. Since
the solver refers to entities through their ID numbers, the element_id value is resolved
to the motion IDs. If you have used different varnames for the motions than mentioned
below, the text could differ.
<!-Deactivate the extension motion first -->
<Deactivate
element_type = "MOTION"
element_id = "{MODEL.mot_ext.idstring}"
/>
<!-Simulate for 5 seconds -->
<Simulate
analysis_type = "Transient"
end_time = "5.0"
print_interval = "0.01"
/>

<!-Deactivate the retraction motion -->
<Deactivate
element_id = "{MODEL.mot_ret.idstring}"
/>
<!-Activate the extension motion that was deactivated during the first simulation --
>
<Activate
element_id = "{MODEL.mot_ext.idstring}"
/>
<!-Simulate for 5 more seconds -->
<Simulate
end_time = "10.0"
/>
<STOP/> <!- Stop the simulation. Any further commands below this command will
not be executed -->
The above script has five blocks.
Block 1 Deactivates the motion which defines the extension of the landing gear.
Block 2 Simulates the model for the retraction of the landing gear.
Block 3 Deactivates the motion used to retract the landing gear
Block 4 Activates the motion which defines the extension of the landing gear.
Block 5 Simulates the model for the extension of the landing gear.
The Stop command is used to stop the simulation at the time set in the last Simulate block.
Note A template can be used either to add modeling entities to the solver deck, such as
joints, markers, and so on, that may not be supported by MotionView, or command
entities such as simulation parameters, activation and deactivation, and so on. The
MotionSolve XML is divided into two sections.

1. Model section: All model elements are defined. To write to this section from the template,
for Type select Write text to Solver input deck.
2. Command section: Commands for the solver simulation are defined. To write to this section
from the template, for Type select Write text to Solver command file.
Step 3: Simulating and animating the model.

In this step, run the model to simulate the retraction and extension of the main landing gear model
and animate it.
1. From the Run panel, specify the filename as MLG_Simulation.xml and click Run.
2. Once the solution is complete, close the HyperWorks Solver View window.
3. Click the Animate button and review the animation.
Phase 3
In this phase, you will create output requests and re-run the model to measure the Angular
Displacement and Angular Velocity of the landing gear.
Outputs (or right-click the Outputs icon, , from the toolbar).
2. Create an output request. From the Outputs panel:
Set Type to Displacement and Entity.

Use the drop-down menu to select the Joint collector.
For the Joint, select the Revolute Joint between the Main LG Cylinder and Aircraft-5,
MLG_Ac_Rev.
3. Create another output request to measure the velocity at the same joint as above.

4. Re-run the analysis with these output requests and plot the requested results from the generated
PLT file in HyperGraph.
5. Save your model and exit your HyperWorks session.

Animation

Introduction
Use some features available for post-processing animation results in HyperView

Control the display of the simulation results using Entity Attributes
HyperWorks animation functions allow you to view your model in motion. The three animation types
include transient, linear, and modal. You can select the animation type from the animation types
drop-down menu.
Animation types menu
Transient Transient animation displays the model in its time step positions as
calculated by the analysis code. Transient animation is used to
animate the transient response of a structure or multi-body system.
Linear Linear animation creates and displays an animation sequence that

starts with the original position of the model and ends with the fully
deformed position of the structure or multi-body system. An
appropriate number of frames are linearly interpolated between the first
and last positions. Linear animation is usually selected when results are
from a static analysis.
Modal Modal animation creates and displays an animation sequence that

starts and ends with the original position of the structure or multi-body
system. The deforming frames are calculated based on a sinusoidal
function. Modal animation is most useful for displaying mode shapes.

Multi-body Analysis Types, Animation Mode Settings, and File Types
The tables below show the animation analysis types, mode settings, and the model and results file
types required to animate MotionSolve and Adams results.
Multi-body Animation Parts in Model Model Results

Analysis Type Mode Setting File File
Transient/Static/
Transient Rigid or Flexible Bodies H3D H3D
Quasi-Static
Linear Modal Rigid or Flexible Bodies H3D H3D
Animation Information for MotionSolve Results
Multi-body Animation Parts in Model Model Results

Analysis Type Mode Setting File File
Transient/Static/
Transient Purely rigid GRA GRA
Quasi-Static
Transient/Static/
Transient One or more flexible bodies FLX FLX
Quasi-Static
Linear Modal Purely rigid GRA RES
Linear Modal One or more flexible bodies FLX FLX
Animation Information for Adams Results
Step 1: Viewing and Controlling Animation Files.

In this exercise, you will view and control the pendulum animation based on the files output by
MotionSolve.
Note Copy all of the h3d files located in the mbd_modeling\animation folder to your <working
directory>.
1. From the File menu, select New > Session to start a new session.
If a warning message is displayed, asking if you want to discard the current data, click Yes to
continue.
2. Click the Select application drop-down menu, , from the toolbar, and select HyperView

3. Click the Load Results icon, , from the Standard toolbar.
The Load model and results panel is displayed.
Load model and results panel
4. Click the file browser icon, , next to Load model and select the model file as
single_pendulum.h3d, located in your working directory.
5. The field for Load results will be automatically updated with the same path and name.
6. Click Apply.
HyperView loads the animation file.
7. Click the XZ Left Plane View icon on the Standard Views toolbar to change to the left view
of the model.
8. Click the Start/Pause Animation icon, , on the Animation toolbar to start the animation.
9. Right-click on the Fit Model/Fit All Frames icon on the Standard Views toolbar to fit the
entire animation in the window.
10. Click the Animation Controls icon, , on the Animation toolbar.
From this panel, you can control the parameters like speed, start time, end time of the animation.
Animation C ontrols panel
Drag the vertical slider bar on the left to change the animation speed from fast to slow.
Current time: show all the time steps.
The Animate start and Animate end sliders can be set to restrict the animation to a certain
window in time. For example, moving the start slider to 0 and end slider to 3.5 to restrict the
animation to these time limits and covers only a partial cycle of motion.

11. Click the Start/Pause Animation icon, , on the Animation toolbar to stop the animation.
Step 2: Tracing Entities.

HyperView allows you to trace the path of any moving part while animating.
1. Retain the animation file single_pendulum.h3d that was loaded in Step 1 above.
2. To trace the pendulum motion, click the Tracing button, , on the toolbar.
Tracing panel
3. Under Trace select Component from the radio buttons on the left.
4. Pick the entity/component that needs to be traced by clicking on it from the graphics window.
5. Change the view to the Iso view.
6. Under Tracing mode: select Last and specify 10 as the steps.
7. Animate the model. This displays the last 10 steps in the animation.
8. To turn the tracing off, click the Delete button to remove the selected components from the
tracing list.
9. Try the From First Step and All Steps options.
10. Use the Display Options to change the line color and thickness.
Step 3: Tracking Entities.

The Tracking option allows one of the parts of the animation to be fixed to the center of the
animation window and the rest of the parts move relative to the tracked part.
1. Add a new page to the session by clicking on the Add page button, , on the Page Controls
toolbar.
2. Load the animation file front_ride.h3d from your working directory.

3. To Track or fix any part of your model in the center of the animation window and to see all the
other parts moving with respect to the fixed part, click on the Tracking, , button on the
Results toolbar.
Tracking panel
4. Add a tracking system to the animation by clicking on the Add button under Tracking Systems.
5. Under the Track pull down menu select Component and click on a part from the model currently
loaded.
6. Select the Displacements and/or Rotations to track the part.
7. Click the Start/Pause Animation icon, , on the Animation toolbar to start the animation,
and click the Start/Pause Animation icon again, , to stop the animation.
Step 4: Editing Entity Attributes.

In this exercise, you will edit the graphic entity attributes.
1. Retain the model front_ride.h3d loaded in the previous exercise Step 3 above.
2. Click the Entity Attributes icon, , on the Visualization toolbar.
The Entity Attributes panel is displayed.
Entity Attributes panel
3. Click the arrow to the right of the Entity option menu to expand it.
The list contains the following entity types: Components, Systems, Assembly Hierarchy, and
Sets.
4. Select Assembly Hierarchy from this list to show all the parts of the model in the entity list tree
below.

5. To change the color of the entire model:
Select Assembly Hierarchy from the Entity option menu.
Select All from the list of buttons next to the entity list tree (All, None, Flip, and Displayed).
Select a color from the color palette under the Color section.
6. To change the entire model to wire frame:
Click All from the list of buttons next to the entity list tree.
Click the Wire Frame icon, , beside Shaded.
7. To make the entire model transparent and shaded:
Click All from the list of buttons next to the entity list tree.
Click the Shaded icon, .
Click the Transparent icon, .

8. Use the On/Off buttons to turn the entities on or off.
9. Use the On/Off buttons next to ID: to display and hide the entity IDs.

Introduction
View force and moment vectors from a MotionSolve results file.

Use the collision detection feature
Use the measure panel to extract information from the animation results
Step 1: Force and Moment Graphics.

HyperView allows you to view the change in force and moment in the form of dynamic vectors that
represent the magnitude and direction of the force and moment.
Copy all of the h3d files located in the mbd_modeling\animation folder to your <working
directory>.
1. Start a new MotionView session or refresh your MotionView session by pressing SHIFT+F9.
2. Change the application on the page to HyperView.
3. Load the MotionSolve result file front_ride.h3d from your working directory.
4. Click on Vector icon, , on the toolbar.
Vector panel
5. Under the Result type: select Force (v).
6. Click on the Display sub-tab and select By Magnitude for Size scaling.
7. Click on Apply.
8. Now, animate the results by clicking on the Start/Pause Animation button, .

9. You will see an arrow whose size and direction change dynamically as the simulation is animated
from start to end. This arrow represents the magnitude and direction of force on a body or at a
joint as it is specified for force output in the model.
10. Click on the Clear Vector button to clear the force vector.
11. For the Result type: now select Moment (v).
12. Repeat the Steps 6 to 9 to view the Moment vectors of the simulation.
13. Under Display options: try changing the scale of the vectors by changing the Scale value:.
Collision Detection
HyperView allows you to view and detect collisions between bodies during simulations.
Step 2: Using the Collision Detection Option.
1. Click the Add a page button, , from the toolbar.
2. Use the Select Application menu to select HyperView as the application.
3. Click the Load Results icon, on the toolbar.
The Load Model and Results panel is displayed.
4. Click the Load model file browser and select collision.h3d, from your working directory.
5. Click the Load results file browser and select collision.h3d from the same location
specified in Step 4 above.
6. Click Apply.
7. Click the Start/Pause Animation icon, , to animate the model.
8. After the file is read, click the Start/Stop Animation icon, , to stop the animation.

9. Click the Collision Detection button, on the Tools toolbar (if this toolbar is not visible by
default, go to the View menu and select Toolbars > HyperView > Tools).
The Collision Detection panel is displayed.
C ollision Detection panel
10. Click the Add button in the leftmost column under Collision Sets to add a new collision set.
11. Pick the Trunk body in the graphics area.
Note Clicking on the Components input collector will display the Extended Entity Selection
dialog. The Extend Entity Selection dialog provides you with criteria based selection
options available for entity selection in HyperView. This method of selection is not used
in this tutorial. See the Selecting Entities Using the Input Collector topic (located in the
HyperView) to learn more about using this selection method.
12. Click the Add to Group A button.
13. Next, pick the Car body in the graphics area.
14. Click the Add to Group B button.
15. Under the Proximity section, click Enable Proximity checking and specify the Minimum
Distance for the proximity check.

16. Under the Show result by: section select Elements by clicking on the radio button next to it.
17. Click Apply.
18. Click the Start/Pause Animation icon, , to start the animation.
The animation begins.
Wherever areas of the trunklid collide with the trunk (car body), the colliding elements turn red.
The color yellow indicates proximity. When neither proximity nor collision is detected, the bodies
retain their natural colors.
19. Stop the animation.
20. Try these additional steps:
Try to view the Element and Component results alternately by clicking on the radio buttons in
the Show Results by: section.
Click on Summary below to get a text summary of the penetration.
Step 3: Using the Measure Panel.

HyperView allows you to measure certain parameters during post processing of the results.
Refresh your MotionView session by pressing SHIFT+F9.
Note Please refer to HyperView tutorial Using Keyboard Shortcuts and Function Keys - HV-2050 for
more information regarding keyboard shortcuts.
1. Change the Application to HyperView.
2. Load the file front_ride.h3d as the model and result file from your working directory.
3. Click on the Measure button, , on the Annotations toolbar to go to the Measure panel.
4. Under Measure Groups click on Add to add a Measure Group.
5. From the measure type pull-down menu select Position.
6. Click on the Nodes button and from the graphic window pick on a point of your choice.
7. Turn on the check boxes for X, Y and Z.

8. Click the Create Curves button (located on the right side of the panel).
The Create Curves dialog is displayed.
9. From the Place on drop-down menu select New Plot.
10. For the Y Axis: select X and activate the Live link check box.
Note The Live Link helps you correlate the measured value with the animation. As you
animate the current animation model a small square marker moves on the measured curve
to indicate the value of the curve at the corresponding time step of the animation.
11. Click OK.
12. Repeat Point 10 and 11 twice more by selecting Y and Z respectively and clicking on OK each
time.
13. Click the Start/Pause Animation icon, , to start the animating the results.
14. You will see a marker on all the three plots which corresponding to the simulation time step in the
HyperView window.
For more advanced animation options, refer to the HyperView tutorials.

Plotting

Introduction
In this tutorial you will learn to:
Import a MotionSolve result (plot) file for plotting curves

Plot multiple curves in a single window
Plot multiple curves in different windows on a single page
Save your work as a session (mvw) file
Theory
The Build Plots panel allows you to import plot files that can be plotted in a 2D layout. The panel
allows you to control what curves are to be plotted either in single or multiple windows.
Tools
The Build Plots panel can be accessed in any one of these three applications: MotionView, HyperView
or HyperGraph.
Copy the Demo.plt file, located in the mbd_modeling\plotting folder, to your <working
directory>.
Step 1: Opening a plot file.

1. Start a new MotionView session.
2. Select HyperGraph 2D from the Select application menu, , on the toolbar.
The toolbar is located right below the plot window.
3. Click the Build Plots icon, , on the toolbar.
4. Click the Open File icon, , on the Build Plots panel.
5. Select the file <working directory>\Demo.plt.
6. Click Open.
This file contains several curves.
7. Confirm that Time is selected under X Type:.
8. For Y Type: click on Displacement to select it.
The Y Request text box displays the data available in the file.
9. Click the Y Request expansion button to view the Y Request list.

10. Press CTRL button on the keyboard and click on REQ/70000006 and REQ/70000007 (or left-
click and drag the mouse to select both REQ/70000006 and REQ/70000007). Click OK.
11. Select X under Y Component:.
12. Set Layout as one plot per Component.
13. Click Apply.
Two curves are plotted in the plot window, each with its own line type and color. The legend
identifying the curves is located in the upper right hand corner of the plot.
Single plot window with multiple curves created using the Build Plots panel
Step 2: To build multiple curves on multiple plots using the plot file.
In this step you will select multiple curves and plot them in multiple windows.
1. Stay in Build Plots panel.
2. Leave Time selected under X:.
3. Leave Displacement selected under Y Type:.
4. Leave REQ/70000006, and REQ/70000007 selected under Y Request:.
5. Press CTRL and under Y Component: select X, Psi, MAG and RMAG.

6. Select One plot per Component from the Layout pull down menu , located in the lower left
corner of the panel.
This selection creates one plot for every request selected under Y component. There will be
four plots created. You could have one page for each plot. However, this tutorial wants all four
plots on the same page.
7. Click the Page Layout button , located next to the Show Legends check box.
8. Select the four window layout option .
The Page Layout dialog automatically closes.
9. Click Apply.
A second page is added to the page list with four windows and the plots you requested.
Multiple plots with multiple curves created using the Build Plots panel
Note The procedure to plot and edit curves from other result/request files (for example, .req, .abf,
etc.) remains the same as described in this tutorial.

Step 3: To save this work session.
You can save your work with multiple curves in multiple windows on multiple pages as a session file. A
session allows later retrieval either for display, printing, or to continue adding more information. The
session file is a script with the extension .mvw. The contents of an .mvw file are all the information in
the program that gets recorded in the script file.
Note To save a session as a script file with curve data: select the Options panel icon from the
Annotations toolbar, and activate the Save All Curve Data To Session File / Report
Template check box (located on the Session tab).
1. From the File menu, select Save As > Session.
2. Select a directory.

3. In the File name text box type Demo1.mvw.
Save Session As dialog
4. Confirm that Session (*.mvw) is selected from the Save as type drop-down menu.
5. Click Save.
This saves your current work session as a session script file called Demo1.mvw.
Step 4: To exit the program.

1. From the File menu, select Exit.
A dialog displays prompting you to save the session.
2. Click No, since you saved the session in the previous step.
For more advanced plotting options, refer to the HyperGraph tutorials.

MV-1070: Creating a Simple Pendulum System using MDL
MV-1030: Creating a System Definition Using the MotionView GUI

Create a model using the Model Definition Language (MDL).

Run a dynamic simulation of this model for a time of 2 seconds and 500 steps.
Plot the rotation of the pendulum about the global X-axis and view the animation.
MDL stands for Model Definition Language. A MotionView model is an object that holds the information
in the form of this language which is required to describe a mechanical system. The complete
information about the model is stored in the MDL format. MDL is an ASCII programmable language.
Some benefits of MDL include:
Opening and editing in any text editor

Assisting with model debugging
Using conditional statements "if" for custom modeling requirements
Building modular and reusable models
Parameterizing the models
Use modeling entities which are not available through GUI (for example, CommandSets)
Section 1: Entities in MDL

A modeling entity is saved to MDL in the form of MDL statements. All MDL statements begin with an
asterisk (*).
There are two types of entities:
General Entities
Definition Based Entities
General Entities
Have one statement to define the entity. They may have one or more statements to set their
properties.
Some examples include points, bodies, joints, etc.

Each general entity has certain properties consistent with its type. For example, a point has
the properties x-coordinate, y-coordinate, z-coordinate, label, state, and varname (variable
name).

Definition Based Entities
Are defined through a block statement, called definition, and its instance is created in a model
by an instantiation statement.
The block generally begins with a *Define() statement and end with a *EndDefine()
statement.
The entity (or block) is comprised of a series of other MDL entities or members.
These entities are reusable. Once defined, the same entity-definition may be instantiated
several times within the same model or different model files.
Some of the commonly used user-defined entities are outlined in the table below:
Entity Description
System A system entity defines a collection of modeling entities. These

definitions may be used repeatedly within the same model or different
MDL model files. A model can be organized into different systems.
Examples of system entities include SLA suspension system, wiper blade
system, and power-train system. Systems can be hierarchical in nature
(for example, a system can be a child of another system).
Assembly An assembly is similar to a system entity, except that the definition

resides in a separate file than the model file.
Analysis An analysis is a collection of entities (bodies, joints, etc.) describing a

particular analysis task or event applied to a model. For example, a
static ride analysis is one of the analysis that can be applied to a model.
An analysis can only be instantiated under Model (the top level root
system). A system can be a child of an analysis, however the reverse is
not true.
Dataset A dataset is a collection of user-defined variables of type integer, real,

string, Boolean, or filename. These variables can be referred or
parameterized to other entity properties. Datasets are displayed in a
tabular form, thereby offering a single window to modify a model.
Generally, design variables are collectively defined in the form of a
dataset. A dataset can be instantiated within a system or an analysis.
Template A template is a utility that uses the Templex program in HyperWorks.

It can be used to create user-defined calculations and codes
embedded into the model. The output of such code can be written out
to solver deck or execute another program. Another use is to
implement solver statements and commands not supported by MDL and
to generate text reports.
Note The system, assembly, and analysis are together referred to as container entities (or simply
containers).

Section 2: Properties of Entities
Each entity has variable, label, and other properties associated with it.
Each entity should have a unique variable name.
Following is the recommended convention for variable names which allows the user to identify
the modeling entity during debugging. You are not restricted to this nomenclature, however
you are encouraged to adopt it.
This list of entities and their properties is not comprehensive. For a complete list, refer to the MDL
Language Reference on-line help.
General Entities Naming Convention Properties
Point p_ x, y, z, label, state, varname
mass, IXX, IYY, IZZ, IXY, IYZ, IXZ, cg,

Body b_
cm, im, lprf, label, state, varname
RevJoint j_ b1, b2, i, j, id
Vector v_ x, y, z, label, state, varname
Marker m_ body, flt, x-axis, y-axis, z-axis, origin
ActionReactionForce frc_ b1, b2, fx, fy, fz, id, tx, ty, tz
General entities, their naming conventions, and properties
Definition Based Entities Naming Convention Properties
System sys_ Label, varname, state
Analysis ana_ Label, varname, state
Dataset ds_ Label, varname, state
Template tmplt_ Label, varname, state
User-defined entities, their naming conventions, and properties

To access entity properties; use the entity varname, followed by a dot separator, followed by the
property. Below are some examples:
Entity Varname Varname Represents
b_knuckle A body representing the knuckle in the mechanical system.
p_knuckle_cg A point representing the center of mass point for the knuckle body.
Entity Property Name Property Accessed
b_knuckle.cm The center of mass marker of the knuckle body, b_knuckle.
The ID of the center of mass marker of the knuckle body,

b_knuckle.cm.id
b_knuckle.
p_knuckle_cg.x The x coordinate of p_knuckle_cg.
Section 3: Global Variables

MotionView comes with Global Variables, by default, which are available for use anywhere in the
model. These variables are case sensitive.
The table below lists some commonly used keywords and what they represent:
Keyword Refers to
B_Ground Ground body
P_Global_Origin Global Origin
V_Global_X, V_Global_Y, V_Global_Z Vectors along the global XYZ axes
Global_Frame Global reference marker
Reference to the top level system of the

MODEL
model
C ommon keywords in MotionView

Section 4: MDL Statement Classification
Topology statements
These are statements that define an entity and establish topological relation between one entity and
the other. For example, *Body(b_body, Body, p_cg). In this example, the *Body statement
defines a body having its CG at point p_cg. Through this statement the body (b_body) is topologically
connected to point p_cg.
Property or Set Statements
These statements assign properties to the entities created by topological entities. For example,
*SetBody() is a property statement that assign mass and inertia properties to a body defined using
*Body(). Since most of the property statements begin with *Set, they are generally referred as
Set statements.
Definition and Data
Building upon the concept of a definition block, these terminologies are used specifically with regard to
container entities such as Systems, Assembly, and Analysis.
The block of statements when contained within a *Define() block are termed as a Definition. The
statements within the block may include:
1. Topology statements that define entities.
2. Set statements that assign properties. These Set statements within a definition block are
called "Default Sets", as they are considered as default values for the entities in the definition.
Any statements or block that resides outside the context of *Define() block are termed as Data.
These include:
1. Set statements within a *BeginContext() block that relate to entities within a system,
assembly, or analysis definition.
2. Some of the *Begin statements, such as *BeginAssemblySelection and *BeginAnalysis.
Section 5: MDL Model File Overview

MDL model file is an ASCII file; it can be edited using any text editor.
All statements in a model are contained within a *BeginMDL() - *EndMDL() block.
The syntax of the MDL statement is an asterisk (*) followed by a valid statement with its
arguments defined.
Statements without a leading asterisk (*) are considered comments. In this tutorial, comment
statements are preceded by // to improve readability. The comments are not read in by the
MotionView graphical user interface and are removed if the model MDL is saved back or saved
to a different file.
MDL accepts statements in any order, with a few exceptions.

To help you learn this language, the code in the tutorial examples will follow this structure:
//comments about the MDL file
*BeginMDL(argument list)
//Topology section
*Point
*Body
*System()
// definitions sub-section
*DefineSystem(..)
..
.*EndDefine()
//Property of entities directly in *BeginMDL()//Property section for entities

within Systems and analysis
*BeginContext()
..
..
*EndContext()
*EndMDL

Exercise: Build a Pendulum Model using MDL Statements
The figure below shows the schematic diagram of a pendulum. The pendulum is connected to the
ground through a revolute joint at the global origin. The pendulum falls freely under gravity, which
acts in the negative global-Z direction. Geometry and inertia properties are shown in the figure. The
center of mass of the pendulum is located at (0, 10, 10).
Schematic representation of the pendulum
The following MDL statements are used in this exercise:
*BeginMdl()
*EndMdl()
*Point()
*Body()
*Graphic() - cylinder
*Graphic() - sphere
*RevJoint()
*Output() - output on entities
*SetPoint()
*SetBody()
Step 1: Create an MDL model file.

1. In a text editor, create the following comment statements describing the purpose of the MDL
model file:
//Pendulum falling under gravity
//date

2. Create a *BeginMdl() - *EndMdl() block to signify the beginning and end of the MDL model file.
Create all other MDL model file statements between these block statements:
The syntax for the *BeginMdl() statement is:
*BeginMdl(model_name, "model_label")
where
model_name The variable name of the model.
model_label The descriptive label of the model.
For this model, use:
*BeginMdl(pendulum, "Pendulum Model")
*EndMdl()
It is strongly recommended that you look for the syntax of the corresponding statements by
invoking the online Help and typing the statement in the Index. In MDL statements, only the
keywords are case sensitive.
Step 2: Create the entity declarations required for the problem.

1. Create a point where the pendulum pivot would be placed using a *Point() statement. The
syntax is:
*Point(point_name, "point_label", [point_num])
where:
point_name The variable name of the point.
point_label The descriptive label of the point.
point_num An optional integer argument assigned to the

point as its entity number.
For this problem, you will need point_name and point_label.
//Points
*Point(p_pendu_pivot, "Pivot Point")
2. Using the same *Point statement create another point which would be pendulum center of mass:
*Point(p_pendu_cm, "Pendulum CM")

3. Use the *Body() statement to define the balls body. The syntax is:
*Body(body_name, "body_label", [cm_origin], [im_origin], [lprf_origin],

[body_num])
where:
body_name The variable name of the body.
body_label The descriptive label of the body appearing in the

graphical display of the body.
cm_origin An optional argument for the center of mass point of

the body.
im_origin An optional argument for the origin point of the inertia

marker of the body.
lprf_origin An optional argument for the origin point of the local

part reference frame of the body.
body_num An optional integer argument assigned to the body as

its entity number.
Square brackets,[ ], in the description of any statement syntax means that an argument is
optional.
This problem requires body_name, body_label, and cm_origin.
//Bodies
*Body(b_link, "Ball", p_pendu_cm)
4. Define the graphics for the body for visualization. To attach graphics to the body, use the
*Graphic() statement for spheres and cylinder to display the link and the sphere.
Statement syntax for sphere graphics:
*Graphic(gr_name, "gr_label", SPHERE, body, origin, radius)
where:
gr_name The variable name of the graphic.
gr_label The descriptive label of the graphic.
SPHERE This argument indicates that the graphic is a sphere.
body The body associated with the graphic.
origin The location of center point of the sphere.
radius The radius of the sphere.

For this exercise, use all of the arguments. The statement is:
//Graphics for sphere
*Graphic(gr_sphere, "pendulum sphere graphic", SPHERE, b_link, p_pendu_cm, 1)
Statement syntax for cylinder graphics:

*Graphic(gr_name, "gr_label", CYLINDER, body, point_1, POINT|VECTOR,
orient_entity, radius, [CAPBOTH|CAPBEGIN|CAPEND])
where
gr_name The variable name of the graphic.
gr_label The descriptive label of the graphic.
CYLINDER This argument indicates that the graphic is a cylinder.
body The body associated with the graphic.
Point1 The location of one end of the cylinder.
POINT|VECTOR Keyword to indicate the type of entity used to orient the cylinder.
If POINT is used, the following argument should resolve to a point,
otherwise it should resolve to a vector.
orient_entity The variable name of the entity for orienting the cylinder.
radius The radius of the cylinder.

[CAPBOTH| An optional argument that identifies if either or both cylinder ends
should be capped (closed).
CAPBEGIN|
CAPEND]
For this exercise, use all of the arguments. The statement is:
//Graphics for cylinder
*Graphic(gr_link, "pendulum link graphic", CYLINDER, b_link p_pendu_pivot, POINT,

p_pendu_cm, 0.5, CAPBOTH )
5. Create a revolute joint at the pivot point. The syntax is:

*RevJoint(joint_name, "joint_label", body_1,body_2, origin, POINT|VECTOR, point|
vector, [ALLOW_COMPLIANCE])
where:
joint_name The variable name of the joint.
joint label The descriptive label of the revolute joint.

body 1 The first body constrained by the revolute joint.
body 2 The second body constrained by the revolute joint.
origin The locations of revolute joint.
POINT|VECTOR Keyword to suggest the method of orientation for the joint using a
point or vector.
point|vector A point or vector that defines the rotational axis of the revolute
joint.
[ALLOW An optional argument that indicates the joint can be made

COMPLIANCE] compliant (a joint that is compliant is treated like a bushing and
can be toggled between compliant and non-compliant).
For this problem, you will use the following statement:

//Revolute Joint
*RevJoint(j_joint, "New Joint", B_Ground, b_link, p_pendu_pivot, VECTOR,

V_Global_X)
6. Create an entity output statement. The syntax for *Output - output on entities is:
*Output(out_name, "out_label", DISP|VEL|ACCL|FORCE, entity_type, ent_name,

[ref_marker], [I_MARKER|J_MARKER|BOTH_MARKERS])
where:
out_name The variable name of the output.
out_label The descriptive label of the output.
DISP|VEL|ACCL|FORCE An argument that indicates whether the output type is

displacement, velocity, acceleration, or force.
entity_type Keyword to indicate the type of entity on which the output

is being requested. Valid values are: BODY|JOINT|BEAM|
BUSHING|FORCE|SPRINGDAMPER
ent_name The entity on which output is requested.
ref_marker An optional argument for the reference marker in which the

output is requested.
I_MARKER|J_MARKER| Keyword to indicate the capture of output on the I marker,

BOTH_MARKERS J Marker or both markers. The default is both markers.

In order to obtain the displacement versus time output of the falling ball, you will use the
*Output() statement as follows.
//Output
*Output(o_pendu, "Disp Output", DISP, BODY, b_link)
7. Set property values for the entities you created in your MDL model file. This is done in the
property data section of the MDL model file. For this problem, use the *SetSystem(),
*SetPoint(), and *SetBody() statements.
//Property data section
*SetPoint(p_pendu_pivot, 0, 5, 5)
*SetPoint(p_pendu_cm, 0, 10, 10)
*SetBody(b_link, 1, 1000, 1000, 1000, 0, 0, 0)
8. Save the model as pendulum.mdl.
Your MDL model file will look like the file below (it summarizes the key sections of the MDL model
file for this exercise):
//Pendulum Model
//05/31/XX
*BeginMDL(pendulum, "Pendulum Model")
//Topology information
//declaration of entities
//Points
*Point( p_pendu_cm, "Pendulum CM")
//Bodies
//Graphics
*Graphic(gr_link, "pendulum link graphic", CYLINDER, b_link, p_pendu_pivot,

p_pendu_cm, 0.5, CAPBOTH)
//Revolute Joint

V_Global_X)

//Output
//End Topology
// Property Information
*SetBody( b_link, 1, 1000, 1000, 1000, 0, 0, 0)
*EndMDL()
Step 3: Load and run the MDL model file.
1. Launch MotionView .
OR
From the File menu, select Open > Model.
4. From the Open Model dialog, locate and select the file pendulum.mdl.
5. Click Open.
6. Observe and review the model in the graphics area.
7. From the Standard View toolbar, click the YZ Rear Plane View button.
The model is seen as shown in the image below:

8. Use the Project Browser to view the model entities and verify their properties.
9. Go to the Tools menu and click on Check Model to check for any modeling errors.
10. Perform the following steps to run MotionSolve:
Go to the Run panel and select Transient as the Simulation Type: option.
Set the End time as 2 seconds.
Click on the Simulation Settings button.
The Simulation Settings dialog is displayed.
Click on the Transient tab and review the integrator parameters.
Click Close to close the dialog.
From the Main tab, use the Save and run current model file browser, and enter pendulum
for the xml.
Click Run.
Upon completion of the run, close the solver window and clear the message log.
Step 4: Animate and plot the results.

1. Click Animate.
2. The animation file pendulum.h3d will be loaded in the adjacent window. Click on that window to
activate it.
3. Click the Start/Pause Animation icon on the Animation toolbar to start the animation, and
click the Start/Pause Animation icon again to pause the animation.
4. Right-click on the Fit Model/Fit All Frames icon icon on the Standard Views toolbar to fit
the visualization in all frames of the animation.
5. Click on the MotionView window to make it active.
6. From the Run panel, click Plot.
7. The plot window will be added, with the pendulum.abf loaded.
8. Select Y Type as Marker Displacement, Y Request as REQ/70000000 Disp Output (on

Ball), and Y component as DZ.
9. Click Apply.
The plot for the displacement of the pendulum in the Z direction is shown.

10. Click the Start/Pause Animation icon, , to review the plot and animation together. Click
, to pause the animation.
Your session page should look similar to the image below:
11. Close the session using the File menu (File > Exit).

MV-1070: Creating a Simple Pendulum System using
MDL
In this tutorial, you will learn how to create a definition based entity (such as a system) using MDL.
Using systems allows you to:
Organize your model file modularly

Reuse system definition files
Easily debug and maintain your files
Create a library of modeling components
Perform certain operations on the entire system at once (for example; turning systems on/off,
making the whole system compliant/rigid, translation, etc.). An operation, such as translation
on a system, is automatically performed on all the subsystems within that system.
The concept of system definition is analogous to the procedures/subroutines in a programming
language.
Analogy between programming and MDL approach
A procedure is a program that needs information from the main program. The procedure can be
called /instantiated any number of times. A procedure is a part of main program, but can be
maintained separately.
Similarly, a system definition is a model aggregate which needs information from the main model. It
can be called/instantiated any number of times. A system definition is a part of the main model
which can be maintained separately.
Use of system definition is two-step process:
1. Defining the system
2. Instantiation of the system definition in the model

Section 1: System Definitions
A system definition is a reusable system model that can be a part of any model as long all the
attachment requirements are satisfied.
A system definition is represented by a *DefineSystem() block. This block should end with a
*EndDefine() statement that indicates the end of a definition block. All entities defined within this
block are considered to be part of the system definition.
A typical system definition example is shown below:

*DefineSystem(def_sys, att_1, att_2att_n)
In the system definition example above:
def_sys is the variable name of the system definition and will be used while instantiating this
system.
att_1, att_2, att_n is a list of arguments that act as attachments to the system.
A system definition can be created in two ways:
1. Using the text editor.

2. Created from graphical user interface. This requires minimal text editing. Refer to tutorial MV-
1032.
Note This tutorial covers Method 1, as it covers all the details of the system definition.

Section 2: System Attachments
The picture above shows a system definition of an SLA suspension. It is an incomplete system which
needs information about the attachment bodies and points to get connected to.
Excluding the *Attachment() statement, other entities in a system definition are similar to an MDL
model file.
The general structure of a system definition is:
A system receives information about entities external to the system via attachments.
Any MDL entity can be passed to a system as an attachment.
The *Attachment() statement inside the system definition declares the arguments in the
*DefineSystem block as an attachment, along with assigning what type of entity the
attachment is going to be.
The same variable name as the attachment should be referred within the definition when
defining an entity that depends on the external entity.
Refer to the entries in bold in the example below. Reference line numbers are for reference
only and are not part of the MDL file.
o Line 2 - defines a system with a variable name sys_definition and has one argument
b_body_att as an attachment.
o Line 4 - declares b_body_att as an attachment with the entity type as Body.
o Line 7 - creates a revolute joint between b_sys_body which is a body defined within
this system (not shown) and b_body_att which is a body that is an attachment to this
system.

Note An attachment entity need not serve as a physical attachment to entities inside the
system definition. It may be used to represent external variables being passed into the
system definition. For example, datasets may also serve as attachments.
Section 3: Instantiating a System

Instantiating a system means creating an instance of a system definition. A system is
instantiated using a *System() MDL statement, which has the following syntax:
o *System(varname, label, def_varname, arg_1, arg_2, , arg_n) where,
varname variable name of the system instance.
label descriptive label for the system.
def_varname variable name of the system definition being instantiated.
arg_1, arg_2, arg,_n entity variable names that act as attachment to the
system. The number of arguments should match the number of attachments
listed and declared in the system definition.
A definition can be instantiated multiple times. For example, a single system definition file for
an SLA suspension can be used to create multiple SLA suspension systems within one or more
vehicle model files.
The following example illustrates a system definition and its instantiation within an MDL model
file. Some of the terms in the example below are in bold to highlight a few key relationships
between a system definition and its instantiation. Reference numbers are for the example only,
and are not contained in an MDL file.
o A system instance with variable name system1 is created in line 2, that refers to the
definition sys_definition. B_Ground (Ground Body) which is passed as an argument
for the attachment.
o The system definition is described within the *DefineSystem() and *EndDefine()

block between line 3 and line 7. Attachment b_att gets resolved to B_Ground.

Reference System Instantiation with Definition
Numbers
// Model : Body.mdl
1
*BeginMDL(base_model, "Base Model")
//Instantiate the system definition sys_definition

2
*System(system1, "First System", sys_definition, B_Ground)
//Begin System Defintion Block

3
*DefineSystem(sys_definition, b_att)
//Declare a body attachment to the system

4 *Attachment(b_att, "Body Attachment", Body, "Add an body
external to this system")
//Entities within the system
5 *Point(p_sys, "Point in the system")
*Body(b_sys, "Body in the system")
//Define a joint with the body b_sys and the body

attachment b_att
6
*RevJoint(j_rev, "Revolute Joint", b_sys, b_att, p_sys,
VECTOR, V_Global_X)
7 *EndDefine() //End Definition Block
8 *EndMDL()
You can instantiate systems within your model in one of three ways:
1. Manually author the MDL file as shown in the example above.
2. Import a system from the System/Assembly panel in the MotionView MBD Model window.
3. Use the Assembly Wizard in the MotionView MBD Model window.
The exercises that follow explain the first two methods; the third is covered in a separate tutorial.

Exercise 1: Creating and Using System Definitions
The following exercise illustrates how system definition can be generated from the original system MDL
file. The later part of the exercise shows two different ways of system instantiation.

*DefineSystem()
*System()
*SetSystem()
*Attachment()
Problem
In Steps 1 and step 2:
Modify the pendulum model from tutorial MV-1060 to create a pendulum system definition file
called sys_pendu.mdl.
Use this system definition to add another pendulum to the pendulum model from the tutorial
MV-1060 to obtain the double pendulum model shown in the figure below.
Save your base model file as doublependulum.mdl.
Perform a dynamic simulation of the transient response and view the animation.
Schematic representation of the double pendulum

Properties table for the double pendulum
Step 1: Create a system definition.

The structure of a system definition is similar to an MDL model file. You can reuse the pendulum model
file you created in the previous exercise to generate a more generalized system definition.
1. Copy the pendulum.mdl file, located in the mbd_modeling\mdl folder, to your <working
directory>.
Below is a sample MDL file for the pendulum model in tutorial MV-1060.
//Pendulum Model
//05/31/XX
*BeginMDL(pendulum, "Pendulum Model")
//Topology information
//declaration of entities
//Points
//Bodies
//Graphics
*Graphic(gr_link, "pendulum link graphic", CYLINDER, b_link, p_pendu_pivot, POINT,

p_pendu_cm, 0.5, CAPBOTH)
//Revolute Joint

V_Global_X)
//Output
//End Topology
// Property Information
*SetBody( b_link, 1, 1000, 1000, 1000, 0, 0, 0)
*EndMDL()
You can convert the above MDL file into a system definition by making small changes to your MDL
file. It is important to note that this conversion is not applicable in all cases, and some of the
conditions that need to be taken care are described later in this tutorial.
2. Replace the *BeginMDL() and *EndMDL() statements with the *DefineSystem() and
*EndDefine() statements, respectively. Specify an appropriate variable name for the system
definition.
3. The pendulum system definition would need information about:
Where to connect (attachment point or pivot point)
What body to connect to (attachment body)
Lets use att_point and att_body as the attachment entities.
4. Use these variables in the *DefineSystem () statement:
*DefineSystem (sys_def_pendulum, att_point, att_body)
Note As mentioned earlier, the attachment entity can be any MDL entity. Therefore one needs
to specify the entity type that the variable represents (for example, att_point represents
the POINT entity).
5. Use *Attachment statement to specify the entity type that each variable represents.
*Attachment (att_point, "Pivot Point", POINT, "Attachment point where the pendulum
definition gets attached")
*Attachment (att_body, "Attachment body" , BODY, " Any body to which the pendulum
definition gets attached")
Note In the original model variable p_pendu_pivot was representing the pivot point. While
converting the pendulum model to pendulum system definition, this pivot point would be
provided by the attachment point.

6. The point p_pendu_pivot is now passed as an attachment, therefore we do not need to define
the pivot point. Delete the statement *Point (p_pendu_pivot, "Pivot Point").
7. Retain pendulum CM point as it is.
8. Retain the *Body() statement to create the pendulum body.
The *RevJoint() statement refers to the B_Ground and p_pendu_pivot. Replace B_Ground with
the att_body and p_pendu_pivot with att_point.
9. Retain the sphere *Graphic() statement.
The *Graphic() statement for the cylinder refers to the variable p_pendu_pivot. Replace the
variable p_pendu_pivot with att_point.
Note All of these variable replacements show that wherever applicable, the attachment
variables should replace the original variables.
10. Retain the *Output() statement. This allows you to obtain displacement outputs on each
pendulum body in your model.
11. Remove *setpoint(p_pendu_pivot, 0, 5, 5).
12. Parameterize the points in the system so that they are positioned with respect to each other in a
certain way. In this case, you can set the CM point to be 5 units away from the attachment
point in the y and z direction (att_point.y+5, att_point.z+5).
13. The following file shows a sample system definition (system.mdl):
// system.mdl
// created on:
*DefineSystem(sys_def_pendulum, att_point, att_body)
//Topology Data
// Declaration of Entities
//Attachments
*Attachment (att_point, "Pivot Point", Point, "Attachment

point where the pendulum definition gets attached")
*Attachment (att_body, "Attachment body" , Body, " Any body

to which the pendulum definition gets attached")
//Points
//Bodies
//Joints
*RevJoint(j_joint, "New Joint", att_body, b_link, att_point,

VECTOR, V_Global_X)
//Output
//Graphics
*Graphic(gr_sphere, "pendulum sphere graphic", SPHERE,

b_link, p_pendu_cm, 1 )
*Graphic(gr_link, "pendulum link graphic", CYLINDER, b_link,

att_point, POINT, p_pendu_cm, 0.5, CAPBOTH )
// Property Data
*SetPoint(p_pendu_cm, 0, att_point.y+5, att_point.z+5)
*SetBody(b_link, 1, 1000, 1000, 1000, 0, 0, 0)
*EndDefine()
14. Save the file as sys_pendu.mdl.
Step 2: Add a system definition by manually authoring your MDL file.

In step 1, you created a reusable system definition. In this step, you will instantiate this system
definition in your model file. In the manual approach, you will write an MDL file which includes the
system definition and instantiates it several times.
1. Create a new empty file in a text editor.
2. Begin the model file with a *BeginMDL() statement.
3. Copy the content in the sys_pendu.mdl file from*DefineSystem() to *EndDefine() after the
*BeginMDL() statement.
4. Instantiate the first pendulum system using the *System() statement. Refer to the MDL Language
Reference online help for syntax. For example:
*System(system1, "First Pendulum System", sys_def_pendulum, P_Global_Origin,

B_Ground)
When you instantiate a system, remember:
Reference the system definition used by the system by specifying its variable name as the third
argument in the *System() statement. The variable name of the system definition should be
the same as you specified in the corresponding *DefineSystem() statement. In the above
example, system1 uses the system definition sys_def_pendulum.
If the system definition contains attachments, resolve those attachments when you instantiate
the system. For example, sys_def_pendulum has an attachment, att_body, to reference
body_2 in the *RevJoint() statement. In system1, the pendulum body, b_link, should be
connected to the ground body, B_Ground. Therefore, B_Ground is specified as the attachment
body in the *System() statement.
It is recommended to add the *System() statement before *DefineSystem(), although this

not mandatory.

5. Repeat Step 4 with appropriate modifications, to create the second pendulum system using the
*System() statement again.
Provide a different variable name, system2, for the system instance.
Use Pendulum CM (p_pendu_cm) and the Pendulum Body (b_link) from the first system as
the attachment.
The exact statement that you should use is shown below:
*System(system2, "Second Pendulum System", sys_def_pendulum,
system1.p_pendu_cm, system1.b_link )
6. Close the MDL file with the *EndMDL() statement.
A sample MDL file is provided below:

*BeginMDL(model, "MODEL")
*System(system1, "First Pendulum System", sys_def_pendulum, P_Global_Origin,

B_Ground)
*System(system2, "Second Pendulum System", sys_def_pendulum, system1.p_pendu_cm,

system1.b_link )
*DefineSystem(sys_def_pendulum, att_point, att_body)
//Topology Data
// Declaration of Entities
//Attachments
*Attachment (att_point, "Pivot Point", Point, "Attachment point where the

pendulum definition gets attached")
*Attachment (att_body, "Attachment body" , Body, " Any body to which the
pendulum definition gets attached")
//Points
//Bodies
*Body(b_link, "Pendulum Body", p_pendu_cm)
//Joints
*RevJoint(j_pivot, " Revolute Joint at Pivot Point ", b_link, att_body,

att_point, VECTOR, V_Global_X)
//Output
//Graphics
*Graphic(gr_sphere, "pendulum sphere graphic", SPHERE, b_link, p_pendu_cm, 1 )
*Graphic(gr_link, "pendulum link graphic", CYLINDER, b_link, att_point, POINT,

p_pendu_cm, 0.5, CAPBOTH )

// Property Data
*SetPoint(p_pendu_cm, 0, att_point.y+5, att_point.z+5)
*SetBody(b_link, 1, 1000, 1000, 1000, 0, 0, 0)
*EndDefine()
*EndMDL()
7. Save the model as doublependulum.mdl.
8. Open the MDL file in MotionView and review the model.
9. Take a close look at items listed in the Project Browser. You will now notice a 'hand' under the
System icon for the First Pendulum System and the Second Pendulum System. This indicates
that both of these systems share a single definition. This feature is called a Shared Definition.
10. When a System definition is shared among different instances, any modifications to one of those
instances can be made to reflect in all of the instances. This can be achieved as follows:
From the Tools menu, select Options.
The Options dialog is displayed.

Click on the Build Model option (located near the bottom of the tree).
11. Under Legacy Support, uncheck the Create a separate definition when modifying a shared
instance option. This will ensure that when entities in a shared instance are modified, the
changes will be reflected across all of the instances without creating a separate definition.
12. Click OK to close the dialog.
13. Run the MotionSolve simulation and post-process the results. From the Main tab of the Run
Panel , specify the End time as 1.0 and the Print interval as 0.01.
Exercise 2: Adding Systems from the Systems/Assembly Panel

This exercise demonstrates how to instantiate a system from the MotionView graphical user interface
using the Systems/Assembly panel.
Problem
In this exercise:
Use MotionView to add another pendulum link to your double pendulum model to obtain the
triple pendulum shown in the image below.
Solve and view the animation.

The triple pendulum
Properties table for the triple pendulum

Step 1: Add the system definition from MotionView.
Adding system definitions to a model is similar to adding other entities except the system definitions
are loaded from a file.
1. Start MotionView and open the pendulum model file from Exercise 1 (the previous exercise) in the
MBD Model window.
2. From the Project Browser, click Model.
The Systems/Assembly panel is displayed.
3. Click the Import/Export tab.
4. Using the Select File: file browser , pick the system definition you just created, sys_pendu.mdl.
5. Click Import.
The Specify entity details dialog is displayed.
6. Under Select a definition, select sys_def_pendulum.
7. Under Label, remove the default label and enter Third Pendulum System as the new label.
8. Under Variable, remove the default variable and enter system3 as the new variable.
9. Click OK.

Step 2: Resolve attachments and update points.
1. Select the newly added system from the Project Browser.
The *Attachment() line added to the system definition now appears in the Attachments tab for
the system folder of the newly added system. Attach the third link of the pendulum to the
second link in the pendulum system.
2. From the Attachments tab, activate the collector for Attachment body to select a
body attachment.
3. Expand the Bodies folder in the second pendulum system and pick the Pendulum Body (which
belongs to system2).
4. Click OK.
5. Next, activate the collector for Pivot Point to select a point attachment.
The Select a Point dialog is displayed
6. Expand the Points folder under the second pendulum system and select the Pendulum CM point.
7. Click OK.
The third pendulum system should be visible in the graphics area.
8. Save the model as triplependulum.mdl for future use.
9. Run MotionSolve and view the results.

Important Note Regarding Definitions:
One important aspect of definitions is that they need to be independent, therefore a

*DefineXXX block should not contain another *DefineXXX block within them. For example, the
figure on the left (below) shows a *Define block inside another *Define block. Such
definitions are referred as nested definitions and may result in MotionView giving errors while
reading such definitions. The figure on the right shows the correct way of placing definitions.
In Exercise 1, the method to author a system definition is described by modifying an existing

model MDL, in other words replacing *BeginMDL() and *EndMDL() with *DefineSystem() and
*EndDefine(). While this method can be employed in many cases, care should be taken so
that any existing definition block within the *BeginMDL block should not end up being nested
as described above. Such a definition block must be moved out of the block so that the
definition blocks are independent with regard to each other.

In this tutorial, you will learn how to create an analysis definition and instantiate it in an MDL file.
An analysis is a collection of loads, motions, output requests, and entities (bodies, joints, etc.)
describing a particular event applied to a model. For example, an analysis to determine the kinematics
of a four-bar mechanism can be described in one analysis, while another analysis can be used to study
a dynamic behavior. In both cases, while the overall model is the same, the analysis container may
contain different entities that form the event. The kinematic analysis can contain motion and related
outputs, while the dynamic analysis may contain forces and its corresponding outputs.
An analysis definition is similar to a system definition in syntax and usage, except:
o Analysis definitions use *DefineAnalysis(), while system definitions use

*DefineSystem().
o Analysis can be instantiated under the top level Model only.
o Only one analysis can be active in the model at a given instance.
A analysis definition block begins with *DefineAnalysis() and ends with *EndDefine(). All
entities defined within this block are considered to be part of the analysis definition.
The syntax of *DefineAnalysis() is as follows:
*DefineAnalysis(ana_def_name, arg_1,arg_2, ..., arg_n)
Where;
ana_def_name is the variable name of the analysis definition and will be used while
instantiating the analysis.
arg_1,arg_2..arg_n are a list of arguments passed to the analysis definition as

attachments.
The following table illustrates an analysis definition and its subsequent instantiation within an
MDL file. Two files, an analysis definition file and the model file, work together when
instantiating a particular analysis under study. Some of the terms in the example below are in
bold to highlight a few key relationships between the files.

Numbers
// Model : Body.mdl
1
*BeginMDL(base_model, "Base Model")
//Instantiate the analysis definition ana_def

2
*Analysis(ana1, "Analysis 1", ana_def, j_rev)
//Begin Analysis Defintion Block

3
*DefineAnalysis(ana_def,j_joint_att)
4 //Declare a joint attachment to the analysis

Numbers
*Attachment(j__joint_att, "Joint Attachment", Joint, "Add

an joint external to this analysis to apply motion/force")
//Entities within the analysis
5 *Point(p_1, "Point in the analysis")
*Body(b_1, "Body in the analysis")
//Define a joint with the body b_sys and the body

6 attachment b_att
*Motion(mot, "Joint Motion", JOINT, j_joint_att, ROT)
7 *EndDefine() //End Definition Block
8 *EndMDL()
The following table details the relationships between the analysis definition and its instantiation
in the MDL Model file.
Variable Relationship
j_joint_att The varname of the attachment, declared in the *Attachment()

statement (line 4) in the analysis definition file, appears as an
argument in the *DefineAnalysis() statement (line 3). A motion is
applied on this joint using the *Motion() statement (line 6).
ana_def The varname of the analysis definition is specified in the

*DefineAnalysis() statement (line 3). The analysis definition is
used by ana1 in the *Analysis() statement (line 2).
Defining relationships between the analysis definition and MDL model files
Exercise: Creating an Analysis Definition

An experimental technique for estimating the natural frequencies of structures is to measure the
response to an impulsive force or torque, then look at the response in the frequency domain via a
Fourier Transform. The peaks in the frequency response indicate the natural frequencies. In this
tutorial, we will create an analysis to simulate this test procedure. The analysis applies an impulsive
torque to the system and measures the response.
1. Use the following function expression to create the impulse torque about the x axis.
Tx = step(TIME,.3, 0, .31, 10) + step(TIME, .31, 0, .32, -10)
2. Apply this torque to estimate the natural frequencies of the triple pendulum model shown in the

image below:
Schematic representation of a triple pendulum in stable equilibrium
Your analysis applies to a pendulum with any number of links or to more general systems.
Properties table for the triple pendulum

*Attachment()
*ActionReactionForce()
*SetForce()
*Output()
Note Refer to the MotionView Reference Guide (located in the HyperWorks Desktop Reference
Guide) for the syntax of the above MDL statements.
Step 1: Create the analysis definition file.

1. Open an empty file in a text editor.

2. Create the *DefineAnalysis() and *EndDefine() block. All other statements will be added
between this block.
In the text editor, define an analysis with a variable name of def_ana_0 and one argument
j_att as an attachment.
*DefineAnalysis(def_ana_0, j_att)
3. The torque may be applied between two bodies connected by a revolute joint, with the origin of
the revolute joint taken as the point of application of the force. This allows you to have only one
attachment; the revolute joint.
Create an *Attachment() statement which defines j_att as the attachment and Joint as the entity
type. Make sure that the variable name used in the statement is the same as is used in the
*DefineAnalysis() statement.
*Attachment(j_att, Joint Attachment, Joint, Select joint to apply torque)
4. Use the *ActionReactionForce() statement to define an applied torque. Please note to

reference the correct properties of the attachment joint to reach the bodies involved in the joint.
Note Refer to the description of the dot separator in MDL. You can access
properties of an entity by using the dot separator.
For example, bodies attached to the revolute joint can be accessed as:
<joint variable name>.b1 and as <joint variable name>.b2.
Create an *ActionReactionForce() statement with the following:
Variable name of force_1.
Force type as ROT (rotational).
Body 1 as j_att.b1 (attachment joint body 1).
Body 2 as j_att.b2 (attachment joint body 2).
Force application point as j_att_i.origin (the attachment joint origin).
Reference frame as Global_Frame (global).
*ActionReactionForce( force_1, "Torque", ROT, j_att.b1, j_att.b2, j_att.origin,

Global_Frame )
5. Use the *SetForce() statement to set the value to the force defined in the previous step.
Create a *SetForce() statement with a variable name of force_1 (the existing force) and the
following torque values:
TX = step(TIME,.3,0,.31,10) + step(TIME,.31,0,.32,-10),TY = 0,TZ = 0

6. Use an *Output() statement to output the applied force.
Define an *Output() statement with the following:
Variable name of o_force.
Output type as FORCE.
Entity type as FORCE.
Variable name of force_1 (the action-reaction force created in Step 3 above).
Reference frame as Global_Frame (global).
*Output( o_force, "Input Torque", FORCE, FORCE, force_1, Global_Frame)
7. Save the analysis definition as analysis.mdl.
The saved file analysis.mdl will look like this:
*DefineAnalysis( def_ana_0,j_att )

Global_Frame )
*SetForce( force_1, EXPR, `step(TIME,.3,0,.31,10) + step(TIME,.31,0,.32,-10)`)
*EndDefine()
Step 2: Instantiate the analysis in a model.

1. Start MotionView and open the triplependulum.mdl file, located in the mdl folder.
2. From the Project Browser, click Model.
3. Click the Import/Export tab.
4. Using the Select File: file browser , pick the analysis definition you just created,
analysis.mdl.
5. Click Import.

6. Make sure that the Select a definition drop-down menu is set to Analysis.
7. Click OK.
8. Select the newly added analysis by clicking on Analysis 0 in the Project Browser, and resolve
the joint attachment by selecting any one of the pivot joints of the triple pendulum:
From the Attachments tab, select the Joint Attachment.
Select any pivot joint of the triple pendulum.
9. Save your model as new_triplependulum.mdl.
10. Solve the model. From the Main tab of the Run panel , specify the End time as 1.0 and the
Print interval as 0.01.
11. View the animation .
12. Plot the output "Input Torque" using the .abf file from the solution.

Create a dataset to specify the start time, mid time, end time, and the force magnitude
Include dataset definition in the analysis definition
Vary the magnitude and time of the impulse torque
In many occasions, it is convenient to provide inputs or change the design variables of a model
through a single interface. The variables could be in the form of real numbers, integers, or strings. Or
it could also be the name of a file. Having a dataset enables such a modeling scenario.
A dataset is a collection of user-defined variables whose values are used or referred by another entity
within MDL. Datasets are either created using the MDL language or the graphical user interface.
This exercise will focus on creating a dataset using MDL. A dataset is defined using a
*DefineDataSet() - *EndDefine() block, which is similar to other definition based entities such as
Systems and Analyses. The definition is then instantiated using the *DataSet() statement.
Exercise: Defining a Dataset
Step 1: Create a dataset definition.

The following steps illustrate how to create a dataset definition.
Refer to the MDL Language Reference online help for the correct syntax for the MDL statements you
choose to use.
1. In a new document in a text editor, create the *DefineDataSet() and *EndDefine() block. You
will create data members belonging to the dataset between these statements.
The data members that you need to define in the dataset are:
Starting time
Mid time
End time
Force magnitude
As all the data members are real numbers, we will use *Real() to define them.
Use one *Real() statement to define one data member.
You can also define other types of members such as: integers, strings, options, or a file (as
applicable to your model).

2. Save the file in the working directory as dataset.mdl. Your file should look like this:
*DefineDataSet(ds_def_force)
*Real(start_time, "Starting Time")
*Real(mid_time, "Mid Time")
*Real(end_time, "End Time")
*Real(force_magnitude, "Force Magnitude")
*EndDefine()
Step 2: Include the dataset in the analysis definition and instantiate.

The dataset will be included in the analysis definition by using the *Include() statement. The
dataset entities will be incorporated in the expression for torque.
1. In a text editor, open the analysis definition file created in tutorial MV-1080. Include the dataset
definition in it by using the *Include() statement before the *DefineAnalysis() statement.
The syntax is:

*Include("dataset.mdl")
2. Instantiate this dataset definition using the *DataSet() statement within the
*DefineAnalysis() block and after the *Attachment() statement.
The syntax for the *DataSet() statement is:
*DataSet(ds_name, "ds_label", ds_def, [optional arguments])
where
ds_name is the variable name of the dataset.
ds_label is the label of the dataset.
ds_def is the variable name of the existing dataset definition.
optional arguments are arguments that are passed as attachments (if any)
Instantiate the dataset by choosing a suitable variable name and label. The ds_def should be
the same as the variable of the dataset definition used in the *DefineDataset() statement.
*DataSet(ds_force, Force Data, ds_def_force)
3. Set the default values of the data members in the dataset by using the *SetReal() statement
within the *DefineAnalysis() block.
The syntax for the *SetReal() statement is:
*SetReal(real_name, real_value)
where
real_name is the variable name of the data member for which the value is being set.
real_value is the value of the data member.

As the data member is a part of the dataset, the correct form of referring to the variable name of
the real entity is ds_name.real_name.
For example, the *SetReal() statement for start time would be:
*SetReal(ds_force.start_time, 0.3)
4. Set the default values of all the data members used in the dataset definition.
Include the lines below after the *DataSet() statement:

*SetReal(ds_force.mid_time, 0.31)
*SetReal(ds_force.end_time, 0.32)
*SetReal(ds_force.force_magnitude, 10)
5. The *SetForce() statement in the analysis definition looks like:
*SetForce( force_1, EXPR, `step(TIME,.3,0,.31,10) + step(TIME,.31,0,.32,-10)`)
6. Change the appropriate values in the *SetForce() statement by incorporating the dataset
members. The idea is to use the dot operator to browse through the model hierarchy and access
the dataset values (for example, use ds_force.start_time.value to access the start time
value from the dataset). This is illustrated in the following statement:
*SetForce(force_1, EXPR, `step(TIME, {ds_force.start_time.value}, 0,
{ds_force.mid_time.value}, {ds_force.force_magnitude.value}) +
step(TIME, {ds_force.mid_time.value}, 0, {ds_force.end_time.value}, -
{ds_force.force_magnitude.value})`,0,0)
The expressions within the curly braces ({}) get processed by Templex in MotionView and get
evaluated to the appropriate values defined in the dataset.
The analysis definition file should look as below:

*Include(dataset.mdl)
*DefineAnalysis( def_ana_0,j_att )
*DataSet(ds_force, Force Data, ds_def_force)
*SetReal(ds_force.mid_time, 0.31)
*SetReal(ds_force.end_time, 0.32)
*SetReal(ds_force.force_magnitude, 10)

Global_Frame )

*SetForce(force_1, EXPR, `step(TIME, {ds_force.start_time.value}, 0,
{ds_force.mid_time.value}, {ds_force.force_magnitude.value}) + step(TIME,
{ds_force.mid_time.value}, 0, {ds_force.end_time.value}, -
{ds_force.force_magnitude.value})`)
*EndDefine()
7. Save the above work in a new analysis definition file named analysis_dataset.mdl.
Step 3: Change the dataset parameters and run the analysis.

1. In MotionView, load the triple pendulum model created in tutorial MV-1080.
2. Delete the existing analysis (if any) by right-clicking on the Analysis in the Project Browser and
clicking Delete.
3. Click on Model in the Project Browser.
4. From the Import/Export tab, import the new analysis definition file analysis_dataset.mdl
following similar steps used to import the analysis in the earlier exercise (MV-1080).
5. From the Project Browser, expand the Datasets folder and select Force Data.
You will see the dataset with the Labels and Values for all of the members in the dataset.
6. Change the Starting Time to 0.5, Mid Time to 0.55, End Time to 0.6 and the Force
Magnitude to 15.
7. Solve the model.
8. Compare the Input Torque in the plot window with that of the earlier analysis.
You can now change the force parameters easily through the dataset graphical user interface and
re-run your analysis.
9. Save your model as triplependulum_dataset.mdl.

MV-1030: Creating a System Definition Using the
MotionView GUI
In the earlier exercise, you learned about MDL and authoring a definition using the MDL language
through a text editor. In general, many of the definitions (such as systems, datasets, and analyses)
are created using the MotionView graphical user interface. This tutorial demonstrates how to create a
system using the GUI and save its definition to a file, which is an alternate way of creating a definition
other than using the text editor.
Exercise: Creating a System Definition Using the GUI.
This exercise will help you learn to:
Create systems using the MotionView graphical user interface

Export a system definition to a file
Reuse the saved definition by instantiating it in the model
Step 1: Creating a system instance.

1. To create a system, right-click on Model in the Project Browser and select Add > System/
Assembly.
OR
Right-click on the System/Assembly panel button on the Container Entity toolbar.
The Add System/Assembly dialog is displayed.
2. Select the System radio button and click Next.
The Add System dialog is displayed.
3. Specify sys_pendu as the Variable, Pendulum as the Label, and def_sys_pendu as the
Definition Name.
4. Click OK.
The Pendulum system is added to the model and its corresponding panel is displayed.
Step 2: Adding attachments to the system.

1. From the Attachments tab, click on the Add button (located in the middle of the panel).
The Add an Attachment dialog is displayed.
2. Specify the Label as Attachment Point and arg_p for the Variable, select Point (from the
drop-down menu), and verify that the Type is set to Single only.
3. Click OK.

4. Add another attachment with the Label as Attachment Body and Variable as arg_b, select
Body from the drop-down menu, and specify the Type as Single only.
We have created two attachments to the Pendulum system which will be used to attach this
system to other entities of a model.
Notice that the both of the newly created attachments are Unresolved, which means that the
attachments are not yet referring to another entity in the model.
5. Double click on the collector.

6. Select Global Origin from the list on the right side of the dialog and click OK.
7. Similarly, click the collector, select Ground Body from the model tree, and
click OK.
Step 3: Adding entities to the system.

1. Select Pendulum in the Project Browser.
2. Right-click and select Add > Reference Entity > Point.
OR
Right-click on the Points panel button on the Reference Entity toolbar).
3. Specify the Label as Mass CG, Variable as p_cg, and the Type as Single.
4. Click OK.
The Points panel is displayed with the properties of Mass CG.

5. From the Properties tab, click in the X Coordinate field and click on the button on the
Expression bar.
The Expression Builder is displayed.

6. Delete 0.0 from the Expression area (located at the top of the dialog).
7. From the model tree, expand the Pendulum > Attachments > Attachment Point folders and
select x (x is one of the property attributes of the point entity Attachment point).
8. Click the Add button (located in the middle of the dialog).
arg_p.x is automatically filled in the Expression area.

9. Append +50 to this expression.
The complete expression should now read: arg_p.x+50.
Through the above steps the point Mass CG is parameterized with regard to the X coordinate of
the point Attachment Point and is placed at a distance of 50 length units in the X direction.

11. Repeat the above steps for the Y and Z Coordinates, by selecting attribute y and z respectively
in the expression bar. Specify the expression for the Y Coordinate as arg_p.y and arg_p.z+100
for the Z Coordinate.
Alternatively, the expressions in Y and Z can be filled by copying the arg_p.x+50 expression from
X Coordinate and editing it.
Note The background color of the field changes for parametric expressions.
12. Right-click on the Pendulum system in the Project Browser and select Add > Reference Entity
> Body.
13. Enter Mass for the Label and b_mass for the Variable, and click OK.
14. From the Properties tab specify the Mass as 1 and the Inertia properties as 1000 for Ixx, Iyy
and Izz respectively.
15. Click on the CM Coordinates tab and check the Use center of mass coordinate system
option. Pick the point Mass CG as the Origin.

16. Right-click on the Pendulum system in the Project Browser and select Add > Reference Entity
> Graphic.
The Add "Graphic" dialog is displayed.
17. Specify the Label as Rod, the Variable as gcyl_rod, the Type as Cylinder, and click OK.
The Graphics panel is displayed.
18. From the Connectivity tab; double click on the Body collector for Parent and pick Mass in the
Pendulum system, click on the Point collector and pick Mass CG as Origin, and for Direction
double click the Point collector and select the attachment to the system Attachment Point.
19. Go to the Properties tab and change the value of Radius 1 to 2.
20. Next, add a Sphere graphic by right-clicking on the Pendulum system in the Project Browser
and selecting Add > Reference Entity > Graphic.
21. Specify the Label as Mass, the Variable as gsph_mass, the Type as Sphere, and click OK.
22. Pick Mass for the Parent body and Mass CG as the Origin.
23. From the Properties tab, specify 25 for the Radius.

24. Right-click on the Pendulum system in the Project Browser and select Add > Constraint >
Joint.
25. Select Revolute Joint from the drop-down menu, specify the Label as Pivot, the Variable as
j_pivot, the Type as Single, and click OK.
The Joints panel is displayed.
26. From the Connectivity tab, double click on and select Mass from the Select a Body
dialog (model tree). For the second body, click on the collector and browse through the
model tree (Model > Pendulum > Attachments) and select Attachment Body.
Note Alternatively, you can click on the Global Triad (at the bottom left of the triad) to pick
Ground Body via the Attachment Body.

27. Similarly, for Origin select Attachment Point (located under Model > Pendulum >
Attachments). Use the Alignment axis drop-down menu to change from Point to Vector and
select Global Y for the Alignment axis.
28. Save the model to your <working directory> as pend_gui.mdl.
Step 4: Exporting the system definition.

1. Select the Pendulum system in the Project Browser and click on the Import/Export tab in
the Systems/Assembly panel.
2. Select the Export option.
3. Click on the Select file file browser and browse to your <working directory>.
4. Specify the name of the file as sys_pend_gui.mdl by clicking on the folder icon and clicking on
Save.

5. Open the above file in a text editor.
The system definition content will look as displayed below:
*DefineSystem( def_sys_pendu, arg_p, arg_b )

*Attachment( arg_p, "Attachment Point", Point, "Select attachment.",
P_Global_Origin, )
*Attachment( arg_b, "Attachment Body", Body, "Select attachment.",
B_Ground, )
*SetDefaultSystemInstance( sys_pendu, "Pendulum" )
*Point( p_cg, "Mass CG" )
*Body( b_mass, "Mass", p_cg, , , , )
*Graphic( gcyl_rod, "Rod", CYLINDER, b_mass, p_cg, POINT, arg_p, 2.0,
gcyl_rod.r1, , 0.0, CAPBOTH )
*Graphic( gsph_mass, "Mass", SPHERE, b_mass, p_cg, 25.0 )
*RevJoint( j_pivot, "Pivot", b_mass, arg_b, arg_p, VECTOR, V_Global_Y )
*SetPoint( p_cg, arg_p.x+50, arg_p.y, arg_p.z+100 )
*SetBodyInertia( b_mass, 1.0, 1000.0, 1000.0, 1000.0,
0.0, 0.0, 0.0 )
*Set( b_mass.usecm, true )
*EndDefine()
Note The Export option is only available for Systems and Analyses. For other definitions like
Datasets or Templates, the definition can be copied from the model .mdl file.
Step 5: Instantiating the system definition.

1. Select the Model system in the Project Browser.
2. Click the Import/Export tab in the Systems/Assembly panel.
3. Click on the Select file file browser and browse to your <working directory>.
4. Select the sys_pend_gui.mdl file and click Open.

5. Click the Import button.
The Import System/Analysis Definition dialog is displayed.
6. Select def_sys_pendu.
7. Change the Label to Pendulum 2 and the Variable to sys_pendu_2.
8. Click OK.
The system definition is instantiated.
9. Select the Pendulum 2 system in the Project Browser.

10. Go to the Attachments tab and resolve the attachments in the following manner:
Double click on the collector. In the model tree that appears, click on the
Pendulum system, select Mass CG from the list on the right, and click OK.
Click on the collector. In the model tree that appears, click on the
Pendulum system, select Mass from the list on the right, and click OK.
11. Save the model to your <working directory> as pend_2_gui.mdl.
The same system definition can be reused to instantiate several times either within the same
model or in a different model.

Contact Simulation
MV-1012: Analytical Contact Simulation using MotionView and MotionSolve
MV-1020 Modeling 2D Rigid to Rigid Contact Simulation

Import CAD geometry with graphic settings suitable for contact simulation.
Setup 3D rigid body contact between meshed geometries in the multi-body model.
Perform a transient analysis to calculate the contact forces between these geometries.
Post-process the results using a report generated automatically.
For these purposes, you will make use of a slotted link model.
Introduction
This tutorial will guide you through the new 3-D rigid body contact capabilities in MotionSolve version
14.0 and later using the mesh-to-mesh contact approach. This approach makes use of surface
meshes for the bodies coming in contact during the simulation. A surface mesh is defined as an
interconnected set of triangles that accurately represent the surface of a 3D rigid body. MotionSolve
prescribes certain conditions for such a surface mesh.
Each component mesh should form a closed volume. This means that the given mesh should
not contain any open edges (edge which is part of only one element) or T- connections (2
elements join at the common edge in form of a T).
Mesh should be of uniform size.
Element surface normal should point in the direction of expected contact.
You can learn more about the best practices for contact modeling by clicking here.
For such a meshed representation of 3D rigid bodies, MotionSolve uses a numerical collision engine
that detects penetration between two or more surface meshes and subsequently calculates the
penetration depth(s) and the contact force(s).
There are numerous 3D contact applications (gears, cams, mechanisms with parts in contact etc.)
that may be solved using this approach.

Slotted Link Model
A slotted link mechanism (sometimes also referred to as a scotch-yoke mechanism) is a type of
mechanism used to convert an input rotational motion into continuous or intermittent translational
motion of a sliding link or yoke part. The motion is transferred via a contact force between parts of
the mechanism that are in contact. Both normal and friction contact force may be responsible for the
transfer of motion.
Such mechanisms find common application in valve actuators, air compressors, certain reciprocating
and rotary engines among others. The figure below illustrates a slotted link mechanism that will be
modeled in this tutorial.
A slotted link mechanism. The cam is in contact with the slotted link as shown, whereas the pin comes into contact with
the slots.
Step 1: Import CAD Geometry into MotionView.

1. Copy the slotted_link.x_t file, located in the mbd_modeling\contacts folder, to your
3. Click the the Tools menu, select Import CAD or FE .
Or
Click on the Import Geometry icon on the Standard toolbar.

4. Set the following options in this dialog:
Import Options radio button to Import CAD or Finite Element Model with Mass and
Inertias.
Input File as Parasolid and specify the input CAD geometry as slotted_link.x_t in your
<working directory> using the File Open icon .
Notice the Output Graphic File text field is automatically populated with the same path and
name, however it is suffixed with a _graphic.h3d extension. This is the file that will be used to
specify the graphics in the model. You may change the name or path of the graphic H3D if you
wish.
Expand the Meshing Options for Surface Data by clicking on the expand button ( ) if it is
not already expanded. Ensure that the option to Allow HyperMesh to specify mesh options
is checked.
Activate the Control mesh coarseness for contacts check box. Set the slider to 5. This
option tells HyperMesh to mesh the CAD geometry such that it can be used for 3D contact in
MotionSolve.
Note The slider controls the coarseness of the generated mesh, with 1 being the coarsest and
10 being the most fine. A very coarse mesh will have large triangles, which may not
represent the curvature of the CAD surfaces accurately. Alternatively, a very fine mesh
will have extremely small triangles that may increase element numbers and thereby the
solution time. The best practice is to strike a balance between mesh fineness and
performance that satisfies the modeling purpose.
At this stage, the Import CAD or FE dialog should look like the figure below:
Importing C AD using the Import C AD or FE utility

5. Click OK.
MotionView will invoke HyperMesh in the background, to mesh the geometry and calculate its
volume properties. Another dialog appears where the components in the CAD file can be reviewed
along with their mass, density, and volume properties.
Importing C AD using the Import C AD or FE utility
6. Click OK on this screen as well and Clear the Message Log.
The converted geometry is loaded into MotionView for visual inspection. You can inspect the
surface mesh by swapping the display to a meshed representation.
7. Click on the Entity Attributes icon, , on the Visualization toolbar.
The Entity Attributes panel is displayed.

8. Select all the graphics by clicking on Model at the top of the list at the left corner of the panel
and click on Mesh Lines .
Displaying mesh lines for all the components of the input C AD geometry
Displaying the surface mesh for all the components of the input C AD geometry

Step 2: Create Joints and Motion.
At this stage, the model contains the following bodies along with their associated graphics:
Entity name Entity type Description
Slotted_Link Rigid Body The slotted link body.
Cam Rigid Body The cam body.
Pin Rigid Body The pin body. Together the cam and the pin bodies
engage the slotted link.
Link Rigid Body A connector body between the pin and the cam.
Slotted_Link Graphic The graphic that represents the slotted link body. This
is a tessellated graphic.
Cam Graphic The graphic that represents the cam body. This is a
tessellated graphic.
Pin Graphic The graphic that represents the pin body. This is a
Link Graphic The graphics that represent the link body. This is a
The Pin, Link, and the Cam bodies are fixed to each other and pivoted with to the Ground Body at
the Cam center. The Slotted link can translate with respect to the Ground Body.
1. Create joints as per the details given in the table below:
S.No Label Type Body 1 Body 2 Origin Alignment

Axis
1 Pin Link Fix Fixed Joint Pin Link Pin CG
2 Link Cam Fix Fixed Joint Link Cam Link CG
3 Cam Pivot Revolute Joint Cam Ground Body Global Origin Global Y
4 Sloted Link Translation Sloted_Link Ground Body Sloted_Link CG Global X

Slider Joint
2. Apply a Motion on the Cam Pivot joint of the type Displacement and the Expression as
`360d*TIME`.

3. Save your model as slotted_link_mech.mdl.
Step 3: Define contact between the colliding geometries.

In this step, you will define contact between:
Cam and the Slotted_Link

Pin and the Slotted_Link
1. Right-click the icon on the Force Entity toolbar.
The Add Contact dialog is displayed.
2. Change the Label to Cam Slotted Link Contact. Verify that RigidToRigidContact is selected
and click OK.
3. From the Connectivity tab of the Contact panel, resolve Body I to Cam and Body J to
Slotted_Link. Doing this will automatically select the respective graphics that are attached to
these bodies.
To make sure that the geometries are well defined, ensure that the normals are oriented correctly
and there are no open edges or T-connections in the geometries.
4. Activate the Highlight contact side check box. This will color the geometries specified for this
contact force element according to the direction of the surface normals. Verify that both
geometries are completely red, that is make sure that there are no blue patches for either
geometry (to visualize clearly, you may have to deactivate the other graphic and reactivate).

C hecking for incorrect surface normals
The color red indicates the direction of surface normal and is the side of the expected contact.
Next, you can check for open edges or T-connections. If the associated graphics mesh has any
open edges or T-connections, the Highlight mesh errors option would be active. If it is active,
check the box for Highlight mesh errors. Doing this will highlight any open edges or T
Connections in the geometry.
The graphics associated in this contact entity dont have mesh errors. Hence you should see
Highlight mesh errors grayed out.
As you can see, the geometry seems to be clean and there are no free edges or T connections in
the model.

Note For every Contact entity added to the model, MotionView automatically creates an
Output of the type Expression that can be used to plot the contact forces for
that contact element.
5. Next, you need to specify the contact properties. Click on the Properties tab to bring up the
Normal Force and the Friction Force property sub-tabs within the contact panel. In this model
you will use an Impact model with the following properties:
Normal Force Model Impact
Stiffness 1000.0
Exponent 2.1
Damping 0.1
Penetration Depth 0.1
Friction Force Model Disabled
Specify the properties as defined above in the contact panel.
6. Repeat Steps 1 - 5 for creating contact between the Pin body (Body I) and the Slotted_Link
(Body J). You may define the label for this contact to be Pin Slotted Link Contact. Define the
same contact properties as listed in Step 5 above.
7. For the contact force element Pin Slotted Link Contact, you will also instruct MotionSolve to find
the precise time at which contact first occurs between the two colliding bodies. Navigate to the
Advanced tab. Check the box for Find precise contact event. In the text field below, specify a
value of 0.01.
Note With the Find precise contact event option, MotionView automatically adds a sensor
entity (defined by Sensor_Event in the solver deck), which has a zero_crossing
attribute. During simulation, when the contact force is detected for the first time (force
value crossing zero), MotionSolve will cut down its step size by the given factor and try
to determine the contact event more precisely.

Step 4: Setup a Transient Simulation and Run the Model.
At this point, you are ready to setup a transient analysis for this model.
1. Navigate to the Run panel by clicking on the Run icon on the toolbar.
2. Change the Simulation type to Transient and specify an end time of 3.0 seconds.
3. To obtain accurate results, you will specify a smaller step size than the default.
Click on Simulation Settings , to bring up the Simulation Settings dialog

Go to the Transient tab and set the Maximum Step Size to 1e-3. Click the Close
button.
Specifying the Maximum Step Size
4. From the Run panel, specify a name for your XML model and click on the Run button. The
transient simulation is started.
Specify the output file name and run the model
In the HyperWorks Solver View window that pops up, you should be able to see a message from
the solver that confirms that the mesh based contact method is being used for the contact
calculations.
Verifying that the mesh based contact is used for the simulation

In the log file you will also see messages related to the sensor, this is related to finding the
precise contact event for the second contact element in the model.
Solver message related to sensor activity
Step 5: Post-process the Results.

After the simulation is complete, MotionSolve prints out a summary table (both on screen and in the
log file generated) that lists the top 5 contact pairs ordered by maximum penetration depth and by
maximum contact force for this simulation. This is very useful since it can be used to verify that the
model is behaving as intended even before loading the results (ABF, MRF, PLT or H3D) files. You can
also use this table to verify that the penetration depths and contact forces are within the intended
limits for your model. The summary table for this simulation is illustrated below:
C ontact Overview Table
1. To view a consolidated report of the results, navigate to Assembly>View Reports.
Analysis reports
This brings up a list of the history of simulations you have completed in the past using
MotionView.

2. Select the Contact Report that corresponds to this simulation.
3. Click OK.
C reate contact report

MotionView creates a number of pages in your current HyperWorks session:
Contact Overview via H3D
The first HyperView page (second in the session) displays a contour plot colored by maximum
penetration depth over the entire length of the simulation. You may hide one or more parts to
view this clearly in the graphic area. This is illustrated in the figure below. The cam graphic has
been made transparent to see the penetration depths better.
The contact overview for penetration depth
Note The contact overview colored by penetration depth is only available for meshed
geometries.

Visualizing the penetration depth via H3D
Navigate to the next page .
The third page in the session can be used to animate the results while viewing a contour
plot of the penetration depth colored by magnitude. This allows you visualize the penetration
depths at different times of the animation.
Set the graphic display to Transparent Elements and Feature Lines.
Setting all graphics display to transparent and feature lines
Click on the Animation Controls icon, , on the Animation toolbar and move the
Animate End slider to the end .
Click on Contour panel button on the toolbar and select the Cam body as the
Components collector.
Click Apply.
Click on the Start/Pause Animation button to animate the result.
The penetration depth contour animation on the cam body can be visualized.
The contact penetration depth contour

Visualizing the Contact forces via H3D
Navigate to the next page
The fourth page in the session can be used to visualize the contact forces in the animation
of the results. By default, the contact report plots the total contact force for each contact
element.
Click on the Animation Controls icon, , on the Animation toolbar and move the
Animate End slider to the end .
Click on the Start/Pause Animation button to animate the result.
Set the graphic display to Transparent Elements and Feature Lines .
The forces may need to be scaled by magnitude or uniformly by a factor to be entirely
visible. To change the scale, go to the Vector panel , click on the Display tab and
change the Size scaling option as appropriate.
An example of this animation is shown in the figure below:
The total contact force between the cam body and the slotted link
The current force vectors are displayed on each node of the mesh that is in contact at each
time step.

Visualizing the sum total of force at a given region
From the Results browser deactivate the following Components: Contact Graphic(Cam
Slotted Link Contact) and Contact Graphic (Pin Slotted Link Contact). Activate the
Contact Region Output (by either clicking on the icon in the browser or using the right-
click context menu).
Deactivating and activating components from Results browser
MotionSolve supports a number of outputs that can be animated in HyperView:
o The contact normal force
o The contact penetration depth
o The contact penetration velocity
o The contact point slip velocity
o The contact tangential force
o The contact total force

Visualizing MotionSolve outputs
Navigate to the Vector panel .
For the Result type, select the type of result you would like to see from the drop-down
menu. Next, click Apply.
This will plot the result type you selected for all the relevant graphics in the model. You may
have to scale the force vectors accordingly to make sure they are visible.
Scaling the tangential force
As an example, the point slip velocity vectors are plotted in the figure below:
Point slip velocity vectors

Plotting the contact forces via ABF
Navigate to the next page . This is the last page in the session.
Each time a new contact entity is created in MotionView, a corresponding output force request is
created that can be used to plot the contact forces between the graphics specified in the
contact entity. These can then be visualized in HyperGraph. The last page of the contact report
plots the contact force magnitude for all the contact elements in the model.
Total contact force magnitude
Manually plotting other output requests
Click Add Page and change the client to HyperGraph 2D (if it is not already
selected).
Open the ABF output file for the simulated model.
Under Y Type, select Expressions and select a request in the Y Request window.
As an example, select REQ/70000003 Force Pin Slotted Link Contact as the Y Request
and F4 as Y Component to plot.
Click Apply.

Visualizing the contact force in HyperGraph
Save your session as slotted_link.mvw.
Summary
In this tutorial, you learned how to create a good meshed representation from CAD geometry. Further,
you learned how to setup contact between meshed geometries. Also, you were able to inspect the
geometry to make sure the surface normals were correct and there were no open edges or T
connections.
You were also able to setup a transient analysis to calculate the contact forces between these
geometries and post-process the results via vector and contour plots in addition to plotting the
contact force requests.

MV-1012: Analytical Contact Simulation using
Setup semi-analytical contact between a primitive spherical geometry and a meshed geometry.
Perform a transient analysis to calculate the contact forces between these geometries.
Process the results.
Compare the analysis time when using meshed representation for the spheres.
For these purposes, you will make use of a ball bearing model.
Introduction
This tutorial will guide you through the new analytical 3-D rigid body contact capabilities in
MotionSolve. When one or both of the rigid bodies in contact are primitive spheres, MotionSolve uses
a semi-analytical or fully analytical contact method respectively to calculate the penetration depth(s)
and subsequently the contact force(s). This is explained in the table below:
Body I graphic Body J graphic Contact method Description
A semi-analytical contact
method that computes contact
Primitive Sphere Mesh Sphere Mesh between the primitive sphere
(Body I) and the tessellated
geometry (Body J).
A fully analytical contact method

Primitive Sphere Primitive Sphere Sphere Sphere that is independent of the
tessellation of either graphics.
There are several 3D contact applications that involve spherical geometries (ball bearings, re-
circulating ball systems etc.) using the analytical approach for computing the contact forces in such
scenarios offers several benefits:
1. The simulation time is reduced when using the semi-analytical or fully analytical approach.
2. The simulation is more robust since the dependence on the mesh quality is removed.
3. The simulation results are often more accurate since there are no or lesser effects of mesh
discretization.

Ball Bearing Model
A ball bearing is a type of bearing that consists of balls located between the outer and inner bearing
races. The balls are in contact with both the outer and inner races. The purpose of the balls is
mainly to support radial loads between the two races while minimizing losses due to friction. Since the
balls roll in between the two races, the friction is drastically reduced as compared to two surfaces
sliding against each other. A typical ball bearing geometry is illustrated in the figure below:
A typical ball bearing geometry with six balls. A cutaway section shows how the balls are in contact with the outer and
inner races.
The geometries for all surfaces except the balls are meshed in this geometry. Only the six balls are
defined as primitive spheres.
Step 1: Loading the model in MotionView.

1. Copy the Ball_Bearing.mdl file, located in the mbd_modeling\contacts folder, to your

3. Open the Ball_Bearing.mdl model file from the <working directory>.
MotionView model for the ball bearing mechanism
The figure above shows the model as it is setup in MotionView. This model has all the necessary
contacts defined except for a few which you will setup next. The following table describes the
components present in this model.
Component name Component type Description
Ground Body Rigid body Ground Body
Outer Race Rigid body The outer bearing race body
Inner Race Rigid Body The inner bearing race body
Ball 1, , Ball 6 Rigid Body Ball bodies
Rim Rigid Body The rim body that keeps the balls in place
Ball1_inter, , Ball5_inter 3D rigid body Contact force element between the balls and
contact the Rim
Ball1_upper, , Ball5_upper 3D rigid body Contact force elements between the balls and
contact the Outer Race

Ball1_inter, , Ball5_inter 3D rigid body Contact force elements between the balls and
contact the Inner Race
Solver Units Data Set The solver units for this model. These are set
to Newton, Millimeter, Kilogram, Second
Gravity Data Set Gravity specified for this model. The gravity is
turned on and acts in the negative Z direction
Outer Race Graphic Graphic The graphic that represents the outer race
body. This is a tessellated graphic
Inner Race Graphic Graphic The graphic that represents the inner race
body. This is a tessellated graphic
Rim Graphic Graphic The graphic that represents the rim body. This
is a tessellated graphic
Ball 1 Primitive, , Ball 6 - Graphic The graphics that represent the ball bodies.
Primitive These are primitive geometries
Inner Race Rev Revolute Joint Revolute joint defined between the Inner Race
and Ground Body
Outer Race Fixed Fixed Joint Fixed joint defined between the Outer Race and
Ground Body
Input Motion to Inner Race Motion A motion defined on the Inner Race Rev joint
that actuates the mechanism

Step 2: Defining contact between the primitive and meshed geometries.
In this step, you will define contact between:
Ball 6 and the Outer Race

Ball 6 and the Rim
Ball 6 and the Inner Race
1. Add a new contact force entity by right-clicking on the Contact button in the Force Entity
toolbar:
2. For Label, enter Ball6_inter.
3. For Variable, enter con_ball6_inter.
4. Verify that RigidToRigidContact is selected in the drop-down menu and click OK.
The Contact panel is displayed.

5. From the Connectivity tab, resolve Body I to Ball 6 and Body J to Rim. This will automatically
select the graphics that are attached to these bodies.
6. To make sure that the geometries are well defined for contacts, the normals of the surface mesh
should be along the direction of contact and there should be no open edges or T-connections in
the geometries. To make sure the normals are oriented correctly, activate the Highlight contact
side box. This will color the geometries specified for this contact force according to the direction
of the surface normals. You should make sure both geometries are completely red i.e. there are
no blue patches for either geometry. To see this clearly, you may have to deactivate the Outer
Race graphic. This is illustrated in the figures below.
C hecking for incorrect surface normals
7. Next, you can check for open edges or T-connections. If the associated graphics mesh has any
open edges or T-connections, the Highlight mesh errors option would be active. Activate the
box for Highlight mesh errors if there are any mesh errors. Doing this will highlight any open edges
or T Connections in the geometry.
The graphics associated in this contact entity dont have mesh errors. Hence you should see
Highlight mesh errors grayed out.

8. Next, you need to specify the contact properties. To do this, click on the Properties tab to bring
up the Normal Force and the Friction Force property tabs within the Contact panel. In this
model you will use an Impact model with the following properties:
Normal Force Model Impact
Stiffness 500.0
Exponent 3.0
Damping 1.0
Penetration Depth 0.1
Friction Force Model Disabled
Specify the properties as defined above in the contact panel.
9. Repeat steps 1 3 for creating contact between the Ball 6 body and the Outer Race body and
also between the Ball 6 body and the Inner Race body. The details for these are listed in the
table below:
Label Ball6_outer Ball6_inner
Variable con_ball6_outer con_ball6_inner
Body I graphic Ball 6 Primitive Ball 6 Primitive
Body J graphic Outer Race Graphic Inner Race Graphic
Normal Force Model Impact Impact
Stiffness 1000.0 1000.0
Exponent 2.1 2.1
Damping 0.1 0.1
Penetration Depth 0.1 0.1

Friction Force Model Static and Dynamic Static and Dynamic
Mu Static 0.4 0.5
Mu Dynamic 0.2 0.3
Stiction transition velocity 1.0 1.0
Friction transition velocity 1.5 1.5
10. Save your model.
Step 3: Setting up a transient simulation and running the model.

At this point, you are ready to setup a transient analysis for this model.
1. To setup a transient analysis, navigate to the Run panel by clicking on the Run button in the
toolbar .
2. From the Run panel, change the Simulation type to Transient and specify an end time of 2.0
seconds.
3. Further, to obtain accurate results, you will need to specify a smaller step size than the default.
Click on the Simulation Settings button and navigate to the Transient tab.
4. Set the Maximum step size to 1e-5 and click Close.

5. Specify a name for your XML model and click the Run button. This will start the transient
simulation.
6. In the HyperWorks Solver View window that pops up, a message is displayed from the solver
that confirms that the semi-analytical contact method is being used for the contact calculations.
As you may have noticed, you did not have to explicitly specify the contact force method to be used.
MotionSolve automatically detects if one or both the bodies in contact are primitive spheres and
accordingly changes the contact force method being used.

Step 4: Post-processing the results.
After the simulation is complete, MotionSolve prints out a summary table (both on screen and in the
log file generated) that lists the top five contact pairs ordered by maximum penetration depth and by
maximum contact force for this simulation. This is very useful since it can be used to verify that the
model is behaving as intended even before loading the results (ABF, MRF, PLT or H3D) files. You can
also use this table to verify that the penetration depths and contact forces are within the intended
limits for your model. The summary table for this simulation is illustrated below:
1. Motionview makes available an automated report for model containing contacts. The report
automatically adds animation and plots to the session. The report can be accessed through
Analysis > View Reports menu option.
The View Reports dialog is displayed.

2. The report item, Contact Report, for the last submitted run will be listed at the top. Select that
item and click OK.
3. Additional pages are added to the report. Use the Page Navigation buttons (located
at the upper right corner of the window, below the menu bar area and above the graphics area)
to view these pages.
Contact Overview
MotionSolve writes out a static load case to the H3D file that can be used to view the maximum
penetration on all the geometry in contact throughout the length of the simulation. This enables you
to inspect your results to see where the maximum penetration depth occurred in your geometry/
geometries. You may hide one or more parts to view this clearly in the graphic area.
Note You may Fit the graphic area in case the graphics are not visible in the Graphics area.
1. From the Results browser select the components Ball 1 Primitive to Ball 6 Primitive.

2. Right-click and click Hide from the context menu.
3. Similarly, Hide the Rim graphic and Inner Race graphic in order to visualize the contours on the
Outer Race graphic.
C ontact overview for penetration depth

Animation Penetration Depth
1. Navigate to the next page , which shows a transient animation of the penetration depth.
2. You can visualize the contours individually on the components by isolating the components. For
example, to visualize the contours on the Inner Race graphic, select the component in the
Results browser, right-click and select Isolate from the context menu.
3. Click on Start/Pause Animation to view the animation.
Visualizing the Contact forces via force vectors
1. Navigate to the next page , which shows a transient animation of the contact forces.
2. Fit the model in the graphics area.
3. Select Transparent Element and Feature Lines from the toolbar options.
4. Go to the Vector panel.
5. Activate the Display tab and change the Size Scaling option to By Magnitude and use a value
of 5.

6. Click on Start/Pause Animation button to view the animation.
Animating the total contact force (the outer race graphic is turned off for better visualization)
Plotting Contact Forces
Note You may turn off curves from the Plot browser to look at individual force plots.
1. Each time a new contact entity is created in MotionView, a corresponding output force request is
created that can be used to plot the contact forces between the geometries specified in the
contact entity.
2. Go to the next page , which has a HyperGraph plot of all the contact force magnitudes.

Step 5: Comparing the run time with a model containing meshed spheres.
The semi-analytical (and fully analytical) contact method is more efficient than the 3D mesh-mesh
based contact. To illustrate this, you can run the same model you just created however instead of
using primitive spheres for the bearings, use a meshed representation. Such a model is already
available in your HyperWorks installation. Copy the model Ball_Bearing_meshed.mdl, located in the
mbd_modeling\contacts folder, to your <working directory>. Run this model from MotionView and
compare the analysis time to see the speedup. As an example, a comparison between the run times
for the two models is listed in the table below. Also listed are the machine specifications that were
used to generate this data.
Model Ball_Bearing.mdl Ball_Bearing_meshed.mdl
Contact Type Semi-analytical Mesh-Mesh
Number of processors used for 1 1

solution
Core Analysis Time (seconds) 177.4s 1342s
Total Elapsed Time (seconds) 180.4s 1344s
CPU Speed 2.4GHz 2.4GHz
Available RAM 57,784 MB 57,759 MB
CPU Type Intel Xeon E5-2620 Intel Xeon E5-2620
Platform Windows 7 Windows 7
As can be seen, for this model, a speedup of ~7x (1344/180.4) is achieved.
Summary
In this tutorial, you learned how to setup semi-analytical contact between a primitive spherical
geometry and a meshed geometry. Further, you were able to inspect the geometry to make sure the
surface normals were correct and there were no open edges or T connections.
You were also able to setup a transient analysis to calculate the contact forces between these
geometries and post-process the results via vector and contour plots, in addition to plotting the
contact force requests.
Finally, you were able to compare the analysis time between a fully meshed representation of the
spheres and the model that you created. A significant speedup was observed which makes the semi-
analytical contact method the first choice for solving 3D contact models when applicable.

MV-1020 Modeling 2D Rigid to Rigid Contact
Simulation
Create Curve Entities using File, Math and Values options

Create Curve Graphics using Marker and Body/Point option
Use macro to create Curve Entity and Curve Graphics simultaneously
Setup 2D rigid curve to curve contact
Introduction
This tutorial will guide you through the new 2D rigid body contact capabilities in MotionSolve which
can be used when contact occurs in a plane. In this tutorial, we will model a roller type cam-follower
mechanism with the help of 2D rigid to rigid contact as there are no out-of-plane contact forces that
are expected.
Exercise
Copy the files Cam_Follower_Input.mdl, CamProfile.h3d, Cam_Fixed.csv and Cam_Variable.csv
from the location
<installation_directory>\tutorials\mv_hv_hg\mbd_modeling\interactive\ to your <Working
directory>.

Step 1: Review the partially setup model.
A partially setup model is available for you to open in MotionView. Except the 2D contact, everything
else has been setup. Let us review the same by running the model using MotionSolve.
1. Launch MotionView.
2. From the HyperWorks-Standard toolbar, click the Open Model icon, .
Or
Open the model by selecting File > Open > Model.
3. From the Open model dialog, select the file Cam_Follower_Input.mdl from your working
directory and click Open.
Once the model is loaded it will look as it does below. Review the model for its bodies, graphics,
markers, joints and motion.
4. In the Run panel , click the Save and run current model browser button
5. Click the Run button. Once the simulation is completed, close the solver window and the
Message Log.

6. From the Run panel, review the results animation by clicking on Animate button.
Notice that the FollowerRoller is not in contact with the Cam since there is no contact defined in
the model.
7. Return to MotionView window using the Page Window Layout button located on the
HyperWorks Page Controls toolbar as shown below.
Step 2: Create Curve Entity and Curve Graphics for FollowerRoller.

Since the FollowerRoller profile is circular - it can be easily defined using mathematical expressions.
First, we will create a closed circular Curve Entity (using the Math option). Then, we will create Curve
Graphics to associate this Curve Entity with FollowerRoller body so that it can be later used in setup
the 2D Contact.
1. From the Project browser right-click on Model and select Add Reference Entity > Curve (or
right-click the Curves icon on the MotionView-Reference Entity toolbar).
The Add Curve dialog is displayed.

2. For Label, enter Roller_Curve. For Variable, enter crv_roller and click OK (as shown in the
image below).
3. From the Properties tab, use the first drop-down menu to change the curve from 2D Cartesian
to 3D Cartesian.
Note Only 3D Cartesian types of Curve Entities are supported for the Curve Graphics.
4. Use the fourth drop-down menu to change the curve from Open Curve to Closed Curve.
5. From the Properties tab, click on the x radio button. Select Math from the second drop-down
menu on the left. Enter 5*SIN(2*PI*(0:1:0.01)) in the Expression Builder and hit Enter on
the keyboard.
6. Similarly enter 5*COS(2*PI*(0:1:0.01)) and 0.0*(0:1:0.01) as Math expressions for y and z

coordinates of the curve respectively. The panel should now look as shown in the image below.
Note Now having created the Curve Entity, let us create a Curve Graphics to graphically represent
the FollowerRoller body on the screen and later use it to define 2D Contact.

7. From the Project browser right-click on Model and select Add Reference Entity > Graphic (or
right-click the Graphic icon on the MotionView-Reference Entity toolbar).
8. Choose Curve from the drop-down menu.
9. For Label, enter Roller_Curve. For Variable, enter gcrv_roller and click OK (as shown in the
image below).
Note The Body/Point option (Parent type) has been selected by default on the Connectivity
tab.
10. From the Connectivity tab, double-click on the Body collector .
Select FollowerRoller from the tree.
11. Now the Point collector is highlighted by default , click once on the same.
Select FollowerRevJoint from the tree.

12. Similarly choose Roller_Curve using the Curve collector . Leave the rest of the
options on the panel as default. The panel should look as shown in the image below.
Note Curve Graphics representing the FollowerRoller should now be graphically visible as shown
in the image below.
Note At this point we can deactivate (or delete) the original cylinder graphics used to represent
FollowerRoller.

13. To deactivate the FollowerRoller graphics from the Project browser; right-click on
FollowerRoller > Deactivate as shown in the image below.
Step 3: Create Curve Entity and Curve Graphics for Cam.

In the process of designing a cam, designers often like to determine the best shape of the cam in
order to achieve a specific displacement profile of the follower. To allow this, let us divide the cam
profile into two portions: Fixed and Variable, as show in the image below.
The variable portion of cam will be controlled by the coordinates of some points in our model.

Step 3a: Create fixed portion of Cam profile.
In this step we will learn how to use .csv File containing x,y and z coordinates of points to create a
Curve Entity.
1. Right-click the Curves icon to insert a new Curve Entity and provide Cam_Fixed_Curve for
the Label and crv_cam_fix for the Variable.
to 3D Cartesian.
3. Retain the default selection for the fourth drop-down menu to Open Curve.
4. From the Properties tab, click on the x radio button. Retain the default File option in the second
drop-down menu on the left.
5. Click on the file browser icon and select Cam_Fixed.csv from the working directory. Click
Open.
6. Select Column 1 for the Component. Retain all other options on the panel to its default values.
The panel should look like the image below:
7. Similarly click on the y radio button, the same file should be selected by default. This time, select
Column 2 for the Component.
8. Click on the z radio button, the same file should be selected by default. This time, select Column
3 for the Component.
Note Now, having created the Curve Entity, let us create a Curve Graphics to just graphically
visualize and make sure that the imported data is located as per our requirement.

9. Insert a new Curve Graphic by following Steps 7 - 13 of Step 2 of this tutorial with input details
as listed in the table below:
Variable Value
Label: Cam_Fixed_Curve
Variable: gcrv_cam_fix
Body: Cam
Origin Point: Global Origin
Curve: Cam_Fixed_Curve
Note Curve Graphics representing the fixed portion of Cam should now be graphically visible as
shown in the image below.

Step 3b: Create variable portion of Cam profile.
In this step we will learn how to use a macro to automatically create both Curve Entity and Curve
Graphics using existing points in the model.
Firstly, let us create some points in the model using Menu > Macros > Create Points > using
Coordinates.
1. From Main menu, click Macros > Create Points > using Coordinates (or click Create Points
using Coordinates button from the MotionView Toolbar > Point Macros toolbar).
The Parametric Points dialog box opens.

2. Click on the file browser icon and select Cam_Variable.csv from the working directory. Click
Open. Click OK to create 10 points (Point 0 to Point 9).
Note The image below shows the newly created points.
Note Now that we have fixed portion Curve Graphics representing Cam, we can deactivate (or
delete) the original H3D file graphics used to represent Cam.

3. To deactivate the Cam graphics, from the Project browser; right-click on Cam > Deactivate as
Now let us use the newly created points to create the variable portion of the cam profile using the
Create Curve from Points/Nodes macro.
4. From the Main menu, click Macros > Create Curve from Points/Nodes (or click the Create
Curve from Points/Nodes macro button from the MotionView toolbar > Point Macros
toolbar).
5. Double-click the Body collector and select the Cam body.
6. Edit the Labels prefix for the new Curve Entity as well as the Curve Graphics to be created to
Cam_Variable_Curve.

7. Now, the Point/Node collector will be highlighted by default .
You can graphically pick Point 0 from the screen
OR
Click once on the Point/Node collector.
Double-click on Point 0 from the filtered list of points.
Note The selected Point 0 is highlighted in the graphics screen and also listed in the panel.
8. Now repeat the above step to pick all the points from Point 1 to Point 9.
The panel should look like the image shown below.
Note A node associated with File graphic H3D can also be picked. However, the curve created
would not be parametrically linked with the node. Picking a point retains the parametric
relation between the point and the curve.
9. Click the Create button.
A new Curve Entity and a new Curve Graphics (Cam_Variable_Curve) has been added to the
model as shown in the image below.

Note The newly created Curve Graphics representing the variable portion of Cam should now
be graphically visible as shown below.
Note Review the newly created Curve Entity by selecting it from the model tree as shown in
the image below. Notice (by clicking as shown in the image below) how the X, Y and Z
values in the panel are parametrically pointing to the points selected while using the
macro. Thus, by changing the coordinates of these Points in the model, the curve can be
modified.
Step 3c: Create merged curve of Cam profile for 2D Contact.

The fixed and variable Curve Graphics of Cam generated in Step 3a and Step 3b cannot be used in
setting up contact since they are using open Curve Entities. We generated these in order to verify if
the curve data is in the correct location. For a continuous contact between FollowerRoller and Cam,
we need closed curves. Thus, in this step we will merge both fixed and variable portions of Cam and
create a new closed curve to setup the 2D Contact. In the process, we will learn how to use a
mathematical function (CAT) to concatenate two Curve Entities.

1. Insert a new Curve Entity by following Steps 1 - 4 of Step 2 of this tutorial with input details as
listed in the table below:
Variable Value
Label: Cam_Curve
Variable: crv_cam
Curve Type: 3D Cartesian
Open/Closed: Closed
2. From the Properties tab, click on the x radio button. Select Math from the second drop-down
menu on the left. Enter {CAT(crv_cam_fix.x, crv_0.x)} in the Expression Builder and hit
Enter on the keyboard.
3. Similarly enter {CAT(crv_cam_fix.y, crv_0.y)} and {CAT(crv_cam_fix.z, crv_0.z)} as

Math expressions for y and z coordinates of the curve respectively.
Note By using CAT function, we are able to append the data-points of variable portion of cam
to the data-points of fixed portion of cam. The panel should display merged data of both
fixed and variable portions of cam profile as shown in the image below.
Note Now having created the Curve Entity, let us create Curve Graphics to graphically represent the
Cam body on the screen and later use it to define 2D Contact.
4. From the Project browser right-click on Model and select Add Reference Entity > Graphic (or
right-click the Graphic icon on the MotionView-Reference Entity toolbar).
5. Choose Curve from the drop-down menu.
6. For Label, enter Cam_Curve. For Variable, enter gcrv_cam and click OK.
Note The Body/Point option (Parent type) has been selected by default on the Connectivity tab.
This time, let us use the Marker option since we already have a CamMarker in the model which
is associated with Cam (Body) and PivotPoint (Point).
7. From the Connectivity tab, select the drop-down menu of Parent and change it to Marker.
8. Now, double-click on the Marker collector.
The Select a Marker dialog is displayed.
Select CamMarker from the tree and click OK.

9. Now the Curve collector is highlighted by default, click once on the same.
The Select a Curve dialog is displayed.
Double-click on Cam_Curve from the list of filtered curves.
Note The panel should now look like shown in the image below.
Note Curve Graphics representing the Cam should now be graphically visible on screen as

Step 4: Set up 2D Contact.
In this step we will define a contact between Cam and FollowerRoller using their respective Curve
Graphics.
1. Right-click on the Contact button in the Force Entity toolbar.
2. For Label, enter 2D Contact 0 and retain the default Variable.
3. Change the contact Type to 2D Rigid to Rigid and click OK.

4. From the Connectivity tab, click the Body I collector once to activate it and then select the
Cam body from the screen by picking its Curve Graphics as shown in the image below.
5. Next, the Body J collector will be highlighted automatically. Click once and select the
FollowerRoller body from the Select a Body dialog box.
Note The Contact panel should be displayed as shown below.
Note Fixed and Variable Curve Graphics are selected by default since they are associated with
Cam body. Let us remove the same from the contact definition as they are not required.
6. Uncheck (or deselect) Cam_Fixed_Curve and Cam_Variable_Curve from the list of Curves
under Body I.

Now, let us review the side of selected curves that will be in contact.
7. Click the Highlight contact side check box.
Note The arrow display indicates the inside of Cam and FollowerRoller as contacting side. This
needs to be corrected.
8. Click the Flip Contact Side check box for both Body I and Body J curves.
Note The highlighted contact side for both the bodies should now be as shown in the image
below.
9. Review the Properties tab, the default selections are fine for the model.
10. Review the Advanced tab, turn on the Find precise contact event and Change simulation
max step size options with its default values.

Step 5: Save and Run the model.
1. Click Save As > Model using the option located in the File menu.
2. From the Save As Model dialog, browse to your working directory and specify the File name: as
Cam_Follower.mdl.
At this point, you are ready to run your model. We expect a lot quicker run using 2D curve contact as
compared to an equivalent model using 3D contact where the solver has to work harder to determine
contact for a 3D tessellated geometry.

3. Navigate to the Run panel by clicking on the Run button in the toolbar .
Note To obtain accurate results, a smaller step size and a finer print interval have been
selected in this model. You can review the same by checking Simulation Settings
button.
4. Specify a new name for your results by clicking on file browser icon Cam_Follower.xml and
click the Save button as shown in the image below.
5. Click the Run button.
Step 6: Post-processing the results

After the simulation is complete, MotionSolve prints out a summary table like for 3D contact (both on
screen-solver view window and in the log file generated) that lists the contact pairs ordered by
maximum penetration depth and by maximum contact force for this simulation. The image below is an
illustration of the same.
1. Click on the Animate button to review the graphical animation in HyperView.

2. Review contact force graphically in HyperView by selecting Vector plot, then choosing the Result
type to be Contact Force, click Apply and Start as shown in the image below.
Note You can even plot the graph of FollowerShaft vertical displacement during the entire simulation
using HyperGraph. To do the same, follow the steps mentioned below.
3. In the MotionView window, from the Run panel click the Plot button.
Note This should open .abf file in HyperGraph.

4. Use the Build Plot tool and for Y Type (Axis) select Body, FollowerShaft, Y , and click
Apply as shown in the image below.
Further Optional Exercise

Edit the coordinates of any/all points (Point 0 to Point 9) to get updated Cam profile and re-run the
model to investigate its effect on Contact Force on Cam or FollowerShaft Displacement.

Flexible Body Modeling and Simulation
using MotionView and MotionSolve
MV-2010: Flexbody Generation using Flexprep and Optistruct
MV-2021: Simulating an Automotive Door Closure Event

Why Flexible Bodies?

Traditional multi-body dynamic (MBD) analyses involve the simulation of rigid body systems
under the application of forces and/or motions.
In the real world, any continuous medium deforms under the application of force. Rigid body
simulations do not capture such deformations and this may lead to inaccurate results. Inclusion
of flexible bodies in MBD simulations accounts for flexibility.
MotionView provides the modeling tools required to incorporate flexible bodies in your MBD model.
Flexible MBD simulations allow you to:
capture body deformation effects in simulations.

acquire greater accuracy in load predictions.
study stress distribution in the flexible body.
perform fatigue analysis.
However, flexible bodies introduce an additional set of equations in the system and consequently,
have a higher computational cost as compared to rigid body systems.
What is a Flexible Body?

Finite element models have very high number of degrees of freedom. It is hard for MBD solvers
to handle these.
A flexible body is a modal representation of a finite element model. The finite element model is
reduced to very few modal degrees of freedom.
The nodal displacement in physical coordinates is represented as a linear combination of a small
number of modal coordinates.
where:
U nodal displacements vector
modal matrix
Q matrix of modal participation factors or modal coordinates to be

determined by the MBD analysis.
MotionView uses the process of Component Mode Synthesis(CMS) to reduce a finite

element model to set of orthogonal mode shapes.

Two types of CMS methods are supported in Optistruct:
Craig Bampton
Craig Chang
Note At the end of this tutorial, links to online help direct you to where you can learn more about
the theory behind flexible bodies and CMS method.
Flexbody Generation Using Optistruct
There are two ways you can generate flexible bodies using Optistruct:
1. Using the FlexPrep utility in MotionView.
2. Manually editing the input deck.
Using the FlexPrep Utility in the MotionView Interface
FlexPrep is a MotionView utility which allows you to generate a flexible body from a finite element
mesh. It also allows translation between various flexbody formats. These translations are
discussed in the next section, "Flexbody Translation Using Flexprep".

Using the FlexPrep GUI, you can:
generate a flexible body from any Optistruct or Nastran bulk data file.
create RBE2 spiders.
request for stresses and strains.

create Optistruct preparation file which can be used in the file size reduction of a flexible
body.
Manually Editing the Input Deck
You can manually insert certain cards in the Optistruct input deck to run the Component Mode
Synthesis routine. These cards allow file size reduction of a flexbody. This helps in faster pre/
post-processing and overall better efficiency of the process.
Note You can manually edit the preparation file generated by FlexPrep to reduce the size of
the flexible body H3D.
By modifying the input deck, you can:
request only the skin elements of the flexbody to display .

request stress and strain information for a selected set of elements.
use released degrees of freedom for the interface nodes.
The following data is included in a flexbody H3D file:
1. Nodal positions. 7. Translational displacement mode shapes.
2. Element connectivity. 8. Rotational displacement mode shapes.
3. Eigenvalues of all modes. 9. Interface node IDs (optional).
4. Inertia invariants (optional). 10. Element stress/strain tensors (optional).
5. Nodal mass. 11. Global (rigid) inertia properties (optional).
6. Nodal inertia (optional).
Flexprep.exe always generates points 1, 2, 3, 4, 5, 6, 7, 8, 9, and 11 and writes them to the

H3D file. Points 4, 6, 9, and 11 are not strictly required.
Flexbody Translation Using FlexPrep

FlexPrep allows you to translate a flexbody from one format to another. Using FlexPrep, you can:
1. Mirror an existing flexible body H3D file about a plane.
2. Translate an ADAMS MNF file to an Altair H3D file.
3. Translate an H3D file to an ADAMS MTX file.
4. Translate an Altair H3D file to ADAMS MNF file.

5. Translate an Nastran PCH file to an Altair H3D file.
6. Translate an Altair H3D file to DADS DFD file.
Note Once the flexbody H3D is created, it can be used in the MBD model and the model can be
submitted to either MotionSolve or ADAMS. This is covered in the following tutorials.
Stress Recovery and Fatigue Calculations
Stress recovery and fatigue calculations are done in two stages during the MBD analysis:
For stress recovery in the pre-processing stage, element stresses are obtained using the
orthogonalized displacement modes. Every displacement mode is associated with a particular
number of stress modes, each representing a basic stress tensor. This particular number
depends on the type of elements used in the flexible body, for example, one, two, or three-
dimensional elements. These stress modes are then saved to the H3D file.
In the post-processing stage, the actual stress recovery and fatigue index calculations are
carried out. The modal participation factors obtained from the simulation are used to linearly
superimpose the stress modes to come up with the stress tensor for each element. This stress
tensor is used to calculate the other components of stresses: Principal, Shear, or von Mises.

MV-2010: Flexbody Generation using Flex Prep and
Optistruct
In this tutorial you will:
get familiar with the flexible body generation techniques available in MotionView and Optistruct.
be introduced to all available features in FlexBodyPrep for flexbody generation.
be introduced to the various options available in Optistruct to reduce the size of the H3D file.
There are two ways you can generate the flexible bodies for MBD simulation in Hyperworks:
1. Using FlexPrep utility in MotionView interface.
2. Manually editing the input deck (*.fem) for Optistruct solver.
Introduction to Flex Prep

Flex Prep is a tool in MotionView which is used to:
create flexbody H3D files using Optistruct.

create flexbody H3D file from ADAMS MNF and NASTRAN PCH.
translate flexbody H3D file to ADAMS MTX, Altair H3D (mirrored), ADAMS MNF, DADS FDF, and
nCode FES.
Exercise: Creating and Simulating Flexible LCA

In this exercise, you will generate a flexible body for a left Lower Control Arm of a front SLA
suspension. The input file is a pre-prepared .fem file (sla_flex_left.fem) which has finite element
modeling information for the LCA (elements and nodes). Interface nodes for the flexible body are:
the center nodes at the front and rear bushing mounts

location where the spring is attached
the center of the lower ball joint attaching to the knuckle.
In the given input file, interface nodes are already created at the center of the bushing mounts and
the spring attachment location. You will create the interface node at the lower ball joint and its
connection to the LCA in the exercise.
Step 1: Using FlexBodyPrep.

Once you provide the required input, Flex Prep generates an input deck (_prp.fem) for the Optistruct
solver with all the required cards, and then it calls Optistruct to run the job. Please refer to tutorial
MV-2000 to understand all the inputs and process.
Note Copy the sla_flex_left.fem file, located in the mbd_modeling\flexbodies folder, to your
working directory before proceeding further.
1. Open a new MotionView session.

2. From the Flex Tools menu, select Flex Prep.
Launching Flex Prep
2. Select Optistruct Flexbody generation.
3. From the pull down menu, pick the option Create Optistruct prp (preparation) file and
generate the h3d flexbody.
4. Click on the file browser icon, , next to Select Bulk Data file and select the input bulk data
file sla_flex_left.fem from your working directory.
Note You can use any Optistruct (FEM) or Nastran (nas, dat, bdf) bulk data files.
5. For Save the *.h3d file as, enter the name of the output H3D file as sla_flex_left.h3d in
your <working directory>.
6. For the Component mode synthesis type, select Craig-Bampton to perform Craig-Bampton
component mode synthesis.
7. In the Specify Interface Node List field, enter 10001+10002+10003.
Note If the interface node IDs are within a range, you can specify as 10001:10003.
The interface nodes are the nodes where constraints or forces are applied in the MBD analysis.
8. For the Cutoff type and value, select Highest Mode # and enter a value of 10.
Limiting Modal Information
MotionView allows you to specify a limit on the modal information contained in your H3D file. Two
methods are available to set these limits.
Specify a maximum number of Eigen modes for which modal data is included in your H3D file.
OR
Specify an upper cut-off frequency for the Eigen modes. When a cut-off frequency is specified,
normal modes analysis can be performed using one of two algorithms: Lanczos or the
automated multi-level sub-structuring eigenvalue solution, AMSES.
We used the first method in this exercise.
a) Click Additional Options to bring up the dialog.
o Activate Perform stress recovery
With this option set, Flex Prep puts relevant cards in the OptiStruct input deck to calculate the
modal stresses while processing your bulk data file.
o Activate Perform strain recovery

With this option set, Flex Prep puts relevant cards in the Optistruct input deck to calculate the
modal strains while processing your bulk data file.
Note The Create Recovery H3D option is useful in fatigue analysis. A smaller flex H3D file is
generated that contains the minimum amount of information required for MBD simulation
in MotionSolve. A larger file, *_recov.h3d, is also generated that contains additional
information for displacement, velocity, acceleration, stress, and strain. Refer to
Recovering MBD Analysis Results in OptiStruct to learn more about using this method
for fatigue analysis.
FlexPrep utility with data
11. Under Specify units in bulk data file, select the following:
Mass Units Kilogram
Length Millimeter
Force Newton
Time Second
Note HyperMesh is unit-less and you need to make sure to use consistent units, or the
flexbody generated will have incorrect modal frequencies. In the given input file, the
density used is in unit kg/mm^3. Hence, you will use kilogram as the mass unit in this
exercise.

Generally, FE analysts using mm-N-sec as Length, Force and Time units need to specify mass as a
derived unit as N-sec^2/mm (equivalent to tonne/mm^3/MEGAGRAMS). If the model that you
use in the future may have such units, use MEGAGRAMS for the mass units in FlexBodyPrep.
12. There are three RBE2 spiders already in sla_flex_left.fem. The fourth RBE2 spider should be
created using the Create RBE2 Spiders option explained in the next step.
Step 2: Create RBE2 Spiders.

If you have a circular hole in your finite element (FE) model and need to use the center of the hole as
the interface node, you need to transfer the loads from the center node to the peripheral nodes. This
feature allows to you create RBE2 spiders at the hole in the FE model to transfer forces from the
interface node to peripheral nodes of the hole.
Note: If the finite element model definition is complete (all interface nodes and connections already
exist), this step is not required.
Description of an RBE2 Spider
An RBE2 is a rigid element whose independent degrees of freedom are specified at a single grid point
and whose dependent degrees of freedom are specified at an arbitrary number of grid points. This is
usually used to model relatively stiff connections.
1. Click the Create RBE2 Spider button.
2. HyperMesh is invoked. The input file, sla_flex_left.fem, is imported into HyperMesh and the
FE model is displayed in the graphics area of the screen.
Note If HyperMesh asks for a user profile, click Cancel and go to the utility panel in the
Browser area.
The Tab area displays a Utility tab with a user-defined page with three buttons (steps 1 to 3).
Note If the user defined page with the three buttons is not displayed, follow these steps to
view it:
From the View menu, select the Utility Menu.
From the Utility menu, click the User button, located at the bottom of the page.

3. The Info button details the procedure to create RBE2 spiders.
4. Zoom into the area of the lower ball joint location as shown in the image below:
5. Click the Step 2: Superspider to create one spider at a time.
6. Select a node on the periphery of the hole and click Proceed.

7. The script would create a RBE2 Spider automatically as shown in image below:
8. Click the Step 3: Save and Close, which will save the modified file and automatically grab the ID
of the center (interface) node. Give a new name to the file sla_flex_left_complete.fem and
check to see if the interface node ID is added to the flex prep.

9. The new interface node IDs are automatically added to the interface node list in FlexBodyPrep as
displayed in the image below:
10. Click OK to launch Optistruct in a command window.
Based on the inputs provided here, FlexBodyPrep creates a new FEM file by appending _prp to the
input filename and submits it to Optistruct. In this case, sla_flex_left_complete_prp.fem is
created.
Messages from the FlexBodyPrep translator are displayed in the Output window. Check the
status of the Optistruct run and look for any error messages there.
11. Click OK in the Output window to close.
Step 3: Viewing the model and verifying results.

In this exercise, you will verify your work in Step 1 by viewing the flexible control arm in HyperView.
1. From Select window mode drop-down menu on the toolbar, select HyperView.
The Load model and results: panel is displayed.

2. Click the Load model file browser and select the H3D flex file, <working directory>/
sla_flex_left.h3d.
The flexible arm model and its modal results are contained in the H3D flex file you created using
the Flexprep wizard.
Load model and results fields
HyperView automatically updates the Load results file field with the same filename.
3. Click Apply to load the model into the HyperView.
Flexible LC A Model

4. Click the Select animation mode arrow and select Set Transient Animation Mode, .
5. Animate the results by clicking the Start Animation icon, .
HyperView sequentially animates the flexible control arm through its mode shapes. The mode
number and its frequency are displayed at the top-right of the window.
6. Stop the cycling of modes by clicking the Pause Animation icon , .
7. Click the Select animation mode arrow and from the drop-down list, select Set Modal
Animation Mode.
8. To animate a particular mode shape, go to the Results Browser and change the mode from
Undeformed Model Frame to Mode 7.
Selecting specific mode using the Simulation selector panel

Note Although there is not a direct correlation possible, you can recognize the first six modes
as rigid body modes due to near zero frequency values. If there are more than six modes
that are near zero, it generally indicates a model integrity problem (one or more elements
are free and not connected to other elements).
9. Click the Animation icon, , to animate the selected mode.
Toggle the animation on and off by clicking the button.
You can similarly animate other modes of the flexible body.
10. Click the Contour button, , to view the stresses on the flexbody.
11. From the Result type drop-down menu, select Stress and vonMises. For Entity with layers,
select Z1 as shown in image below:

12. Click Apply to display the contours and the legend in the graphic area.
vonMises Stress contours displayed on the model
The above exercise demonstrated generating a flexible body using MotionView. Flexible bodies
can also be generated by using Hypermesh and Optistruct. To learn more, you can refer to
tutorial OS-1930 - Generating a Flexible Body for use in Altair MotionSolve.
Step 4: Invoking FlexPrep in batch mode.

The FlexPrep executable can also be invoked in batch mode.
To run the FlexPrep from the command line in LINUX or Mac:

<install_path>/altair/scripts/flexprep
To run the FlexPrep from the command line in DOS:
<install_path>\io\translators\bin\<os>\flexprep.exe (where <os> is either win32 or win64).

The usage options and corresponding syntax is listed if the above command is given without any
arguments.
The sla_flex_left.h3d flexbody created in the earlier exercise is the lower control arm of a left
front SLA suspension. Now, we will create a symmetric flexible body for the right front SLA suspension
by invoking flex prep in batch mode.
Note In this exercise, you will run the FlexPrep translator from the MS DOS prompt for the Windows
Operating System. You may follow analogous steps for the Linux/Mac OS terminal.
1. From the Start menu, open an MS DOS prompt window.
2. Use the cd command to navigate to your working directory.
3. Enter the command to launch FlexPrep <install_path>\translators\flexprep.exe.
4. Go through the usage options for running the FlexPrep translator in batch mode.
5. Enter the following command:

<install_path>\io\translators\bin\<os>\flexprep.exe sla_flex_left.h3d
sla_flex_right.h3d -MIRROR_XZ
6. FlexPrep creates the mirrored lower control arm sla_flex_right.h3d flexbody file.
Exercise: Manual Methods to Reduce the Size of the Flexbody

The previous exercise discussed flexbody generation using FlexPrep. It is possible to generate
flexbodies directly from Optistruct by editing the input FEM file and adding the cards that invoke the
flexbody generation from Optistruct. Steps 1 to 4 below discuss these cards in brief.
Understanding the Optistruct input file for flexbody generation

1. Open the file sla_flex_left_complete_prp.fem in any text editor.
2. The first few lines of the FEM file are given below with explanation for each line:
Line 1: SUBCASE 1
Line 2: OUTFILE, sla_flex_left
Line 3: CMSMETH 1
Line 4: STRESS=ALL
Line 5: STRAIN=ALL
Line 6: BEGIN BULK
Line 7: DTI, UNITS, 1, KG, N, MM, S
Line 8: PARAM COUPMASS -1
Line 9: PARAM CHECKEL YES
Line 10: CMSMETH, 1, CB, , 10
Line 11: ASET1, 123456, 10001

Line 12: ASET1, 123456, 10002
Line 13: ASET1, 123456, 10003
Line 14: ASET1, 123456, 10004
SET DATA FOLLOWS
BULK DATA FOLLOWS
A generalized input deck (FEM file) need the cards specified above to generate a flexbody from
Optistruct. The definition of each line is as follows:
Line 1: SUBCASE indicates the start of a new subcase definition.
Line 2: OUTFILE used to specify a base name for the H3D file.
Line 3: CMSMETH is the card defining the component mode synthesis solution method used to
generate flexbodies in Optistruct.
Line 4: STRESS=ALL use to specify that modal stresses are to be computed by Optistruct for all
the elements in the model.
Line 5: STRAIN=ALL use to specify that modal strain values are to be computed by Optistruct
for all the elements in the model.
Line 6: BEGIN BULK defines the start of FE entities in the model.
Line 7: DTI, UNITS defines the units for the flexbody.
Line 8: PARAM COUPMASS -1 defines values for parameters used by Optistruct for the
generation of a flexbody. In this case, lumped mass matrix approach is used by Optistruct for
eigenvalue analysis.
Line 9: PARAM CHECKEL YES parameter to perform element quality check before running the job.
Specifying NO makes the solver skip the element check. Elements with poor quality may lead to
inaccurate results.
Line 10: CMSMETH CB 10 component mode synthesis method selected is Craig Brampton and 10
modes are requested.
Lines 11 to 14: ASET1 defines the boundary degrees of freedom for the interface nodes.
With these cards specified, Optistruct generates a flexbody H3D file. The flexbody size can be
large based on the bulk data file, number of interface nodes, and modes and stress/strain details.
It is possible to reduce the size by using any of following methods:
MODEL Set Reduces the model information that is used for graphical display.
STRESS/STRAIN Set Reduces the number of elements on which stress or strain
calculation is requested.
OUTLINE Reduces the model information to display only boundary edges.
Reduced DOF Reduces the number of DOF that contribute to the flexible body information.
Modifying the Input Deck to Incorporate Stress/Strain Set, Model Set, Outline
and Released DOF into the Flexbody
In finite element modeling, nodes or elements can be grouped together to form a SET. These groups
can then be used in other modeling cards that can take the nodes and elements as inputs collectively.

In flexible body generation, the need to incorporate these sets in the Optistruct input deck is:
to reduce the size of the flexbody.

to help increase the speed of the multi-body pre-processing, simulation and animation.
Step 1: Stress/strain set in Optistruct.

The cards STRESS and STRAIN specify the elements for which the stress and strain computations
have to be carried out during flexbody generation. Use this card if you are interested in viewing
stress results for the body in your analysis. If the objective of using a flexible body is to incorporate
the flexibility of the body and not calculate stresses, then not using this card drastically reduces the
size of the H3D.
Syntax of the STRESS and STRAIN cards:
STRESS=[setid|ALL|NONE]
STRAIN=[setid|ALL]
setid is the ID of the set of elements.
Alternatively, if ALL is specified, the stress/strain is calculated for all elements.
If NONE is specified, the stress is not calculated on any elements. (Not having the STRESS card has
the same effect).
In the FEM file that is opened, you can observe SET cards defined for nodes (keyword GRID) and
elements (keyword ELEM).
1. Modify the cards STRESS=ALL and STRAIN=ALL as STRESS=5 and STRAIN=5, respectively.
2. Modify the OUTFILE to read as OUTFILE, sla_flex_left_stress_set.
3. Save the file as sla_flex_left_stress_set.fem and close the file.
4. Generate the flexbody using FlexBodyPrep. From the Optistruct Flexbody Generation drop-
down menu, select the option Create h3d flexbody using pre-existing prp file.
Note You can use Optistruct to generate the flexbody. To run Optistruct from the command
prompt, type the following the working directory: <install>\hwsolvers\bin\win32
\Optistruct.bat sla_left_stress_strain_set.fem.
5. Start a new MotionView session and change the window type to HyperView.
6. Load in the H3D file sla_flex_left_stress_set.h3d generated by Optistruct.
7. Go to the Contour panel to apply Stress and Strain contours. You will see that only a few
elements display the contours. These are the elements that were pre-selected for stress and
strain computations using the element set.
Step 2: Model Set in Optistruct.

This card lets you control the display of elements of the flexbody in the H3D file while using the H3D
file during pre- and post-processing in MotionView.
Syntax of the MODEL card:

MODEL=setid|PLOTEL
Where MODEL is the Optistruct card that determines the elements to be written to the result file
(H3D). setid is the ID of set that defines the element displayed.
The PLOTEL option will be discussed further in this tutorial
1. Open the FEM input deck sla_flex_left_stress_set.fem in a text editor.
2. Add the model card as MODEL=4 above the line STRESS=5.
3. Change the OUTFILE line to read as OUTFILE, sla_flex_left_model_set.
4. Save the file sla_flex_left_model_set.fem to your working directory and close the file.
5. Run the FEM deck in Optistruct or you generate the flexbody using FlexBodyPrep. From the
Optistruct Flexbody Generation drop-down menu, select the option Create h3d flexbody
using pre-existing prp file.
6. In HyperView, load the H3D file generated by Optistruct.
You will see that only a part of the flexbody is displayed. Only those elements included in the set
that is used with the MODEL card are displayed here.
Step 3: Outline feature using PLOTEL elements in Optistruct.

The size of the flexbody can be greatly reduced by using PLOTEL elements in the Optistruct input
deck for flexbody generation. In case you would like only the edges of the flexbody to be displayed in
MotionView, PLOTEL elements can be defined in the input deck and displayed using the MODEL card.
PLOTEL is a one-dimensional dummy element for use in display. This element does not contribute any
mass or stiffness to the part.
Syntax of the PLOTEL element:
PLOTEL EID G1 G2
Where PLOTEL is the element type, EID is the element ID, G1 and G2 are the nodes used to define the
element. For example: PLOTEL 8786 4698 1702
The FEM file that you are working with already contain PLOTEL elements.
The procedure to incorporate the PLOTEL feature is briefly explained here:
You can use the features option in HyperMesh to generate the PLOTEL elements of the
feature edges of your model automatically. The features option is available on the Tool page
in HyperMesh.

The picture below shows a flexbody model with PLOTEL elements created with the features
option:
Use the MODEL card and specify the PLOTEL option.

MODEL=PLOTEL (to skip writing rigid elements like RBE2 as part of plotel, use optional keyword
NORIGID)
Save the FEM file and run it in Optistruct to generate the flexbody that displays only the
PLOTEL elements.
1. Open the FEM deck sla_flex_left_model_set.fem, saved earlier in your working directory.
2. Replace the MODEL=4 by MODEL=PLOTEL.
Within the BULK DATA, you will be able to see the many PLOTEL elements.
3. Change the OUTFILE line to read as OUTFILE, sla_flex_left_plotel_set.
4. Save the file as sla_flex_left_plotel_set.fem.
5. Run the FEM deck in Optistruct or you can generate the flexbody from FlexPrep. From the
Optistruct Flexbody Generation drop-down menu, select the option Create h3d flexbody
using pre-existing prp file.
6. In HyperView, load the H3D file generated by Optistruct.
You will see that the flexbody is shown only as lines or edges defined by the PLOTEL elements
Step 4: Released DOF method for interface nodes in Optistruct.

The released DOF (degrees of freedom) feature enables you to free some degrees of freedom of the
interface nodes. If the appropriate DOF (corresponding DOF that are free in the MBD model) are
released for a particular interface node, the simulation is not affected in any way. Depending on the
kind of kinematic constraints in the model and the MBD simulation being carried out, you can release
the appropriate degrees of freedom at the interface nodes to reduce the size of the H3D file
generated.
The ASET1 card is used define the boundary degrees of freedom of an interface node of a flexbody.
Syntax of the ASET1 card:

ASET1 C G1 or ASET1, C, G1
Where ASET1 is the card name, C is the DOF to be constrained, and G1 is the node ID. For example:
ASET1, 123456, 4927
This means that the interface node of ID 4927 will be constrained for all DOF, where 123456
represents the three translational and three rotational nodes in that order. Thus, to release a DOF
from the interface node (for example, rotation about X), the C value will be 12356.
1. Modify the ASET1 card corresponding to interface node 10004 in the deck as follows:
ASET1, 123, 10004
2. Change OUTFILE to read as OUTFILE, sla_flex_left_rdof.
3. Save the file in your working directory as sla_flex_left_rdof.fem and close the file.
4. Run the FEM deck in Optistruct or generate the flexbody from FlexPrep. From the Optistruct
Flexbody generation drop-down menu, select the option Create h3d flexbody using pre-
existing prp file.
5. Check the size of the H3D file generated and you will notice a reduction in size; this is due to the
released DOF incorporated into the flexbody.
Compare the sizes of all the H3D files generated using the cards mentioned in this step to know
the reduction in file size.

use the flexible bodies created in tutorial MV-2010 in an MBD model and solve the model using
MotionSolve.
Exercise: Simulating a Front SLA suspension with Flexible

LCA
Step 1: Replacing rigid bodies with flexible bodies and solving them in
MotionSolve.
In this exercise, you will integrate the flexbodies into your MBD model.
1. From the MotionView menu bar, select Model > Assembly Wizard to bring up the wizard.
2. Use the criteria from the table below to assemble a front end half vehicle model.
Panel Selection
Model Type Front-end of the vehicle
Driveline Configuration Defaults <No driveline>
Primary Systems Front Suspension = Frnt. SLA susp (1 pc LCA)

and defaults for the rest
Steering Subsystems Steering Column = Steering column 1 (not for

abaqus) and Steering boost = None
Springs, Dampers, and Stabars Defaults
Jounce/Rebound Bumpers Defaults
Label and Varname Defaults
Attachment Wizard Compliant = Yes; Defaults for the rest
Assembly Wizard settings
You should make sure to select Frnt. SLA susp (1 pc LCA) since the flexible bodies you have
created are for this suspension geometry.
3. From the MotionView menu bar, select Analysis >Task Wizard to display the wizard.
4. Load a Static Ride Analysis task from the Task Wizard - Front end tasks. Click Next and click
Finish.
5. The Vehicle Parameters form is displayed. Click Finish.

6. From the Project Browser, select Lwr control arm from the Bodies folder (located underneath
the FrntSLA Susp (1 pc.LCA) system).
The Bodies panel is displayed.
7. Under the Properties tab for the Lwr control arm-left, deselect the symmetry check-box,
Symmetric properties.
8. The Remove Symmetry confirmation dialog is displayed. Click Retain to retain the current
values of properties of Lwr control arm-right.
9. Select the Flex Body (CMS) check box and click Yes to confirm both sides as deformable.
Notice that the graphics of the rigid body lower control arm vanishes.
10. Using the Graphic file browser, , select the file sla_flex_left.h3d (created in earlier tutorial
MV-2010) from your working directory.
11. You will see that the H3D file field is populated automatically with the same path and the file
name as the graphic file you specified in point 10.
Properties panel
The flexible body drops into the right position.
Note You need to specify the flexbody H3D file as the H3D file. Specify the same or any other
file as the Graphic file.
External Graphics for Flexbodies
Use of large flexbodies is becoming very common. For faster pre-processing, you can use any graphic
file for the display and use the flexbody H3D file to provide the data to the solver. You can use the
input FEM deck or the CAD file used for the flexbody generation to generate a graphic H3D file using
the CAD to H3D Conversion and specify that file as the Graphic file. This will make pre-processing
a much more efficient process.

Locate Feature
The Locate button on this panel is an optional step to relocate a flexible body if it is not imported in
the desired position. This may happen if the coordinate system used while creating the flexible body
in the original FEM model does not match the MBD model coordinate system. However, if your flexible
body is already in the desired position, you can skip this step.
12. Click Nodes .
The Nodes panel is displayed.
The Nodes panel is used to resolve the flexbodys attachments with the vehicle model, since the
vehicle model is attached to the flexible body at these interface nodes.
This panel lists all markers of the connections (joints/forces)on the body which is now flexible.
These markers can interact with the flexible body only through a node. This panel is used to map
each of the markers to a node. The panel also displays the point coordinates of the marker origin
which are nothing but coordinates of a point entity that the connections are referring to.
13. Click the Find All button on the Nodes dialog to find nodes on the flexible body that are located
closest to the interface points on the vehicle model. Node ID column is populated with the
interface node numbers for each row of connections. Also, the node coordinate table is also
populated along with the Offset with respect to the point coordinates.
14. Observe a small offset for the Lwr ball jt-Marker J-left. It suggests a difference in the
coordinate values between the point at which the joint Lwr ball jt is defined and its
corresponding location of the interface node 10004. Click Align to move the point to the nodal
coordinate position.
Note Many times there is a little offset between the flexible body interface node and its
corresponding point in the model. When you click the Align button, MotionView moves
the connection point in the model to the node location on the flexible body. This could
affect other entities that reference this point. Hence, this option should be used with
caution. Generally, it is common to have minor offsets (values between 0.001mm to
0.1mm). If the offset is more than the tolerance value, MotionView inserts a dummy
body between the flexible body and the nearest connection point. If the offset value is
too high, it could indicate an mismatch of the FE model information with respect to the
MBD model. In such an event, it is recommended to review the models and reconcile the
differences.
15. Close the Nodes dialog.

16. Click the Modes button. The Modes panel is displayed. This option lets you select the modes
that will be active during the simulation. By default, the rigid body modes are deactivated. You
can also change the damping used for modes.
Note By default, for frequencies under 100Hz, 1% damping is used. For frequencies greater
than 100Hz and less than 1000Hz, 10% damping is used. Modes greater than 1000 Hz use
critical damping. You can also give any initial conditions to the modes.
Please note that when selecting the modes, the simulation results may vary as you
change the modes to be included in the simulation.
17. Click Close.

18. Repeat steps 7 through 17 to integrate the right side flexible body sla_flex_right.h3d (created
in tutorial MV-2010) in your model.
Your model should look like the image below:
Now you will review the properties of the FEM model file.
19. Click the FEM Inertia Props tab.
The following information is displayed:
Bodies panel/FEM Inertia Props tab
20. From the Tools menu, select Check Model to check your complete MBD model for errors.

21. From the Standard toolbar, click the Save Model icon, , to save your model as an MDL file
named sla_flex.mdl.
The Save As Model dialog is displayed.
22. Click the Run icon, , on the toolbar and run the model with simulation type Quasi-Static,
specifying the filename as sla_flex_ride.xml.
23. Once the run is complete, load the MotionSolve result file sla_flex_ride.h3d (located in your
working directory) in a HyperView window and view the animation of the run.

MV-2021: Simulating an Automotive Door Closure
Event
use an FEM file to create a flexible body file.

use body data to create a rigid body model.
make the door flexible and use the flexbody file created in the model.
set up a door closure simulation.
N Copy the files metro_door.fem and car_body_graphics.hm, located in the mbd_modeling

o \flexbodies folder, to your <Working directory>.
t
e
Step 1: Review of a finite element model for the flexible door.

In this step, we will review the contents of the finite element (FE) model, which is the starting point
for creating a flexible body.
1. Import the model metro_door.fem in HyperMesh.
2. Click the Model Browser on the left of the graphics area and expand the model tree to review all
components, properties, and materials of the model.

3. The FEM model should have the following attributes:
A decent, quality mesh on all components.
The Section properties are assigned to all components.
All components refer to appropriate materials.
4. Identify the interface nodes of the flexible body. Please check the following nodes by ID: 9751,
9750, 10090.
5. Export the FEM as metro_door_flex.fem for Flexbody Generation.

Step 2: Generating the flexbody using Flex Prep
In this step, we will use the FEM file created in Step 1 and use Flex Prep to generate a flexible body
H3D file. A pre-requisite for going through this step of the tutorial is an understanding of Flex Prep
as described in the tutorial: MV-2010: Flexbody Generation using Flexprep and Optistruct.
1. In MotionView, from the FlexTools menu, select Flex Prep. The FlexBodyPrep dialog is
displayed.
2. Once the FlexBodyPrep dialog is displayed, enter the following information in the FlexBodyPrep
dialog to generate the flexbody for building the door closure model.
FlexPrep utility with data
3. See the image above where the entries and options on the FlexBodyPrep dialog are labeled with
numbers.

4. For #2, Select Bulk Data file (fem/nas/bdf/dat):, specify the input file metro_door_flex.fem
generated in Step 1.
5. For #3, Save the h3d file as:, specify the output H3D file as metro_door_flex.h3d.
6. For #4, Specify Interface Node List, specify the interface node numbers as: 9751+9750+10090.
7. For #5, Cutoff type and value: select Highest Mode # and enter 20.
8. For #6, activate both Perform stress recovery and Perform strain recovery, and select No for
Perform element check in Optistruct model.
9. For Mass units, select Megagram.
10. Click OK to start the flexbody generation.
11. The flexbody H3D file is generated in the selected folder with the name metro_door_flex.h3d.
Step 3: Creating the MBD model of the car door.

In this step, you will create the MBD model of the car door, after which the door closure simulation
can be performed.
For this model, use the following units for length, mass, force, and time, respectively: millimeter,
megagram, Newton, second.
Model Units
1. From the Forms panel, , change the Mass units from the default Kilogram to Megagram.
Points
For building this model, a total of six points need to be created.
1. From the Project Browser right-click Model and select Add Reference Entity > Point (or right
click on Points icon, , from the toolbar. Add the points as shown in the table below.
Table 1 Points required for the model

Bodies
In this model, there are two bodies: one body to represent the car and another to represent the
flexible door.
1. From the Project Browser, right-click Model and select Add Reference Entity > Body (or right-
click the Bodies icon, , from the toolbar. Add a body and label it Car Body.
2. Specify the center of mass of the body as the point Car Body CG from the CM Coordinates tab.
3. Click the Properties tab of the Car Body and enter the mass and inertia properties values as
shown in Table 2 below.
Table 2 Mass and inertia properties of the car body
4. Add another body and label it Car Door.
5. From the Properties tab, click the Deformable check box.
6. Browse and specify the metro_door_flex.h3d file as the Graphic file: and H3D file: of the Door
Body. Use the flexbody file generated in Step 2 above.

Graphics
After Point 6 above, we see that the Door Body has a graphical representation, but Car Body is still
not graphically represented. Lets add a File Graphic to the Car Body so that visualization of the
model becomes more meaningful.
1. From the Tools menu, select Import CAD or FE.
2. From the Input File drop-down menu, select HyperMesh. Use the file browser to select the
HyperMesh file car_body_graphics.hm. The Output Graphic File field is automatically
populated.
3. Click OK. The HyperMesh file is converted to H3D and imported into the MotionView window.

4. From the Graphics panel, , click the graphic just now added.
5. From the Connectivity tab, double-click the Body button and pick Car Body as the body. This
will associate the selected graphic with the Car Body.
Joints
For this body, we will need to add a total of four constraints/joints. One of these joints will need to
be added using the XML Template.
1. From the Project Browser, right-click Model and select Add Constraint > Joint (or right-click
the Joints icon, , from the toolbar). Add joints as specified in the table below.
Table 3 List of the joints to be created and their topology
Once the joints are specified and since there is a flexible body in the model, the interface nodes
of the flexible body have to be associated with corresponding joint markers.
2. From the Bodies panel, select Car Door.
3. From the Properties tab, click the Nodes button.
4. From the Nodes dialogue, click Find All to find the interface node numbers and to resolve them
with the respective connection markers.
Initial Conditions
In this simulation, we will have body initial velocity as the primary motion input to the model.
1. From the Project Browser, select the Door Body from the filter on the left.
2. Click the Initial Conditions tab.
3. Activate WZ and specify a value of 5.0 for the same. This will be the magnitude of the initial
angular velocity about the global Z axis that will be applied to the Door Body.
4. Do a test simulation to check how the model behaves with just the initial velocity and the
constraints.

Markers
To represent the locking mechanism of the car door, we will use a sensor activated fixed joint
between the Car Body and the Door Body that initially is deactivated. The fixed joint will need to be
created using XML templates since the MotionView interface allows joints to be created using bodies
and points. In this case, we need to create the joint between two initially non-coincident markers.
1. From the Project Browser, right-click Model and select Add Reference Entity > Marker (or
right-click the Marker icon, , from the toolbar. Add two markers as specified in the table
below.
Table 4 List of markers to be created and their topology
2. Once the markers are created, repeat steps 2-4 under Joints above to resolve the node
connections of Car Door Body with the maker Door Lock Mark.
Sensor
In this model, we will use an Event Sensor to detect the closing of the door. At the instance of the
event detection, the fixed joint between the door and the car body is activated to simulate the actual
locking mechanism.
1. From the Project Browser, right-click Model and select Add General MDL Entity > Sensor (or
right-click the Sensor icon, , from the toolbar. Add a sensor and label it Lock Recognize.
2. Click the Signal tab and change the signal type from Linear to Expression.
3. Use the following expression as the signal: DY({MODEL.m_door.idstring},

{MODEL.m_car.idstring},{MODEL.m_car.idstring}).
The DY function accepts three markers as arguments. It returns the Y distance of the first
marker from the second marker in the third markers reference frame. In this case, the first
marker is the maker labeled Door Lock Mark, which belongs to the Car Door Body. The second
and the third marker is Car Body Lock Mark, which belongs to the Car Body.
4. From the Compare To tab, specify 0.0010 for Value: and 0.0001 for Error: Under Respond if:,
select Signal is less than VALUE + ERROR.
5. From the Response tab, activate the Return to command file check box.

Templates
To simulate the door lock, we need a fixed joint between the door and the car body. The fixed joint
needs to be activated with the sensor. The activation of the joint and the deactivation of the sensor
can be done using a sequential simulation operation.
1. From the Project Browser, right-click Model and select Add General MDL Entity > Template
(or right-click the Template icon, , from the toolbar). Add a template to the model and label
it Lock Fix Joint.
2. From the Properties tab of the template, under Type:, select Write text to solver input deck.
3. Type in the following definition of the fixed joint in XML format in the template are of the panel:
<Constraint_Joint
id = "1001"
type = "FIXED"
i_marker_id = "{the_model.m_door.idstring}"
j_marker_id = "{the_model.m_car.idstring}"
/>
This defines the fixed joint between the two markers Door Lock Mark and Car Body Lock Mark.
4. From the Project Browser, right-click Model and select Add General MDL Entity > Template
(or right-click the Template icon, , from the toolbar) to add another template.
5. Specify the label as Seq Sim Commands.
6. From the Properties tab of the template, under Type, select Write text to solver command
file.
7. Below are XML Commands for the sequential simulation. Enter the following blocks of XML
commands in the template area of the panel:
<Deactivate
element_type = "JOINT"
element_id = "1001"
/>
<Simulate
end_time = "1.0"
/>
<Activate
element_id = "1001"
/>
<Deactivate
element_type = "SENSOR"
element_id = "{the_model.sen_0.idstring}"
/>
<Param_Transient
integrator_type = "VSTIFF"
/>

<Simulate
end_time = "2.5"
/>
<Stop/>
These set of XML blocks define a sequential simulation operation as specified in the steps below:
A. Deactivate Fixed Joint (initially).

B. Simulate for 1 second.
C. Activate Fixed Joint.
D. Deactivate Sensor.
E. Change the Integrator Type to VSTIFF.

F. Simulate for 1.5 seconds.
G. Stop simulation.
Continuing from step 7:
8. Save the model once by selecting Export > Solver Deck from File menu.
9. From the Run panel, click the file browser, , next to Save and run current model and specify
a name for the solver XML file.
10. Click Run to run the model in MotionSolve.
11. Once the run is complete, click Animate to animate the simulation results.

solve an ADM/ACF model that has flexbodies using MotionSolve.

use the Add Object panel in Hyperview and view the transient analysis results from
MotionSolve.
Theory
You can submit Adams dataset language files (ADM and ACF) directly to MotionSolve, thus avoiding
manual translation. The Adams model is first automatically translated into the MotionSolve XML format
and then it is solved. If the Adams model has a flexible body represented by the MNF and MTX files,
the MotionView Flexprep utility will be used to generate an H3D flexible body file (using the MNF file).
This H3D flexbody file is the MotionSolve equivalent of the Adams MNF and MTX files. It holds the
mass and inertia properties, as well as the flexibility properties which allow the body to deform under
the application of loads. The deformation is defined using a set of spatial modes and time dependent
modal coordinates.
Process
In this tutorial, an Adams single cylinder engine model (ADM and ACF) is provided. To improve the
accuracy of the model responses, the connecting rod is modeled as a flexbody (MNF and MTX). This
chapter deals with transient analysis of this single cylinder engine model using MotionSolve.
We will modify the ACF file to include an argument that would generate a flexbody H3D file.
MotionSolve internally calls OptiStruct, which generates the H3D flexbody file. The ADM and ACF is
translated into MotionSolve XML format and solved. MotionSolve outputs the results H3D file, which
can be loaded in HyperView for animation. In HyperView, external graphics (for piston and crank) can
be added for visualization.
MotionSolve supports most of the Adams statements, commands, functions, and user subroutines.
Refer to the MotionSolve Users Guide help for additional details.
Tools
Copy the following files, located in the mbd_modeling\motionsolve folder, to your <working
directory>:
single_cylinder_engine.adm
single_cylinder_engine.acf
connecting_rod_flex_body.h3d
Flexible_body.mnf
Flexible_body.mtx
piston.h3d
crank.h3d

Note Below is a table listing the flexbody files in Adams and the equivalent files for MotionSolve:
Option Adams MotionSolve
Flexbody file mnf and mtx h3d flexbody
Post processing Gra and res h3d-animation

animation
Plot Req plt/abf
Step 1: Modifying the ACF file.

2. Click the Select Application icon, ,and choose Text View, .
3. From the toolbar, click the arrow next to the Open Session icon, , and select Open
document , . Select single_cylinder_engine.acf, located in your <working directory>.
4. Add the following text in line 3 :
FLEX_BODY/1, H3D_FILE=connecting_rod_flex_body.h3d
The ACF file should look like this:
5. From the toolbar, click the Save Document icon, , and save the file as
single_cylinder_engine.acf to your <working directory>.
Note The connecting_rod_flex_body.h3d file that has been used in this tutorial is generated
using the FlexPrep utility in MotionView. Refer to the MotionView online help for more
information on converting an Adams MNF file into a MotionView H3D flexbody.

Step 2: Running the ACF file in MotionSolve.
1. Click Start > All Programs > Altair HyperWorks > MotionSolve.
2. For Input file, click Browse and select All files (*.*) from the file type menu. Select the input
file single_cylinder_engine.acf from your <Working directory>.
3. Click Run.
MotionSolve translates the Adams model (ADM, ACF) to the MotionSolve XML format and solves it.
MotionSolve internally invokes OptiStruct, which converts the connecting rod flexbody MNF and
MTX files to a flexbody H3D file.
MotionSolve outputs the following files:
Results H3D file - single_cylinder_engine.h3d
Plot files - single_cylinder_engine.abf and single_cylinder_engine.plt
Log file - single_cylinder_engine.log
Note MotionSolve is completely integrated into MotionView. You can also use the Run icon,
, from the toolbar in MotionView to perform this action. MotionSolve can also be run
from the command prompt. Open a DOS command window, and at the command prompt
type:
[install_path]\hwsolvers\scripts\motionsolve.bat input_filename.
[fem,acf,xml]
Step 3: View transient analysis results in HyperView by adding external

graphics.
Since the ADM file does not carry the external graphic information, the results from MotionSolve will
not contain this information either. From Adams, you can export a Parasolid file which can be used for
visualizing results in HyperView. In this step, we will attach the piston and crank external graphic for
better result visualization.
1. Start a new HyperView session.

2. Using the Load model file browser, , select: single_cylinder_engine.h3d, located in your
The Load results file field will be automatically be updated with the
single_cylinder_engine.h3d file.
3. Click Apply.
The model is displayed in the window.
4. From the Add Object panel, , using the Add object from: browser, select the piston.h3d
file. If the Add Object icon is not visible on the toolbar, select the View menu > Toolbars >
HyperView > Tools.
5. For Select object, select All to add all objects to the list.
6. Using the expansion button, , select Piston as the component with which you want the
selected object to move.
7. For Reference system, select the Global coordinate system.
8. Click Add.
Notice that the piston graphic is added to the model.
9. Repeat steps 5 through 8 to add the crank object to the model.
Note Remember to select the crank.h3d file in the Add Object from: browser and attach it to
Crank using the expansion button.
10. Click the Contour icon, , on the toolbar. From the Result type drop-down menu, select the
data type that should be used to calculate the contours.
11. Select a data component from the second drop-down menu located below Result type.
Note If you select Mag (Magnitude), the results system is disabled (since magnitude is the
same for any coordinate system).
12. Click Apply.
The contour is displayed.
13. Click the Start Animation icon, , on the toolbar to animate the model.

14. Click the Stop Animation icon, , on the toolbar to stop the animation.
Note In the Add Object from: browser, you can directly select a wavefront file (*.obj) from
Adams to add graphics. Whereas, if you have a Parasolid file (*.x_t) from Adams, use
the Tools menu > Import CAD or FE utility in MotionView to generate an H3D file. You
can then use this file to add the graphics.
Refer to the MotionView help for additional details.

MV-2040: Load Estimation for a Fore Canard Actuator
Mechanism under Aero-dynamic Loads
Represent pressure/distributed loads as Modal Forces on a CMS flexible body.

Scale Modal Forces to real world loads in MotionView/MotionSolve.
What is Modal Force?
Forces acting on a flexible body may be an aerodynamic load, liquid pressure, a thermal load, an
electromagnetic force or any force generating mechanism that is spread out over the flexible body,
such as non-uniform damping or visco-elasticity. It may be even a contact force between two bodies.
These distributed loads can be conveniently transformed from Nodal to Modal domain and represent
as Modal Forces.
If we define as the mode shapes of the flexible body, and as the Nodal load acting on the
flexible body, the equivalent Modal load on the flexible body is defined as:
Exercise:
In this exercise, you will create a flexible body of a Fore Canard of an aircraft with aero-dynamic loads
using Optistruct. Aero-dynamic loads for three operating positions of the fore canard, namely -10
deg, 0 deg, and 10deg, considering an air speed of 200m/sec at 1 atm pressure are available from a
CFD simulation using AcuSolve. A later section of the exercise involves embedding this flexible body in
the actuator mechanism model in MotionSolve to estimate actuator loads required for the operation of
fore canard.
Copy all of the files located in the mbd_modeling\flexbodies\modalforce folder to the <working
directory>.

Fore C anard of an Aircraft

Step 1: Creating a Fore Canard flexible body.
1. Review the HyperMesh model:
Open ForeCanard.hm in Hypermesh with Optistruct selected as the user profile.
Fore C anard meshed model

The HM file contains a meshed model of Fore Canard with material properties and control cards
defined.
HyperMesh model browser
Note Please note model units are Newton-Meter-KG-Sec, therefore all properties defined are
consistent with this unit system.
2. Create aerodynamic loads from CSV files:
Average pressure distribution over the surface of canard is exported as text file from
AcuFieldView. This file contains the location and value of the pressure. The
AerodynamicLoad_0deg.csv, AerodynamicLoad_Negative10deg.csv, and
AerodynamicLoad_Positive10deg.csv files contain the pressure distribution information for
0deg, -10 deg, and 10 deg of canard orientation respectively.
Add load collectors for three cases:
Left click on the Load Collector icon from toolbar.
Verify that the create radio button is selected and specify a new load collector name as
AerodynamicLoad_0deg.
With drop-down menu for card image set as no card image, click on the create button.
Follow steps above to create the other two load collectors with names as
AerodynamicLoad_Negative10deg and AerodynamicLoad_Positive10deg.
Click return.

3. Browse to the Pressure load panel:
Select the Analysis radio button to go to the Analysis page.
Click on Pressures button to open the pressure panel.
Analysis page
4. Set the pressure load type to linear interpolation:
Verify that the create radio button is selected.
Pressures panel
Click on the drop-down arrow next to faces button.
Surface type set as faces by default
Select entities from the drop-down menu to switch the surface selection type from faces to
elems.
Specifying entity type as elems from list
Click on drop-down menu button next to magnitude.
Magnitude type is a constant vector by default

Select linear interpolation from the list.
Specifying magnitude as linear interpolation from list
Upon selection of the above settings, you can select elements on which pressure loads are
applied and a CSV file for pressure load info.
Pressures panel with linear interpolation type
5. Create pressure loads on canard surface:
Pressure loads for each position are created under their respective load collectors so that you can
scale them in MotionSolve with respect to the canard position. Create a pressure load for 0deg
by following the steps below.
Make AerodynamicLoad_0deg as the current load collector by following below steps:
Left click on the Set Current Load Collector button located at the bottom.
Information bar at the bottom with current model, component, and load collector information
Select AerodynamicLoad_0deg from the load collector list.
Load collectors list

Specify the elements from the Fore Canard collector by following the steps below:
Left click on the elems button.
Left click on elems button to display different element selection options
Select by collector from the list.
Element selection options dialog
Select the Fore Canard collector from the component collector list and activate the select
button to return back to pressures panel.
C omponent collectors list

Select the 0 deg pressure info CSV file by following below steps:
Click on the ellipsis button ... to browse for the file.
The Open dialog box is displayed. Browse to your <working directory> to select the
AerodynamicLoad_0deg.csv file and click Open.

The selection of surface elements and the pressure info file is now complete. Click on the
create button to create pressure loads for the 0deg position.
C ompleted pressure panel
Pressure loads on canard surface
Note The pressure load on each element is obtained by a linear interpolation of pressure values
with respect to its location.
Follow the above steps to create pressure loads for -10deg and +10deg under the respective
load collectors AerodynamicLoad_Negative10deg and AerodynamicLoad_Positive10deg.

6. Specify load sets for CMS method:
Three load cases modeled in previous step represent nodal forces. These nodal forces are
transformed as modal forces using CMS method. In this step you modify the existing CMSMETH
card image to include three load sets.
Open an existing CMS card image by following the steps below:
Browse to the CMS load collector from Entities browser.
Right click on CMS load collector.
Opening C MS load collector card image from browser context menu

From the context menu select Card Edit to open the load collector card image.
C MS load collector card image dialog with method specified as C raig-Bampton (C B) and the number of modes
as 25
7. Specify load sets for CMSMETH by following below steps:
In Card Image dialog, activate the LOADSET check box.
Specify the CMSMETH_LOADSET_LSID_NUM value as 3.
Specifying LOADSET option for C MSMETH
Observe that the Card Image shows an option to specify three load sets.
Specify load collectors for three load sets by following the steps below:
Double click on the LSID(1) button to open load collectors list.
Browsing to load collectors list from C ard Image dialog

Select AerodynamicLoad_0deg from the list and click on return button to return back to
CMS card image.
Load collectors list
C ard image with LSID(1) specified
Similarly, specify the AerodynamicLoad_Negative10deg and

AerodynamicLoad_Positive10deg load collectors for LSID(2) and LSID(3) respectively.
Click Return.
8. Generate flexbody.
Your model is now ready for solving to generate a flexbody. The two control cards required to
solve for flexbody creation are already specified in the model.
Review the control cards:
Click on control cards button from the Analysis page.

Click on the DTI_UNITS button from the first page to review flexible body units. Click
Return.
DTI_UNITS card image
Click on GLOBAL_CASE_CONTROL in the next card to see the CMS load collector specified
for CMSMETH solution.
Click return twice.
GLOBAL_C ASE_C ONTROL card image
Solve the model by following the steps below:
Click on the Optistruct button from Analysis page.
Analysis Page
In the Optistruct analysis panel:

o Set export options to all.
o Set run options to analysis.
o Browse to your working directory and specify input file name as flex_ForeCanard.fem.
o Click on the Optistruct button.
C ompleted Optistruct panel

9. Review flexbody modes.
On successful completion of solver run, open the flexbody flex_ForeCanard.h3d created from
Optistruct run in HyperView to review the various mode shapes. Your flexbody contains 34
modes constituting normal modes, constraint modes, and Static modes.
Frequency and Eigen values read from flex_ForeC anard.out file

Three aero-dynamic loads represented as static modes
Step 2: Creating a MotionView model.

A MotionView model of the fore canard mechanism has been provided. In this model, the Fore Canard
body is modeled as a rigid body. In this next step we will replace the rigid Fore Canard body with a
flexible body created in the previous step and use ModalForce entities to scale the pressure loads with
respect to canard position.
1. Review the MotionView model:
Open the ForeCanard_Model.mdl in MotionView. The model contains:
Four bodies namely Fore Canard, Torque Arm, Piston, and Cylinder.
A motion on the Piston with an expression 0.025*SIN(2*PI*TIME) to extend and retract the
piston by 25mm at 1 Hz. This piston motion varies the fore canard angular position between
-9.619 deg to +9.984 deg.
MotionView model of Fore canard mechanism

An expression type Output request to measure the ForeCanard angular position and
Piston force along its axis.
The Fore canard angular position is measured from the RevJnt_TorqueArm_Gnd joint
rotation angle using the expression `RTOD({j_4.AZ})`.
The Piston force is measured from the Piston Motion using the expression
`MOTION({mot_0.idstring},{0},{4},{j_2.i.idstring})`.
Output requests
Solve the model with the rigid Canard to review piston forces without aero-dynamic loads.
Invoke the Run panel by clicking the Run Solver button, , in the toolbar.
Specify the MotionSolve file name as ForeCanard_withoutAeroloads.xml.
Select the Simulation type as Quasi-static, the End time as 1 sec, and the Print
interval as 0.01.
Click on the Run button.
After the simulation is completed, click on the Animate button to view the animation in
HyperView.
Initial position 0 deg (meshed) and rotated position 10deg at 0.25 sec of simulation

Click on the Plot button from the MotionView Run panel to load the
ForeCanard_withoutAeroloads.abf file in HyperGraph2D.
Plot the Piston Force versus Fore Canard Angular Position by selecting the below data in
HyperGraph.
Select the following for X-axis data:
X Type Expression
X Request REQ/70000000 Fore Canard Angular Position (deg)F2,

Piston Force (N)F3
X Component F2
Select the following for Y-axis data:
Y Type Expression
Y Request REQ/70000000 Fore Canard Angular Position (deg)F2,

Piston Force (N)F3
Y Component F3
Results without aero-dynamic loads
The piston forces in this case are due to the canard mass moment of inertia.

2. Return to MotionView and switch the rigid fore canard to a flexible body.
Browse and select the Fore Canard body from Project browser.
In the Body panel, activate the Flex Body(CMS) check box.
Body panel
Browse to your working directory, specify flex_ForeCanard.h3d for the Graphic and H3D files.
Specify flexbody h3d file for Fore C anard body
Click on Nodes button and resolve the flexbody interface nodes.

3. Model Aero-dynamic loads through Modal Force entity:
The aero-dynamic loads are estimated at three distinct positions of canard namely -10 deg, 0deg,
10deg. We assume the each pressure load to linearly vary in interval 10deg on a 0 to 1 scale.
This variation of the aero-dynamic loads is achieved by scaling Modal Forces with respect to
canard angle using an expression.
Create a solver variable:
An explicit solver variable is created to measure the fore canards position.
Right-click on the SolverVariable icon from the toolbar.
The Add SolverVariable dialog is displayed.
Specify the Label as Angle Measure and the Variable name as sv_ang.
C ompleted Add SolverVariable dialog
Click OK.
The SolverVariable panel is displayed.

From the Properties tab, specify the Type as Expression and enter `RTOD({j_4.AZ})` for
the Expression.
Defining explicit solver variable
This creates an explicit variable that measures the Fore Canard angle.
Add a ModalForce:
Add three modal forces each corresponding to one load set.
Right-click on the ModalForce icon from the Force Entity toolbar.
MotionView Force Entity toolbar
The Add Modal Force dialog is displayed.
Specify the Label as AerodynamicLoad_0deg and the Variable name as mfrc_0deg.

Click OK.
The ModalForce panel is displayed.
From the Connectivity tab, specify Fore Canard for the FlexBody.
Specifying flexbody
From the Properties tab, specify the scaling type, expression, and load case ID as shown
below:
o Specify the Scale type as Expression.
o Specify the LoadCaseID corresponding to 0deg, in other words 3.
o Specify Expression as `STEP(VARVAL({sv_ang.idstring}),-10,0,0,1)

*STEP(VARVAL({sv_ang.idstring}),0,1,10,0)`.

Steps of creating Modal Force for 0deg
The product of the two STEP functions evaluates to gradually increasing the value of the scale
from 0 to 1 and then back to 0, while the canard angular position varies from -10deg to 10 deg as
shown in the expression below:
Graphical representation of the scaling factor

Follow the steps above to create the remaining Modal Forces as specified below:
S. Label Variabl Flexbo Scale Loa Expression

No e name dy Type d
Cas
e
ID
1 Aerodyn mfrc_n Fore Expre 4 `STEP(VARVAL({sv_ang.idstring}),-

amicLoa eg10de Canar ssion 20,0,-10,1)
d_Negat g d *STEP(VARVAL({sv_ang.idstring}),-
ive10de 10,1,0,0)`
g
2 Aerodyn mfrc_p Fore Expre 5 `STEP(VARVAL({sv_ang.idstring}),0,0,1

amicLoa os10de Canar ssion 0,1)
d_Posit g d *STEP(VARVAL({sv_ang.idstring}),10,1,
ive10de 20,0)`
g
Step3: Solving the model and post-processing.
1. Invoke the Run panel by clicking the Run Solver button, , in the toolbar.
2. Specify the MotionSolve file name as ForeCanard_withAeroloads.xml.
3. Select the Simulation type as Quasi-static, the End time as 1 sec, and the Print interval as
0.01.
4. Click on the Run button.
5. After the simulation is completed, click on the Animate button to view the animation in
HyperView.
6. Use the Start/Pause Animation button to play the animation.
7. Click on the Contour button to activate the Contour panel.

8. Under Result type, select Stress (t) and click Apply to view the stress contours.
Stress contour at 0.25 sec
9. Click on the Plot button from MotionView Run panel to load the ForeCanard_withAeroloads.abf
file in HyperGraph2D.
10. Plot the Piston Force versus Fore Canard Angular Position by selecting below data in
HyperGraph2D.
Select following for X-axis data:
X Type Expression
X Request REQ/70000000 Fore Canard Angular Position (deg)F2, Piston

Force (N)F3
X Component F2

Select the following for Y-axis data:
Y Type Expression
Y Request REQ/70000000 Fore Canard Angular Position (deg)F2, Piston

Force (N)F3
Y Component F3
Results with aero-dynamic loads
You can overlay the plots to observe the difference in piston forces with and without aero-
dynamic forces.
Overlay of results

Automated
MV-1032: Model Building and Simulation using Wizards
MV-1040: Model Building using TCL

MV-1032: Model Building and Simulation using
Wizards
In this tutorial, you will learn:
About the Assembly and Task Wizards in MotionView

How to build a model using the Assembly and Task Wizards
How to view a standard report
How to modify a model and compare results using the Report Template
Model Wizards are powerful tools in MotionView that can be used to quickly build models with standard
topology that is used repeatedly. There are two standard wizards available: the Assembly Wizard
and the Task Wizard (which work in conjunction with one another). Both of these wizards rely on a
library of pre-saved system, analysis, and report definition files to automate the processes of building
models, analyzing them, and post-processing the results. The wizard mechanics are shown in the
flowchart below:
A collection of systems and analyses are stored as a library.

The Assembly Wizard presents the user with various options to select systems to instantiate
(in the form of a series of panels).
The systems selected by the user in the panels are instantiated using the system definitions
contained in the MotionView client library, thereby assembling the model comprised of different
systems. An Attachment Wizard follows, which is used to select possible attachment options
for each system that is instantiated.
On the model is built, the Task Wizard is invoked in order to attach applicable events to the
model. The selected analysis is instantiated using the analysis definition stored in the library.

Exercise: Automated Modeling and Analysis Using Wizards
In this exercise, we will build a suspension model of a vehicle using the standard wizard library
available in MotionView. A static ride event will be attached to this model using the Task Wizard.
The model will then be solved in MotionSolve and an automated report will be generated.
Step 1: Building a front suspension model using the Assembly Wizard.

1. Start a new session in MotionView.
2. On the Model menu, click Assembly Wizard.
The Assembly Wizard dialog is displayed.
3. For Model type, select Front end of vehicle.
4. Click Next.
5. For Drive type, select Front Wheel Drive.
6. Click Next.

7. From the Primary Systems for Front end of vehicle dialog, specify the following:
Vehicle body = Body fixed to ground
Front subframe = None
Front suspension = Front SLA susp (1 pc. LCA)
Steering linkage = Rackpin steering
Powertrain = None
8. Click Next.
9. From the Select steering subsystems dialog, specify the following:
Steering Column = Steering column 1 (not for abaqus)
Steering Boost = None
10. Click Next.
11. From the Select springs, dampers and stabilizer bars dialog, select the following:
Front shocks = Frnt shock absorber (with inline jts)
Front stabilizer bars = None
12. Click Next.
13. From the Select jounce and rebound bumpers dialog, set the options to None, and click Next.
14. From the Select Driveline Systems dialog, set the Front Driveline to Independent Forward,
and click Next.
All of the required systems that are necessary to build a front suspension model have now been
selected.
15. Click Next to load the assembled model and bring up the Attachment Wizard.
The Attachment Wizard shows the attachment choices which are available for each sub-
system. In this exercise, we will simply review the options in each sub-system and accept the
default selections.
16. From the Attachment Wizard, review the choices for each sub-system and click Next until the
last page of the dialog is reached.

17. Click Finish.
Your model should look as follows:
A brief description of the model:
This model represents a front end suspension of a vehicle with a Short Long Arm type (also known as
Wishbone) of suspension and a steering system. The vehicle body is fixed to ground. The upper and
lower control arms of the suspension are attached to the vehicle body at one end through bushings,
while they are connected to a knuckle on the other end through ball joints. A wheel hub (no graphics
for this body are in the model) is mounted on the knuckle through a revolute joint. The wheel is fixed
to the wheel hub.
The steering system consists of a rack with a translation joint with a rack housing (through a dummy
body). The ends of the rack are connected to a tie rod at each end through ball joints and the other
end of the tie rod is connected to the steer arm of the knuckle through ball joints. The rack gets its
movement from the steering column through a coupler constraint between the rack and the pinion.
Step 2: Adding a static ride analysis task using the Task Wizard.
The Analysis Task Wizard allows you to assign an event analysis to the model using a wizard. This
default suspension wizard is configured such that the available analyses choices are dependent on the
system selections made in the Assembly Wizard. Since this is a half-vehicle model, only events that
are applicable for a half-vehicle model are available. A full vehicle model would contain a different set
of analysis events.
In this step, we will add a static ride analysis for the suspension assembly. Through this analysis, the
kinematic characteristic of the suspension can be studied for varying vertical positions of the wheels.
Both wheels are exercised such that they move vertically along the same direction.

1. On the Analysis menu, click Task Wizard.
2. In the Task Wizards Front end tasks dialog select the Front end task as Static Ride
Analysis from the pull down menu.
3. Click Next.
4. Read the information in the dialog box.
5. Click Finish.
The Vehicle parameters dialog is displayed. Vehicle parameters such as wheelbase, jounce, and
rebound distances can be changed in this dialog.
6. Retain the current parameters and click Finish.
Your model should look as follows:
The static ride analysis event consists of a pair of jacks that are attached to the wheels at the
tire contact patch location. The jacks are actuated through Actuator Forces that exercises them
in the vertical direction in a sinusoidal fashion.
The model tree in the Project Browser now includes an analysis called Static ride analysis. It is
possible to add many different analysis tasks to the same model, however only one analysis task
may be active at one time.

7. Go to the Project Browser, right-click on Model and select Rename (or left click on Model and
press F2 on the keyboard).
8. Rename the Model label to My Front SLA Suspension.
9. Expand the Static ride analysis folder and also the Forms folder (located underneath) by clicking
the + sign next to each folder in the Project Browser.
10. Select the Static Ride Parameters Form.
The Forms panel is displayed.
11. Change the values for Jounce travel (mm) and Rebound travel (mm) to 50.0.
12. Click and save the model as sla_ride.mdl in your <working directory>.
Step 3: Running the simulation and viewing a report.

The static ride simulation is a 10 second quasi-static run. Within the 10 seconds the jack moves in
jounce (vertically upwards), then moves down until the rebound position is reached (distance from the
initial position downwards), and then back to its initial position. The amount of travel is as per the
distance specified in the Static Ride parameters form.
2. Save your model as sla_rigid.xml in your <working directory>.
3. Click on the Run button to submit the simulation job to MotionSolve.
4. After the job is completed, close the Run window and the Message Log.
5. From the Analysis menu, click View Reports.
The View Reports dialog is displayed.
6. Select Front Ride-MSolve SDF based Report My Front SLA Supsension and click OK.
This analysis comes with a Standard Report Template that plots the results and loads the
animation in subsequent pages.
7. Once the process of adding the pages is complete, use the Previous Page/Next Page buttons
(located at the upper right corner of the window, below the menu bar area and above
the graphics area) to navigate and review the plots and animation pages.
8. The last page is the TextView client with an open Suspension Design Factors (SDF) report. This
report lists the suspension factors at each time interval of the simulation.

How does viewing pre-specified results work?
A report that refers to a report template file (a template that contains plot and animation definitions)
can be defined in the MotionView model using the *Report() MDL statement. Whenever a model
containing such a report definition is submitted to a solver, MotionView writes a record of the report
into a log file named .reports. You can specify the location of this file with the preference file
statement *RegisterReportsLog(path). The default location of the .reports file is:
UNIX - <user home>
PC - C:\Documents and Settings\<user>
The path to the .reports file can also be set by selecting the Set Wizard path option under the
Model menu.
When View Reports from the Analysis menu is selected, MotionView displays the contents of the
.reports file in the Reports dialog. When you select a report from the dialog, MotionView loads the
requested report definition file into your session.
Below is a sample entry from the .reports log file:
Front Ride - MSolve Report Front Static Ride 02/10/XX 06:07:58
E:/Altair/hw/mdl/mdllib/Libs/Tasks/adams/Front/Ride/ms_rep_kc_front.tpl
*Report(rep_kc_frnt_mc, Front Ride - MSolve Report, repdef_kc_frnt, "E:/Temp/

sla_rigid.h3d", "E:/Temp/sla_rigid.h3d", "E:/Temp/sla_rigid.plt")
The first line contains the report label, model label, and the date and time when the solver input files
were saved. This information is contained in the Reports dialog. It is recommended that you give
your models specific names, otherwise they will be labeled Model.
Line 2 contains the name of the report definition file that the report is to be derived from.
Line 3 contains an MDL statement called *Report(). This statement specifies the report definition
variable name along with the required parameters. Refer to the MDL online help for more information.
Step 4: Modifying model parameters and comparing the results.

Next, we will modify the suspension parameters. After the simulation is run again, the results can
then be compared.
1. Return to the MotionView client page.

2. Right-click on Frnt SLA susp (1 pc. LCA) in the Project Browser and select Data Summary.
The Data Summary dialog is displayed.
3. Change the X and Y coordinates of LCA frnt bush by -5 and +5 respectively (for example, if the
existing value of X is 932.15, append -5 to it so that the expression is 932.15-5).
4. Similarly, change the X and Y coordinates of UCA rear bush by +3 and -5 respectively. In
addition, change the Z coordinate of Lwr ball jt by +10.
5. Click on the Bushings tab and change the KZ values of LCA frnt bush and UCA frnt bush by -
200 and +200 respectively.
6. Click the Close button to close the Data Summary dialog.
7. Go to the Run panel , and specify sla_ride_change.xml as the new file name for the xml file.
9. After the job is completed, close the Run window and the Message Log.
10. From the Analysis menu, click View Reports.
11. Select the latest report (the report located at the top of the list) and click OK.
The results from the latest run will be overlayed in the plot and animation windows. Compare the
plots.

12. In the Hyperview client (page 17 of the session), use the Change Model drop-down menu
(located in the Results Browser) to change the active result to sla_ride_baseline.h3d as
shown below:
13. Click the Entity Attributes panel button on the Visualization toolbar to enter the Entity
Attributes panel.
14. Activate the Auto apply mode check box (located in the middle portion of the panel).
15. Select a color from the color palette and click the All button.
All graphics belonging to the active result will change to the selected color.
16. Repeat steps 12 to 14 for sla_ride_change.h3d, however be sure to select a different color
from the color palette.
results.
View the animation and observe the differences between the two overlayed models.
18. Navigate back to the MotionView page and save the model .
19. Click the Save Session icon on the Standard toolbar and save your session as
my_susp_analysis.mvw in your working directory.
The model, plot, and animation information is saved in the session file.

MV-1040: Model Building using Tcl
Learn the advantages of using Tcl programming to save time and effort in MBD model building
with MotionView
Work with the HyperWorks Desktop Tcl interface
Build a simple model using Tcl commands
About Tcl
Tool Command Language or Tcl (typically pronounced as "tickle" or "tee-see-ell") is a scripting
language that is commonly used for quick prototyping, scripted applications, GUIs, and testing.
More About Tcl/Tk

Tcl has a simple and programmable syntax.
Tcl is open source.
HyperWorks has an inbuilt Tcl interpreter which has libraries to help end users.
Tcl can be used as a standalone or embedded in applications like HyperWorks Desktop
(including MotionView).
Unlike C which is a complied language, TCL is interpreted. Tcl programs are simple scripts
consisting of Tcl commands that are processed by a Tcl interpreter.
Tcl is extensible. New Tcl commands can be implemented using C language and integrated
easily. Many people have written extension packages for common tasks and are freely available
on the internet.
Engineering teams use different resources and application. Tcl can be used to glue those
resources together. This greatly helps in automating the work flow.
Tk is a Graphical User Interface toolkit that makes it possible to quickly create powerful GUIs.
Tcl/Tk is highly portable, and runs on different flavors of UNIX, windows, Macintosh and more.
This proves useful to those who work on various platforms.
Tcl with MotionView

When building huge multibody models in MotionView, you will come across cases where the
same steps are repeated multiple times. Such steps, or the set of steps, can be automated
suing Tcl in order to save time and effort wasted in performing repetitive and time consuming
tasks.
Like all of the HyperWorks Desktop applications, MotionView has Tcl command layers which help
in accessing the various functionalities of the product and utilizing them to write scripts to
automate processes.
The Tcl scripts can be called by Tk applications or tied in to a process manager.
Tcl scripts can be registered in a preference file and be made a part of product with Menu
shortcuts.

The HyperWorks Desktop handles and the HyperWorks database consists of a hierarchy of
objects, the root of which is the hwi object which is automatically created. The hwi provides access
to the hwiSession object and a few high level utilities. Currently, HyperWorks supports only one
session per run. The session object can be retrieved by issuing the following command at the Tcl
command prompt:
(System32) 1 % hwi GetSessionHandle sess1
Once the session handle is retrieved, it can be used to access all objects in the HyperWorks
database as shown below:
(System32) 2 % sess1 GetProjectHandle proj1
(System32) 3 % proj1 GetPageHandle page1 1
Windows are retrieved as shown below. Windows are assigned a client type, which can be modified.
(System32) 4 % page1 GetWindowHandle win1 1
(System32) 5 % win1 SetClientType "Animation"
(System32) 6 % win1 GetClientHandle post1
A window's client type cannot be changed after the client handle has been retrieved. The client
handle must be released and retrieved again if the window's client type is changed.
Every HyperWorks command object supports the following utility commands:
ListMethods: Displays the method commands which can be performed on an object.

ListHandles: Lists the names of all command objects of the same type.
ReleaseHandle: Releases the command object.
The top level hwi command object supports the following utility commands:
ListAllHandles: Displays all command objects currently in use.
Exercise: Model Building using Tcl
Step 1: Building a Simple Pendulum through Tcl commands.

In this exercise you will write a simple Tcl script to build a simple pendulum model.
Note Putting a # character in the beginning of any line makes it a comment and that line is not
evaluated. In addition, all HyperWorks Tcl commands are case sensitive.
The structure of every Tcl script created for HyperWorks Desktop products should follow the
following structure:
hwi OpenStack
Obtain All necessary handles
Perform some function
Release All obtained handles individually
hwi CloseStack

1. Open a new MotionView session.
2. Go to View menu, and click on Command Window.
3. A TkCon window opens up and displays the version of Tcl and Tk installed with Hyperworks.
4. In the Command Prompt type:

hwi GetSessionHandle sess
The prompt prints sess as the command output if the command is successful. This command
assigns the Session Handle to the variable "sess".
5. To view all the option/commands available with the hwi class type in hwi ListMethods at the
command prompt. This will list all the options available under hwi.
6. Now, type:
sess GetProjectHandle proj
This command will assign the Project handle to the variable "proj".
7. The next step is to obtain the Page handle, the command for it is:
proj GetPageHandle page 1
The variable "page" now points to the page handle of the first page of the session.
Note Please refer the "Programming with Tcl/Tk Commands" online help under the "HyperView,
MotionView and HyperGraph" Reference Guide for the explanation on the syntax of these
commands.
8. To get the control of the window we need to get the window handle the command for that is:
page GetWindowHandle win 1
This assigns the window handle of the first window to the variable "win".
9. Now to get the client handle type in:

win GetClientHandle mc
Note A HyperWorks session has multiple clients (HyperView, MotionView, HyperGraph 2D, etc). When
MotionView is invoked, the default client is MotionView. The GetClientHandle command gets
you the access to the MotionView model object through the Client Handle.
10. To be able to set different views and fit the model in the graphics window the view control handle
is required, the command to get view control handle is:
win GetViewControlHandle vch
11. To start with a new blank model we will run the command:
mc CreateBlankModel

12. To obtain the handle of the model just created in the previous step type in the command:
mc GetModelHandle m
Note Once the model handle is obtained we can now start creating entities using the
InterpretEntity and InterpretSet statements.
To build a simple pendulum we will be using 2 points, 1 body, 3 graphic entities, and 1
revolute joint.
The syntax for the InterpretEntity command is given below:
modelHandle InterpretEntity EntityHandle Entitytype

EntityVariableName EntityLabel <Parameters>
Where:
EntityHandle - The handle for the entity.
Entitytype - The type of entity to create (Point, Body, Graphic, etc.).
EntityVariableName The variable name for the entity to view in MotionView.
EntityLabel The label for entity to view in MotionView.
Parameters The parameters which are required to create the respective entity (for
example, CM point for Body).
13. To start with Add a point for the pendulum pivot with variable p_0 and label Pivot with a
command:
m InterpretEntity p Point p_0 "\"Pivot\""
14. Now to set the properties of the point just created, the command is:
m InterpretSet SetPoint p_0 0.0 0.0 0.0
15. p is the Point handle for Tcl and is released with p ReleaseHandle command:
p ReleaseHandle
16. To create a point for the location of the pendulum mass and set the property for it, the set of
commands are:
m InterpretEntity p Point p_1 "\"Mass\""
m InterpretSet SetPoint p_1 p_0.x+100 p_0.y p_0.z
p ReleaseHandle
17. Add the pendulum body and set its mass and inertia properties type in the following commands:
m InterpretEntity b Body b_0 "\"Pendulum\"" p_1
m InterpretSet SetBodyInertia b_0 0.5 100 100 100
m InterpretSet SetOrientation b_0.cm TWOAXES ZX
b ReleaseHandle

18. To add the graphics on the body for visualization the three graphic entities are added using the
commands:
m InterpretEntity g Graphic gra_0 "\"Graphic_Pivot\"" CYLINDER B_Ground p_0
V_Global_Y 1 1 10 -5 CAPBOTH
g ReleaseHandle
m InterpretEntity g Graphic gra_1 "\"Graphic_Pendulum_Cylinder\"" CYLINDER b_0 p_0

p_1 1 CAPBOTH
g ReleaseHandle
m InterpretEntity g Graphic gra_2 "\"GraphicMass_Cylinder\"" CYLINDER b_0 p_1

g ReleaseHandle
19. The pendulum will need to be connected to the ground with a revolute:
m InterpretEntity j RevJoint j_0 "\"Joint_Pivot_Rev\"" B_Ground b_0 p_0 V_Global_Y
j ReleaseHandle
20. After adding any entity to the model the database has to be updated by using the evaluate
command:
m Evaluate
21. To the fit model in the graphics window:

vch Fit
22. The model is ready to be run. Go to the Run panel, specify a name for the result file and click on
the Run button to run the model using MotionSolve. Use the Animate button to view the
animation.
23. The handles obtained through the commands in the above steps now have to be released using
the ReleaseHandle command. Type in the following:
m ReleaseHandle;
mc ReleaseHandle;
win ReleaseHandle;
page ReleaseHandle;
proj ReleaseHandle;
sess ReleaseHandle;
24. In a text editor paste all the above Tcl commands and save the file as pendulum.tcl in the
working directory. This file can be "sourced" and the model can be built in one step. The complete
script is given below for your reference (please see the bottom of the tutorial).
Note You can also use the file pendulum.tcl located in the automation folder.
Copy this file to your <working directory>.

Step 2: Sourcing the Tcl file.
2. Go to the View menu from the menu bar.
3. Click on Command Window. A TkCon window opens up at the bottom of the screen.
4. Change the directory to current working directory by using the cd command.
5. To invoke a Tcl script, use the command source pendulum.tcl, where pendulum.tcl is the file
that you saved in the previous step.
6. This will build the complete model by sequentially running the commands in the file line by line.
Step 3: Registering the Tcl in the preference file.

1. Open a text editor with a new file.
2. Write the following statements:

*Id("HyperWorks vXX.X")
*BeginModelDefaults()
*BeginMenu(scripts, "My Scripts")
*MenuItem(flexprep, "Build Simple Pendulum", Tcl, "<working directory>/

pendulum.tcl")
*EndMenu()
*EndModelDefaults()

Note Please refer to online help if you need to know more about the syntax.
Replace <working_directory> with the actual path on your machine to the working
directory, using forward slashes for the path, if necessary.
3. Save the file as mypreference.mvw in the <working directory>.
5. From File menu select Load > Preference File.
The Preferences dialog is displayed.
6. Click Register.
7. Select the file mypreference.mvw you created.
A new registered preference is added to the list.
8. Select the new preference and click Load.
9. Close the session and start a new one.
10. You should see a new menu My Scripts in the modeling client. This should be available every time
you open the MotionView session as long you have the preference file registered.
11. Click on My Scripts -> Build Simple Pendulum menu and run the script.

The complete script is given below for your reference:
## Macro to Build a Simple Model in MotionView ##
## Requesting for the Handles required to Use MotionView ##
hwi OpenStack
hwi GetSessionHandle sess
sess GetProjectHandle proj
proj GetPageHandle page [proj GetActivePage]
page GetWindowHandle win [page GetActiveWindow]
win GetClientHandle mc
win GetViewControlHandle vch
mc CreateBlankModel
mc GetModelHandle m
## Building the Model using the InterpretEntity statements ##
m InterpretEntity p Point p_0 "\"Pivot\""

m InterpretSet SetPoint p_0 0.0 0.0 0.0
p ReleaseHandle
m InterpretEntity p Point p_1 "\"Mass\""
m InterpretSet SetPoint p_1 p_0.x+100 p_0.y p_0.z
p ReleaseHandle
m InterpretEntity b Body b_0 "\"Pendulum\"" p_1

m InterpretSet SetBodyInertia b_0 0.5 100 100 100
m InterpretSet SetOrientation b_0.cm TWOAXES ZX
b ReleaseHandle
## Adding graphics to the pendulum and the Ground to improve result visualization
m InterpretEntity g Graphic gra_0 "\"Graphic_Pivot\"" CYLINDER B_Ground p_0

g ReleaseHandle
m InterpretEntity g Graphic gra_1 "\"Graphic_Pendulum_Cylinder\"" CYLINDER b_0
p_0 p_1 1 CAPBOTH
g ReleaseHandle
m InterpretEntity g Graphic gra_2 "\"GraphicMass_Cylinder\"" CYLINDER b_0 p_1
g ReleaseHandle
## Adding the Revolute joint between the Ground and the pendulum body
m InterpretEntity j RevJoint j_0 "\"Joint_Pivot_Rev\"" B_Ground b_0 p_0

V_Global_Y
j ReleaseHandle

m Evaluate
vch Fit
after 1000
## Running the Model ##
mc ExportModel simple_pendu.xml
mc RunSolverScript simple_pendu.xml
## Releasing All the Handles
m ReleaseHandle;
mc ReleaseHandle;
win ReleaseHandle;
page ReleaseHandle;
proj ReleaseHandle;
sess ReleaseHandle;
hwi CloseStack;
## End of Script

In this tutorial, you will:
Invoke a TCL script from MotionView. The TCL script automates the model building, solver
runs and post processing in MotionView.
Link the script to a Menu Item on the menu bar in MotionView.
Exercise: Automation using TCL

Step 1: Running the Script manually.
1. Start a new session.
2. From the View menu, click on Command Window.
A TkCon window opens up at the bottom of the screen.
The C ommand Window
3. Right-click in the Command Window and select File > Load File.
The Source File dialog is displayed.
4. Select the file simple_auto.tcl located in the automation folder.
5. Click Open.
Note The script does the following:
Builds a Simple Pendulum model.

Runs the model through the MotionSolve Solver (the pendulum is modeled to just swing
under gravity).
Creates new windows for Animation and Plotting and loads the animation results and the
plotting results in these windows.
Note You can also invoke the script by using the following steps:
In the Tk Console type cd <installation_directory>/tutorials/mv_hv_hg/

mbd_modeling/automation.
The Command Window acts like a UNIX shell.
Type in Source simple_auto.tcl and press Enter.

Step 2: Creating a Menu Item that invokes the script automatically.
The TCL-script simple_auto.tcl that was discussed in Step 1 can be linked to a Menu Item on the
MotionView Menu bar.
1. Open a new text file in a text editor.
2. Type in the following lines in the text file:

*Id("MotionView v12.0")
*BeginModelDefaults()
*BeginMenu(fut_mv_1050, "MotionView Tutorial Script")
*MenuItem(automation_tutorial, "Tutorial Script", TCL,

{ getenv("ALTAIR_HOME") + "/tutorials/mv_hv_hg/mbd_modeling/automation/
simple_auto.tcl" } )
*EndMenu()
*EndModelDefaults()
3. Save the file as script_invoke_menu.mvw and place at any convenient location on your
machine.
Note The script_invoke_menu.mvw file is a preference file.
A preference file is a special script file that is read each time the program is started. It
specifies default user settings such as the order in which colors are assigned, the default
printer, default page layout, the autosave interval, and so on. Custom menu options in
MotionView can be added using a preference file.
To learn more about the preference file, type preference file under the Index tab under the
Help menu.
To learn more about the preference file statements, type preference statements under the
Index tab under the Help menu.

4. In MotionView, go to the File menu and select Load > Preference File.
The Preferences dialog is displayed.
5. Click Register.
6. Open the script_invoke_menu.mvw that you created.
A new registered preference is added to the list.
7. Select the new preference and click Load.
8. A menu called MotionView Tutorial Script is added to the Menu bar, under which you will find
the Menu item Tutorial Script.
New menu item in HyperWorks Desktop - MotionView
9. Once this preference file is set, the new menu will appear every time HyperWorks Desktop is
invoked.
10. Start a new session of HyperWorks Desktop by pressing the SHIFT + F9 on your keyboard.
11. Check to make sure that the application is set to MotionView.
12. Click the Tutorial Script under MotionView Tutorial Script menu to invoke the script
simple_auto.tcl which in turn will make MotionView to perform the scripted operations.
Note If you no longer want your new menu item to appear on the menu bar, you can un-set the
preference file by going to the File menu and selecting Load > Preference File. From the
Preferences dialog, select script_invoke_menu.mvw and click on the Unregister button.
This will make MotionView unload the preference file.

Sequential Simulation allows you to write simulation instructions to change the model, modify the
solver settings and submit analyses.
This tutorials covers the following topics:
Fixed joint definition between non-coinciding points using marker definitions.

Using a sensor to activate the joint when two markers coincide during simulation.
Using Templex statements to:
o Deactivate a fixed joint when markers are non-coincident.
o Activate a fixed joint when markers coincide.
o Simulate until t = 5.00 seconds.
This tutorial illustrates how to build a model with sensor elements to capture the state of a body, use
the sensor signal to activate some joints and deactivate others, and carry out a sequential
simulation.
Exercise: Running a Sequential Simulation on a Model
Note Copy all of the files located in the mbd_modeling\interactive\sequential_simulation

folder to your <Working directory>.
Step 1: Creating joints, markers and sensors.

2. From the Standard toolbar, click the Open Model icon, .
OR
From the File menu, select Open > Model to open the model Sequential_simulation.mdl.

The model contains two bodies, namely a slider and a picker. You need to create markers, joints,
and a sensor as well as use Templex statements to perform a sequential simulation.
2. From the Project Browser, right-click on Model and select Add Constraint > Joint (or right-
click on the Joints icon, , from the toolbar). Under Type, select Translational Joint. Label
the joint slider trans.
3. For Body 1, select slider.
For Body 2, select Ground Body.
For Origin, select slider cg.
Define the Alignment axis using the point slider end.

4. Add another joint. For Type, select Fixed Joint and label the joint picker rest fix.
For Body 1, select picker.
For Body 2, select Ground Body.
For Origin, select part fix.
This joint will be deactivated when the slider body coincides with the picker body during
simulation.
When you create a fixed joint between the slider and the picker and they come in contact, you
need to define two markers which are initially not coincident, but coincide during the course of
simulation. Creating a joint based on markers must be done using Templex, as it is not possible to
create it from the user interface.
5. From the Project Browser, right-click Model and select Add Reference Entity > Marker (or
right-click on Marker icon, , from the toolbar). Label it Marker Slider Track and set the
properties as shown in the image below:
6. Similarly, create another marker with the label Marker Picker Track and set the properties of
the markers as shown in the image below:
7. From the Project Browser, right-click Model and select Add Control Entity > Sensor (or right-
click the Sensor icon, , from the toolbar) to add a new sensor.

8. From the Signal field, select the type as Expression and enter the following expression:
`DX({the_model.m_0.idstring},{the_model.m_1.idstring})`
9. In the Compare to field, enter 0.0010 for the Value and 0.0010 for Error. Set Respond if to
Signal is greater than VALUE - ERROR.
10. In the Response field, select Return to Command File.
This directs the solver to look into the template for further instruction on how to proceed once
the signal is attained.
11. From the Project Browser, right-click on Model and select Add Constraint > Motion (or right-
click on the Motion icon, , from the toolbar. Set the properties as shown in the figure below.
Step 2: Creating a fixed joint between two non-coincident markers using

Templex.
1. To create a fixed joint between the slider and picker that is activated once the distance between
the slider and picker is zero, from the Project Browser, right-click on Model and select Add
General MDL Entity > Template (or right-click on the Template icon, , from the toolbar).
2. Label it Fixed Joint Defn. For Type, select Write text to solver input deck. Enter the
following commands as they are listed below in the same order.
<Constraint_Joint
id = "5000"
type = "FIXED"

i_marker_id = "{the_model.m_0.idstring}"
j_marker_id = "{the_model.m_1.idstring}"
/>
The panel should look like this:
Step 3: Creating a template to define the sequential simulation.

In this step, you will write a template to do the following:
Set the type of Output files to be written after the simulation.

Deactivate Joint between Slider and Picker for the initial simulation.
Perform a transient analysis for 3.5 seconds.
Activate Joint between Slider and Picker.
Deactivate Joint between Picker and Ground.
Deactivate the Sensor Element.
Run a transient analysis for 5 seconds.
1. From the Project Browser, right-click on Model and select Add General MDL Entity >
Template (or right-click the Template icon, , from the toolbar).
2. Set the Type as Write text to solver command file.
3. Type the following commands as listed below.
<ResOutput
plt_angle = "YAW_PITCH_ROLL"
/>
<ResOutput
mrf_file = "TRUE"
/>
<ResOutput
plt_file = "TRUE"
/>

<H3DOutput
switch_on = "TRUE"
increment = "1"
/>
<ResOutput
abf_file = "TRUE"
/>
<Deactivate
element_id = "5000"
/>
<Simulate
end_time = "3.5"
/>
<Deactivate
element_id = "{the_model.j_1.idstring}"
/>
<Deactivate
element_type = "SENSOR"
element_id = "{the_model.sen_0.idstring}"
/>
<Activate
element_id = "5000"
/>
<Simulate
end_time = "5."
/>
<Stop/>

Step 4: Running the simulation and animating the results.
1. Click the Run Solver button, , and activate the Export MDL snapshot check box. This will
save your model file and export the solver data.
2. Click the Save and run current model button, , and enter a name for the solver run file. This
will save the model in the current state to run_xml_snapshot.mdl, where run_xml is the base
name of the solver run file being provided in the next step.
3. Set End time as 5 and the Print interval as 0.01.
4. Click the Simulation Settings button. In the pop-up dialog, from the Transient tab, select
DSTIFF for the Integrator type. Click Close.
5. From the Main tab, click Run.
6. Once the solver procedure is complete, the Animate button on the Main tab is activated. Click
Animate to animate the model. Click to start the animation and to stop the animation.

MV-3010: Optimization using MotionView - HyperStudy

In this tutorial, you will:
Use Hyperstudy to set-up a DOE study of a MotionView model

Perform DOE study in the MotionView HyperStudy environment
Create approximation (using the DOE results) which can be subsequently used to perform
optimization of the MotionView model
Theory
HyperStudy allows you to perform Design of Experiments (DOE), optimization, and stochastic studies in
a CAE environment. The objective of a DOE, or Design of Experiments, study is to understand how
changes to the parameters (design variables) of a model influence its performance (response).
After a DOE study is complete, approximation can be created from the results of the DOE study.
The approximation is in the form of a polynomial equation of an output as a function of all input
variables. This is called as the regression equation.
The regression equation can then be used to perform Optimization.
Note The goal of DOE is to develop an understanding of the behavior of the system, not to find an
optimal, single solution.
HyperStudy can be used to study different aspects of a design under various conditions, including
non-linear behavior.
HyperStudy also does the following:
Provides a variety of DOE study types, including user-defined

Facilitates multi-disciplinary DOE, optimization, and stochastic studies
Provides a variety of sampling techniques and distributions for stochastic studies
Parameterizes any solver input model via a user-friendly interface
Uses an extensive expression builder to perform mathematical operations
Uses a robust optimization engine

Includes built-in support for post-processing study results
Includes multiple results formats such as MVW, TXT for study results

Tools
In MotionView, HyperStudy can be accessed from
The Main-Menu under Applications ->HyperStudy

You can then select MDL property data as design variables in a DOE or an optimization exercise.
Solver scripts registered in the MotionView Preferences file are available through the HyperStudy
interface to conduct sequential solver runs for DOE or optimization.
For any study, the HyperStudy process is shown below:
The HyperStudy process

MotionView MDL files can be directly loaded into HyperStudy. Any solver input file, such as ADAMS,
MotionSolve, OptiStruct, Nastran, or Abaqus, can be parameterized and the template file submitted as
input for HyperStudy. The parameterized file identifies the design variables to be changed during DOE,
optimization, or stochastic studies. The solver runs are carried out accordingly and the results are
then post-processed within HyperStudy.
Copy the files hs.mdl and target_toe.csv, located in the mbd_modeling\doe folder, to your
In the following steps, you will create a study to carry out subsequent DOE study on a front SLA
suspension model.

While performing a Static Ride Analysis, you will determine the effects of varying the coordinate
positions of the origin points of the inner and outer tie-rod joints on the toe-curve.
Step 1: Study Set-up.

2. Click the Open Model icon, , on the Model-Main toolbar.
Or
From the menu bar, select File > Open > Model.
3. Select the file model hs.mdl, located in your <working directory>, and click Open.
4. Review the model and the toe-curve output request under Static Ride Analysis.
5. From the Applications menu, select HyperStudy.
HyperStudy is launched. The message "Establishing connection between MotionView and

Hyperstudy" is displayed.

6. Start new study using one of the following ways:
From the Welcome page, click on the New Study icon, .
Or
From the toolbar, click the New Study icon, .
Or
From main menu, select File > New. The HyperStudy - Add Study dialog is displayed.
Accept the default label and variable names.
Under Location, click the file browser and select <working directory>\.
Click OK.
7. Model definition.
From the study Setup tree, select Define models.
Click to open the Add Model dialog.
Under Type, select MotionView to add a MotionView model to the study.
Accept the default variable name.
Click OK.
The following table with model data is created.

8. Model data.
Please note that following details are automatically filled when you define the model (previous
step).
o Under Active, check the box to activate or deactivate the model from study.
o The label of model entered in previous step.
o The variable name of model entered in the previous step.
o The model type selected in previous step.
o Point to the source file (here model file is sourced from MotionView through the MotionView
HyperStudy interfacing)
Enter a name for the solver input file with the proper extension (for Motionsolve ->.xml) and
select the solver execution script MotionSolve - standalone ( ms ).
9. Create design variables.
Click Import Variables to specify the design variables for the study.
The Model Browser window opens in MotionView, allowing you to select the variables
interactively.
Select the following from the Browser using the Model Parameter Tree dialog:
System Point Coordinate Function
Front SLA susp. Otr tie-rod ball-jt -left Y Double-click or Click Add
Front SLA susp. Otr tie-rod ball-jt left Z Double-click or Click Add
Parallel Steering Inr tie-rod ball - left Y Double-click or Click Add
Parallel Steering Inr tie-rod ball - left Z Double-click or Click Add

Model Parameter Tree dialog
Click Done.
Click Next to go to Define Design Variables.
10. Define design variables.
From the Define design variables tab, edit the upper and lower bounds of the design variables
according to the following table.
Point Coordinate Lower Upper
Outer tie-rod ball-jt -left Y -571.15 -559.15
Outer tie-rod ball-jt - left Z 246.92 250.92
Inner tie-rod ball - left Y -221.9 -209.9
Inner tie-rod ball - left Z 274.86 278.86

This step also includes definition of other properties to the design variables. The options Details
and Distributions specify variations of design variables in the range specified. The option Link
Variables is used to link different design variables through a mathematical expression.
Click on each tab to observe these options.
Right click on the column header row to view more options that you may want to add.
- Click Next to go to Specifications.

11. Specifications.
This section allows you to specify the initial run for DOE.
Select the Nominal Run radio button for this study and click the Apply button.
Click Next to go to Evaluate.
12. Evaluate.
Click Evaluate Tasks to perform the nominal run.
Make sure that all settings for the run (Write, Execute and Extract) are activated.
MotionSolve runs in the background and the analysis is carried out for the base configuration.
Please note the messages in status bar of the HyperStudy interface and the MotionView
interface. If message log is not visible, click the Message log button, , or go to View >
Message log to display the log.
Once the nominal run is complete, click Next to go to Define responses.
13. Define Response.
Click Add Response to add a new response.
Label the response Sum of Squared Error.
Accept the variable name and click OK.
Response table data
Click the ellipses, , in the Expression cell of Response table to launch the Expression
Builder.

Expression builder
Note: You can move the cursor over the function to display the function help.
For this exercise, the response function requires two vectors:
The elements of Vector 1 contain actual data points of the toe curve from the
solver run for the nominal configuration.
The elements of Vector 2 contain data points from the target curve.
Click the File Sources tab to source the data from the files.
Vector 1:
Click to display the HyperStudy - Add dialog box.

Accept the default label and variable name.
For Select Type, select Solver output file.
Click OK.
Response data table
Click the ellipses, , in the File cell of vector table data to launch the Vector Source
(Vector 1(v_1)) dialog box.
Click the file browser button, , and select the file m_1.mrf from <working directory>
\approaches\nom_1\run__00001\m_1\.
This enables the Type, Request and Component fields.
From the Type drop-down menu, select Expressions.
From the Request drop-down menu, select REQ/70000033 toe-curve.
From the Component drop-down menu, select F2.
Vector 1 source dialog box
You have now selected the toe curve data from the solver run as the data elements for Vector
1.

Click on the arrow button, , on the right side of the dialog box to expanding the vector
dialog box and preview the curve.
Expanded dialog box of Vector 1 source
Click OK.
Vector 2:
Create a vector to hold the data elements from the target toe curve.
Click Add File Source to display the HyperStudy - Add File Source dialog box.
Accept the default label and variable name.
For Select Type, select Reference file.
Click OK.
Response data table

Click the in the File cell of the Vector 2 table data to launch the Vector Source (Vector
2(v_2)) dialog box.
Click the file browser button, , and select the file target_toe.csv, located in your
<working directory>\.
Set Type to Unknown and Request to Block 1.
From the Component drop-down menu, select Column 1.
Click OK.
14. In the Expression field, create the following expression:
sum((v_1-v_2)^2)
This expression evaluates the sum of the square of the difference between the actual toe
change values (from solver run) and the targeted toe curve (from imported file). In the next
tutorial, MV-3010, we will use HyperStudy to minimize the value of this expression to get the
required suspension configuration.
15. Click Evaluate expression to verify that the expression is evaluated correctly. You should get a
value of 16.289.
16. Click OK.
If you do not encounter any error messages and were able to successfully extract the response
for the nominal run, click Next to go to Post Processing.
Observe the table with the design variable values used for the nominal run and other tabs with
the post-processing options.
Click Next to go to Report.
Observe various reporting formats available. The images and data captured during the post-
processing can be exported in any of the formats provided on Report page.
16. From the File menu, select Save As .
17. Save this study set-up as Setup.xml to your <working directory>\.

Step 2: DOE Study.
1. Adding new DOE study.
Right-click in the Explorer browser area and from the context menu, click Add Approach
to display the Add Approach dialog.
Or
From the Edit menu bar, click the Add Approach option to display the HyperStudy - Add
dialog.
Under Select Type, select Doe.
Accept the default label and variable name and click OK.

The DOE study tree is displayed in the Browser with name Doe 1.
Click Next to go to Select design variables.
2. Select design variables for the DOE study.
All variables are used in the present DOE study, so make sure that all design variables are
active.
All the design variables in this study are controlled. Therefore, for Category, leave all variables
set to Controlled.
Click Next to go to Select responses.
3. Select responses for the DOE study:
There is only one response in the present study - make sure to select the response.
Click Next to go to Specifications.
4. Specifications for the DOE study:
The design space for the DOE study is created in this step. The present study has four design
variables with two levels each. A full factorial will give 24 = 16 experiments, as the number of
experiments are less. We will do a full factorial run. Selecting any mode from the list shows all
possible options in the Parameters panel area on the left side of GUI.
Click the Levels tab to see the design variables and number of levels.

Click the Interaction tab to observe that all interactions are selected as it is a full factorial run.
Note: Options which are not applicable will be grayed out or a message will be shown.
5. Click Apply to generate the design space.
6. Click Next to go to Evaluate.
DOE run:
The Tasks tab of Evaluate shows a table of 16 rows and four columns. Column 1 shows the
experiment number while other columns corresponding to each experiment get updated with the
experiment status of failure or success in the three stages of model execution: Write, Execute
and Extract.
Design variable values used under each experiment can be seen under the Evolution Data tab.

The last column corresponds to the response value from each run. The values gets populated
once the run is completed.
Click Evaluate Tasks to start the DOE study.
Once all the runs are finished, the tasks table gets filled up with the status for each run
(Success/Fail).
In the present DOE study, all runs are successfully completed. Click Next to go to Post
Processing.
7. Viewing Main Effect and Interaction plots:
The post-processing section has variety of utilities to helps user to effectively post process
results. Run Summary tab of Post processing page will provide a summary of design along with
responses.
The New Generation HyperStudy allows you to sort data by right-clicking on the column heading
and selecting the options from context menu.
The options to post-process are available in other tabs. The main effects can be plotted by
selecting the Linear Effects tab.

Main Effects:
Click the Linear Effects tab to open the main effects plot window. From the Channel page,
select Variables and Responses for which main effects need to be plotted. Press the left
mouse button and move over the variable or responses list for multiple selection.
Select all controlled variables and responses to plot the main effect plot. This plot shows the
effect of each parameter on the response.
DOE Main effects plot
Note: Click on window icon, , (highlighted above) to toggle it to multiple windows, . Each
curve is displayed in a different plot window.
Interactions:
Interactions can be plotted from the Interactions tab following the above procedure. Here, we
will use the post-processing window to plot the interactions. Click Launch Post Processing to
display the Post-processing window.
Display the Regressions in one of the following ways:
From the toolbar, click the Display regressions icon, .
Or
From main menu, select Display > Regressions.
Click the Interactions radio button.
By default, all interactions are displayed.
Click View to select the design variables Otr_tierod_ball_jt-left-z and

Inr_tierod_ball_jt-left-z.

Under Display on the left side of the page, change the variables type from All Variables to
Controlled Variables from the drop-down menu next to View button. This displays the
interaction plot for these two variables only.
C ontrolled design variable plot for Otr_tierod_ball_jt-left-z & Inr_tierod_ball_jt-left-z interaction
Click Close.
Close the Post Processing application. Confirm the request to quit the application.
Step 3: Approximation.
System response is approximated by using various curve fitting methods. An approximation for the
response with the design variables variation is calculated using the data from above DOE study. The
accuracy of the approximation can be checked and improved.
1. Adding an approximation.
Right-click in the Browser area and from the context menu, click Add Approach to display the
Add Approach dialog.

Under Select Type, select Fit.
Accept the default label and variable names and click OK.
A new tree with the name Fit 1 is created in the Browser.
Click Next.
2. Input matrix.
Click to display the HyperStudy - Add dialog.
Accept the default label and variable names.
Click OK.
A matrix table is created. Select the following options to specify the DOE results as the input
matrix.
Under Type, use the drop-down menu to select Input.
For Matrix Source, select Doe 1 from the drop-down menu.

In the present study, we are not using any validation matrix. So, no matrix will be added for
validation matrix.
Observe that the status shows Import pending.
Click Import Matrix to import the DOE results for the input matrix.
Click Next to go to Select design variables.
Select all design variables and click Next to go to Select responses.
Select the response and click Next to go to Specifications.
In this section, the approximation type and its properties are defined.
Select Moving Least Squares (SMLS):
Click Apply to apply the approximation method.
Click Next to go to Evaluate.
Observe an empty Tasks table which corresponds to the DOE experiments.
Click Evaluate Tasks to evaluate the approximation for the DOE experiments.
Upon completion, the table is populated with the status value (Success or Fail).
Click the other tabs available to observe the fit.
Click the Evolution Data tab to observe the experiment table with responses from the
MotionSolve run and responses predicted using approximation. The same can be viewed in
graph format by selecting the Evolution plot tab.
Select Sum of Squared of Squared Error and Squared of Squared Error_MLSM to plot
against the experiment numbers.

This fit shows a good approximation to the response.
Click Next to go to Post Processing.
Post-processing provides you with statistical parameters and graphical tools useful in validating
the correctness of approximation.
The Residuals tab shows the difference between the response value from the solver and the
response value from the regression equation.
The residual values can be used to determine which runs are generating more errors in the
regression model.
The Trade-off 3D tab shows the plots of the main effects vs. response from the approximation.
Trade-off: 3-D plots
From the toolbar, click the Save icon, , to save the study.
Note All study files will be saved in the study directory with the folder names that are the same as
the tree varnames. For example, nom_1,doe_1 and fit_1.

MV-3010: Optimization using MotionView -
HyperStudy
In this tutorial you will,
Perform an optimization study in the MotionView-HyperStudy environment

Compare the baseline and optimized models
Theory
In general, an optimization problem consists of:
The design constraints
The objective function

The design variables
Design variables change during optimization. The design variables always have a certain range within
which they can be modified. Typical examples of design variables are thickness of shell elements,
shape vectors, and masses.
The changes in the design variables cause some change in model responses. Such responses can
become either objective function or design constraints. Examples of such responses include
displacements and forces.
The response to be minimized or maximized becomes the objective function, while the rest of the
responses that need to be within a certain tolerance range become constraints. Only one response
can be defined as objective function.
HyperStudy can be used to set-up and perform an optimization study on a MotionView model. You can
also use HyperStudy to perform optimization studies involving both linear and non-linear CAE analysis
as well as perform optimization of mathematical equations using Templex. HyperStudy creates the
input parameter files using Templex and provides iterative changes to them during the optimization
process. HyperStudy uses HyperOpt (a general purpose, wrap around software) as the optimization
engine to perform optimization, in conjunction with both linear and non-linear CAE analysis software.
HyperOpt uses a robust sequential response surface methodology for optimization.
The files needed for this tutorial are hs.mdl, target_toe.csv (used in tutorial MV-3000); Setup.xml
saved in tutorial MV-3000 and the nom_run folder created in tutorial MV-3000.
These files should be in the <working-directory> that was used in tutorial MV-3000.
Note: If you copy the Setup.xml file from the above location, the path in the <Folder> tag in the
file needs to be edited to point to your <Working directory>.
In the following steps you will perform an optimization study on a front SLA suspension model and
determine the optimum coordinate positions of the inner and outer tie-rod points while trying to
achieve a target toe curve. The baseline model will then be compared with the optimized model.
Step 1 Optimization Study.

2. Open the model hs.mdl, located in <working directory>.
3. Review the model and the toe-curve output request.

4. From the SolverMode menu make sure that MotionSolve is selected.
5. From the Applications menu, launch HyperStudy.
6. Click on open file icon, , browse to your study directory and select Setup.xml file created
during the MV-3000 tutorial.
7. Add a new optimization study:
Right-click in the Explorer Browser area and from the context menu, click Add Approach to
launch the HyperStudy - Add dialog box.
Or
From the Edit menu bar, click the Add Approach icon, , to launch the HyperStudy - Add
dialog box.
Under Select Type, select Optimization.
Accept the default label and variable name and click OK.
The Optimization tree displays in the explorer with name Optimization_1.
Click Next to go to the Select design variables.

8. In the Define design variables panel, verify that all the design variables are checked.
This panel displays all the variables and their upper and lower bounds.
9. Click Next to go to the Select responses.
Click to launch the HyperStudy - Add Objective dialog box.
Accept the default label and variable names and click OK.
In this exercise, minimize the Sum of Squared Error response function to obtain optimum values
for the design parameters: the Y and Z coordinate positions of the inner and outer tie-rod points.
Check to make sure that the type is set as Minimize from the drop-down menu.
Check to make sure that the Evaluate From option is set to Solver.
10. We will not have any constraints and unused responses in our design, so click Apply and then
click Next to go to Specifications.
Accept the default Optimization Engine: Adaptive Response Surface Method and click Apply
and Next. The Maximum iterations and Convergence criteria are specified in the same dialog.
11. Click Apply and Next to go to Evaluate.
12. Click Evaluate Tasks to start the optimization.
MotionSolve is launched sequentially and the HyperOpt engine attempts to find a solution to the
problem.
Once the optimization is complete, an Iteration table is created with status of each run. The
present study took nine iterations to achieve the target. Browse through the other tabs of this
page to get more understanding of the iteration history.

13. Click on the Iteration Plot 2D tab.
14. From the list on the right side of the GUI, select the Objective function named Objective_1 .
This plots the objective function value against the iterations.
Optimization history plot
In this panel, you can see the plots variations in the values of the objectives, constraints, design
variables, and responses during different design iterations. The Iteration History Table displays
the same data in a tabular format.
Note that in this study, iteration 6 is the optimal configuration.
Save your study to <working directory> as Study_2.xml.
15. Close the HyperStudy.

Step 2: Comparing the Baseline and Optimized Models.
1. Add a Page to your MotionView session.
2. From the Select application drop-down menu, select HyperView.
3. Load the animation file <working directory>\approaches\nom_1\run__00001\m_1\m_1.h3d

using the Load Model panel.
4. Click the Page Layout icon on the toolbar and select the two-window layout.
5. In the second window, switch to HyperGraph.
6. Click the Build Plots icon on the toolbar.
7. Use the Build Plots file browser and select the file target_toe.csv, located in the <working
directory>.
8. For X-axis data, select:
Type = Unknown
Request = Block 1
Component = Column 1
9. For Y-axis data, select:
Type = Unknown
Request = Block 1
Component = Column 2
10. Click Apply.
11. Using the file browser on the Build Plots panel, select the file <working directory>
\approaches\nom_1\run__0001\m_1\m_1.abf
12. For X-axis data, select:
Type = Expressions
Request = REQ/70000033 toe-curve
Component = F2
13. For Y-axis data, select:
Type = Expressions
Request = REQ/70000033 toe-curve
Component = F3
14. Click Apply.

15. Plot another curve from the file
<working directory>\approaches\opt_1\run__00006\m_1\m_1.abf using steps 11-14
You should end up with a session looking like the one shown below. Notice the optimized toe-
curve.
Optimization results
You may also overlay the animation of the optimal configuration (run 6) over the nominal run.
Notice the toe angle differences.
Save the session as opt_toe.mvw.

Durability - Fatigue

The Load Export utility allows you to bridge the gap between Multi-Body Dynamics (MBD) analysis
and Finite Element (FE) analysis using MotionView by:
Identifying and summarizing all loads acting on one/multiple body(ies) for any given time
step(s) in a tabular format.
Identifying and transferring all the forces and moments for one component at any given time
step(s) to a NASTRAN input deck that contains GRID, CORD, FORCE, and MOMENT cards.
Using Load Export

To use this utility, specify the components in the MotionView model for which loads are to be
processed. You can do this by:
Using the MotionView Interface.

OR
Editing the MDL model file to add force output requests on body(ies).
When performing the MS/ADAMS solver run on the MotionView model, you will get a metadata file (an
ASCII file written out from MotionView that contains information about force output on a body).
This file along with the solver output files viz. MS (*.plt) or ADAMS (*.req) become the input files for
this utility. The application scope of this utility is shown in the figure below:
Interaction diagram

Step 1: Creating a Metadata File and Launching Load Export.
1. Copy the load_export.mdl file, located in the mbd_modeling\externalcodes folder, to your
3. Load the front vehicle model file load_export.mdl, located in <working directory>.
4. Right-click on The Model in the Project Browser and select Add General MDL Entity > Output,
or right-click the Outputs icon, , on the Model-General toolbar.
5. Accept the default selections and click OK.
6. Use the drop-down menu to change the Output type from the default Displacement to Force.
7. Double-click the Body collector.
8. Expand the model-tree.
9. In the Frnt macpherson susp system folder, expand the Bodies folder and select the body Lwr
control arm left. (or you can pick the Lwr Control arm - left directly from the model in the
graphics area by clicking the Body collector once).
10. Repeat steps 4 through 9 to create an output force request on Lwr control arm right.
11. Click the Run Solver icon .
12. From the Main tab, change End Time to 2 seconds.
13. Save the solver input file as load_export.xml, to the <working directory>.
14. Click on the Run button, to solve the model in MotionSolve.
MotionView creates a metadata file named load_export.meta in the <working directory>.

Step 2: Using the Load Export Utility and Generating a NASTRAN Input Deck.
1. From the Flex Tools menu, select the Load Export utility.
Launching the Load Export utility
The Load Export utility

2. From the Load Export panel, open the file load_export.meta, located in <working directory>.
All bodies for which force outputs are requested are displayed in a tree structure in the Body
Selection panel. You can select one or multiple bodies from the tree. In this step select the
body Lwr control arm-left.
Body Selection panel
3. Expand the sys_frnt_susp folder and select the body Lwr control arm left.
All the forces acting on the lwr control arm left are displayed in the Force Selection panel.
You can choose any number of loads acting on the body. Only the loads selected by you are
exported by the utility.
4. Select all three forces acting on Lwr control arm left.
Force Selection panel
5. The Time Selection panel allows you to enter/select the time steps for which the loads are to be
exported.
6. Click the Range button.
7. The current simulation runs from 0 to 2 seconds. Specify a Minimum Time Step Value of 1 and
a Maximum Time Step Value of 2.
Activating the Export panel

8. Click Apply.
9. Enter Min/Max Time Step Values.
10. Click Apply on the Time Selection panel.
This activates the Export panel.
Note After time step input, you must click the Apply button to verify the validity of the time
steps. If a time step entered is not present in the ADAMS request file, an error message
is generated and you must make appropriate corrections.
11. Select OPTISTRUCT/NASTRAN [1] by using the radio button under the Export panel.
Nastran options

12. Click Nastran Options [2] to launch the Nastran Export Panel.
This dialog allows you to enter the Nastran node ID numbers in the second column of the table.
You can specify three additional options:
the Nastran deck format (Large/Small)
the reference frame (LPRF/Global) in which the GRID cards are written
whether or not to explicitly output the CORD1R card in the Nastran input deck (Yes/No)
13. Accept the default selections in the Nastran Export dialog.
14. Specify the Node IDs as follows:
o Lwr ball joint 1
o LCA rear bush 2
o LCA frnt bush 3
15. Click Apply.
16. Click Export on the Load Export panel.
17. Specify a filename.
18. Click Save.
This creates a subcase file, in addition to the Nastran input deck, in the same directory as the
.dat file.

19. Repeat steps 3 through 18 to export the loads on the Lwr control arm right.
Note In point 2 above, if you select multiple bodies, the Nastran Export Panel will look as shown
below:
Nastran Export Panel for multiple body selection

Convert results from a multi-body simulation run into file formats which can be used for fatigue
analysis using a tool like NCode
Write a fatigue analysis file from the MotionView animation window (HyperView)
Tools
The following functionalities are used in this tutorial: Fatigue Prep, Flex File Gen, and build plots.
The Fatigue Prep feature can be accessed by:
On the Flex Tools menu, click Fatigue Prep.
This panel translates the following files:
Original Format Translated Format
Altair .H3D flexbody (modal content) Ncode .FES/.ASC
Ncode .DAC Altair .ABF
ADAMS .RES (modal participation factors) Ncode .DAC
ADAMS .REQ files (loads information) Ncode .DAC
Altair .PLT Ncode .DAC
ADAMS .REQ files (loads information) MTS .RPC

The Flex File Gen feature can be accessed by:
On the Flex Tools menu, click Flex File Gen.
The Flex File Gen feature allows you to create an .flx file using the Flex File Gen tool. This file
references a .gra file (rigid body graphics), a .res file (flex and rigid body results), and .H3D files
(flexbody graphics). These files are required to animate ADAMS results that contain flexbodies. The
.flx file can be loaded directly into the animation window.
The build plots feature can be accessed by:
Go to the HyperGraph client, and click the build plot icon, .

The Build Plots panel constructs multiple curves and plots from a single data file. Curves can
be overlaid in a single window or each curve can be assigned to a new window. Individual
curves are edited using the Define Curves panel.
Step 1: Using the Fatigue Prep Wizard.

2. Select the MBD Model window.

3. From the FlexTools menu, select Fatigue Prep.
Fatigue Prep Wizard
The form shown above, describes the set of file translations possible using the Fatigue Prep
wizard.
4. Use the drop-down menu to select the H3D to FES option.
5. Click Next.
6. Specify the H3D file as sla_flex.h3d, located in the mbd_modeling\durability_fatigue folder.
7. Specify the FES file as <working directory>\sla_flex_left.fes.
Fatigue Prep Wizard

8. Click Finish.
The Altair flexible body pre-processor is launched and the FES file is created in your working
directory.
Using the Fatigue Prep wizard, you can convert your results files to .fes, .asc or .dac files.
You can use these files for fatigue and durability analysis in Ncodes FE-Fatigue software.
Step 2: Converting ADAMS results from a REQ file to a DAC file.

The Fatigue Prep translator can be used to convert the request files created from an ADAMS run to
DAC files. These DAC files can be further used for fatigue or durability analysis.
2. Select the MBD Model window.
3. From the FlexTools menu, select Fatigue Prep.
4. Select the REQ to DAC option.
5. Click Next.
6. Click the file browser button attached to Select req file and select indy.req from the
durability_fatigue folder.
Note The DAC file format does not support unequal time steps since only frequency is
specified, not each time step. Therefore your REQ file needs to have equal output time
steps.
7. Click on the file browser attached to Select DAC file and specify indy.dac as an output filename
in <working directory>\.
8. Under Y type, select Displacement.
Once you select Displacement, Y requests and Y components will populate the text boxes.

9. Select first five Y requests and the first three Y components.
REQ to DAC translation
Note You can select any number of Y requests and Y components for REQ2DAC conversion.

10. Click the Finish button.
The message Translation complete is displayed on the screen.
MotionView generates 15 DAC files for each combination selected.
11. Click Cancel and close the window.
12. Change the application to HyperGraph 2D.
13. From the Build Plots panel, load the file indy_D_997000_X.dac from <working directory>\.
Note In this filename, D represents Displacement, 9970000 represents the request number, and
X represents the component. This is how you get the information about the DAC file you
are plotting.
14. Click Apply to see the plot.
You may plot the corresponding request from the original REQ file for comparison.
Step 3: Using the Flex File Tool.

2. From the Flex Tools menu, select Flex File Gen.
3. The Flex File Generator dialog is displayed.
This dialog lists the files you will need for this conversion.
4. Using the Save the *flx file as file browser, select your destination file to be <working-dir>
\sla_flex.
5. In the Number of FlexBodies field, enter 2 since this model includes two lower control arms as
flexible bodies.
6. From the Select model source (*.gra) file browser, select the sla_flex.gra file located in the
durability_fatigue folder.
7. From the Select result source (ASCII *.res) file browser, select the sla_flex.res file located in
the durability_fatigue folder.
8. Using the first file browser under Select flexible body source (*.h3d), select the sla_flex.h3d
file located in the durability_fatigue folder.
9. Using the second file browser under Select Flexible Body Source (*.h3d), select the
sla_flex_m.h3d file located in the durability_fatigue folder.

10. Under ID: field, enter 10404 and 20404 for the two h3ds, respectively.
These values should correspond to the actual IDs of the flexible bodies in the ADM input deck of
the ADAMS solver.
The deformation of these flexible bodies during animation can be scaled using the Def. Scale field.
In this case, accept the default value of 1.000.
11. Click OK.
The translator is launched and the resulting FLX file is created in the destination directory.
12. Select the TextView window from the Select application list.
13. Click the arrow next to the Open Session icon, , on the Standard toolbar and select Open
Document .

14. Open the sla_flex.flx file.
You should see the following contents of the FLX file:
Note To load transients results for selected time intervals check the Optional flx statements
check-box to enter the Start Time, End Time and Increment.
To load selected mode shapes from modal animation files for models with one or more
flexible bodies, check the Optional flx statements for linear analysis check-box to
enter the Start Mode and End Mode.
Additional statements are inserted in the FLX file reflecting the above mentioned
parameters.
Step 4: Viewing Fatigue Results in the Animation Window.
1. Select HyperView using the Select application option on the toolbar.
2. Use the Open drop-down menu on the Standard toolbar (click the arrow next to the Open
Session icon ) to select Open Model .
3. Use the Load model file browser to select the file, sla_flex.flx that you just created. The
Load result field automatically populates with the same file name.
4. Click Apply.
5. Click the Start/Pause Animation icon, to animate the model.
Observe the animating model, which is a combination of rigid multi-bodies and two flexible lower
control arms.
6. Click the Contour icon, on the Results toolbar.
7. Choose different options from the Result Type drop down menu, to view the various results
available in the analysis result files.
For a detailed description of writing a fatigue analysis file from here, refer to the Fatigue Manager
topic in the HyperView Users Guide.

MV-2100: Introduction to Non-Linear Finite Element (NLFE) Analysis in MotionSolve
MV-2110: Using an NLFE Helical Spring in a Cam-Follower Mechanism

MV-2100: Introduction to Non-Linear Finite Element
(NLFE) Analysis in MotionSolve
In this tutorial, you will learn the following:
A brief introduction to Non-Linear Finite Element formulation used in MotionSolve.

Modeling NLFE bodies in MotionView.
Introduction
Starting in version 14.0, MotionSolve introduced a new form of flexible body referred as Non Linear
Finite Elements (NLFE). Unlike the conventional flexible body, where the body is represented in a
modal form, NLFE is modeled in a direct Finite Element form.
NLFE Formulation
MotionSolve uses Absolute Nodal Coordinate Formulation (ANCF) to model large displacement and large
deformation (NLFE) bodies. The absolute nodal coordinate formulation[1 ] is developed based on finite
element formulation and is designed for large deformation multibody analysis. In the absolute nodal
coordinate formulation, slopes and displacements are used as the nodal coordinates instead of
infinitesimal or finite rotations.
ANCF uses the shape function matrix, together with the nodal coordinates to describe arbitrary rigid
body motion. For these reasons, the absolute nodal coordinate formulation leads to a constant mass
matrix in two- and three-dimensional cases. The constant mass matrix simplifies the nonlinear
equations of motion and, consequently, accelerates the time integration of the nonlinear equations of
motion.
Below is a standard beam model[2 ] described in 2D plane using ANCF.
EulerBernoulli beam element
Displacement field, y(x) = s1(x)y 0+ s2(x)y0 +s3(x)y 1+ s4(x)y1
Where,
s1 to s4 are shape functions of beam.
x0, y 0, x1, and y 1 are nodal coordinates of 2 grids.
y0 and y1 are slope coordinates (gradients) at 2 grids.

The absolute nodal coordinate formulation has been applied to a wide variety of challenging nonlinear
dynamics problems that include belt drives, rotor blades, elastic cables, leaf springs, and tires.
Non-linear finite element capabilities of MotionSolve

All type of linear and non-linear elasticity is supported i.e. Isotropic, Orthotropic, Anisotropic
and Hyper elasticity.
Geometric stiffening induced due to elastic forces.
Modeling non-linear behavior above the elasticity limit (like plastic deformation, strain hardening,
fracture etc.) is not supported. In the current version, MotionView supports modeling of 1D line
elements only (Beam and Cable elements). Beam elements can have 18 types of cross-sections and
the dimensions of the cross-section can be changed linearly in the axial direction. Beam elements can
resist axial, shear, torsion and bending loads. The Cable element maintains a constant cross-section,
thus it can resist only axial and bending loads.
This tutorial has two exercises:
1. Cantilever beam bending.

2. Uniaxial tension of rubber.
Exercise 1
In this exercise, you will model a 1m long cantilever beam with a cross-section dimension of
110mmx14mm to perform a bending test and compare it with an analytical solution.
Copy the centerline.csv file, located in the mbd_modeling\nlfe\intro folder, to your <working
directory>.
C antilever beam under end load condition
Step 1: Modeling a Beam with Linear Elastic Material.

2. Right-click on the Body icon in the Model-Reference toolbar.
3. Specify the label as Cantilever Beam.

4. Specify the variable name as nlfeb_cantilever.
5. Select NLFE Body from the drop-down menu.
The NLFE Body is displayed with the Properties tab active.
The following table lists the various tabs available in the NLFE Body panel:
Tab name Sets NLFEBody
Properties Type (Beam/Cable), Cross-section, and material properties
Connectivity Center line data or body profile
Orientation Start and End orientations
Mass Properties Displayed for information only
Initial conditions Initial velocities

7. From the Properties tab, define the properties as listed below:
Type: Beam
Cross section: Bar
dim1: 14.0
dim2: 110.0
The panel also displays the image of the cross-section indicating what the different dimensions
(dim1 and dim2) refer to.
Note The Properties tab has two sub-tabs called Start and End. These sub-tabs are used
to set the dimensions at two different ends of the beam. By default, the End dimensions
are parametrically equated to the Start dimensions. If a different set of dimensions are
provided at the start and end, the cross section varies linearly along the length of the
beam.
8. Click on the End sub-tab and review dim1 and dim2.
9. Click on the Manage Materials button located in the upper right corner of the Properties tab.
The Material Properties dialog is displayed.

Note The Material Properties dialog can also be accessed from the Model menu.
MotionView provides a list of commonly used Linear Elastic, as well as Hyper Elastic material by
default.
10. Select Steel from the Material list.
11. Review the property values and notice that the Elastic line check box for Approach is selected.
12. Click Close to close the dialog.
The default standard materials provided are defined with the Elastic Line option checked on.
Materials without the Elastic Line are solved using the continuous mechanics approach, where in
the cross-section deformation is taken into consideration. The Elastic Line approach ignores
cross-section deformation effects, which gives results closer to an analytical solution.
13. From the Connectivity tab, define the beam centerline by importing point data from a CSV file.
Click on the Import Points button located in upper right corner.
The Import Points From Coordinates In File dialog appears.

14. Browse and select the centerline.csv file from your working directory.
15. Click OK to import the points.
The .csv file must be in the following format: the first column must hold the X-coordinates, the
second column the Y-coordinates, and the third column the Z-coordinates. There can also be a
header row that begins with a # indicating a commented line.
16. Fit the model (by hitting 'F' on the the keyboard) to view the NLFE Body that was created.

17. Click on the Orientation tab to review the Start and End orientations.
Note The Orientation tab is used to set the cross section orientation (YZ plane of the beam).
Use the XY Plane or XZ Plane option to position the Y or the Z-axis (the remaining axis
will be positioned so that it is orthonormal to the remaining two axes).
Use the default orientation for this exercise.
Intermediate Beam elements orientation is linearly varied from Start orientation to End orientation.
The Orientation option is useful in defining twist along the beam length.
18. Click on Mass Properties tab to review the calculated values.
19. Click on Initial Conditions tab to review the NLFEBody initial velocities.
Leave initial velocities equal to zero.

Step 2: Adding a constraint and force.
1. Create a Fixed joint at the beam origin point (Point_1) as specified in the table below:
S.No Label Varia Type Body 1 Body 2 Origin(s Orientati Referenc Referenc
ble ) on e1 e2
name Method
1 Fix j_fix Fixed Cantilev Ground Point_1

Joint Joint er Beam Body
Note Each grid on an NLFE body has 12 DOFs: 3 translational, 3 rotational, and 6 related to
the length and angle between the gradient vectors. Using a fixed joint constrains the
positions of the grid and the rigid body rotations. However, the gradients at the grid are
free. This means that the cross-section at the fixed joint can twist about the grid and
also deform based on Poissons ratio. To arrest these DOFs, an NLFE element called
CONN0 can be used.
There is no graphical user interface support for creating this constraint. By default,
MotionView creates a CONN0 element at all of those grids of the NLFE body through
which it is attached to a constraint/force entity.
2. Create a load at the cantilever beam end point (Point_11) as specified in the table below:
S.No Label Variable Force Properties Action Apply Ref. Marker

name force on force at
1 Load frc_load Action only Scalar Force Cantilever Point_11 Global Frame
along Z axis of Beam
Ref Frame
3. From the Trans Properties tab, specify the expression for force as ` -1000*time`.
Note Negative value is specified to apply load along negative Z-axis direction.

C antilever beam with end load
4. Turn off gravity to eliminate deflection due to beam self-weight.
Step 3: Creating outputs to measure cantilever beam end deflection.

Cantilever beam end deflection from linear-elasticity theory.
Deflection for load applied at end =
Where,
= Load (N)
= Beam length = 1000mm
= Youngs Modulus = 2.1e+05 N/mm2
= Second Moment of Area = = 114 * = 25153.33mm4

1. Add an Output of the Type Expressions with the following:
For Label, enter Deflection - Analytical (F2), NLFE(F3).
For F2, enter `-1*SFORCE({frc_load.idstring},0,1,0)*1000^3/(3*2.1e5*25153.33333)`.
For F3, enter `{frc_load.DZ}`.
2. Click on Check Model to verify the model.
3. Add an output request Load to measure the magnitude of the applied Load.
4. Save your model as nlfe_cantilever.mdl.
Step 4: Solving the model and post-processing.

The model is now complete and can be solved in MotionSolve.
1. Invoke the Run panel by clicking on the Run Solver button on the toolbar.
2. Specify MotionSolve file name as Cantilever_beam.xml.
3. Select the Simulation type as Quasi-static, the end time as 1 sec, and the Print interval as
0.01.
4. Click on the Run button.
HyperView.

6. Click the Start/Pause Animation icon, , on the Animation toolbar to start the animation.
7. Click the Plot button in the MotionView Run panel to load the .abf file in HyperGraph.
8. Plot Deflection vs Load calculated from linear elasticity theory and NLFE by selecting the data
below in HyperGraph.
X Type Marker Force
X Request REQ/70000001 Load- (on Cantilever Beam)
X Component FZ
Select the following Y-axis data:
Y Type Expression
Y Request REQ/70000000 Deflection Analytical (F2), NLFE (F3)
Y Component F2 & F3
9. Click on the Define Curves toolbar icon .
10. Rename the two curves as Analytical and NLFE as shown below:
Define C urves panel
It can be observed from the plot that the NLFE and Analytical curves almost overlap.

Deflection versus load plot
11. Activate the Hyperview animation window.
12. Click on the Contour button on the toolbar to activate the Contour panel.
13. Under Result type, select NLFE Stress (t) and XX.
14. Click Apply to view bending stress contours.
Similarly, you can view Displacement, Strain, etc. for an NLFE body in HyperView. All FE contours
and types are available in HyperView for an NLFE body.
Bending stress contour of NLFE beam
15. Save this session as nlfe_cantilever.mvw.

Exercise 2: Tensile test of Elastomer
Hyper-elastic materials are large strain materials when compared to metals. In case of hyper-elastic
materials the non-linear relation between stress and strain is derived from a strain energy density
function. Currently MotionSolve supports three hyper-elastic material models: Neo-Hookean,
MooneyRivlin, and Yeoh.
In this exercise, a uni-axial tensile test on a rubber strip (2mmx25mmx50mm) will be performed.
Hyper-elastic material constants have been sourced from reference[3 ].
Clear the existing session through File>New>Session .
Step 1: Adding a new material property.

1. From the Main menu, select Model>Materials.
2. In Material Properties dialog:
For Elasticity type, select Hyper Elastic.
Click on the Add button.
Adding new HyperElastic material
3. From Add a MaterialProperty dialog:
Specify the Label as Yeoh Model and Variable name as propmat_yeoh.
For Source for values, select Rubber (Yeoh).
Click OK to add the material property.

Selecting source values for new material
4. Specify the following values for this material:
Element shear modulus (c10): 0.545235
Element shear modulus (c20): 0.0610498
Element shear modulus (c30):
Poisson ratio ( ): 0.48
Density ( ): 1.1e-6
Elastic strain limit ( L): 2.0
Specifying material constant values

5. Click Close.
Step 2: Modeling the rubber strip.

1. Create two points for the rubber strip length profile with the details show in the table below.
S.No Label Variable name x y z
1 Rubber End 1 p_rub_end1 0.0 0.0 0.0
2 Rubber End 2 p_rub_end2 50.0 0.0 0.0
2. Create 9 intermediate points between the above points using the Create Points Along a Vector
macro.
C reating intermediate points using C reate Points along a Vector macro.
3. Right-click on the Body icon in the Model-Reference toolbar. Add a new NLFE body with
the Label as Rubber Strip and the Variable name as nlfeb_rubber_yeoh.
In the Properties tab, specify the properties below:
Type as Beam
Cross-section as Bar
dim1 = 2
dim2 = 25
Select the Yeoh Model created in previous step as the MaterialProperty.
Specifying beam properties
Go to Connectivity tab; Append 8 more points to the displayed table.
Activate the first Point collector and select the point Rubber End 1.
Select the next available intermediate points one by one into other collectors, with the last
point being Rubber End 2.

Rubber strip model
Step 3: Adding constraints.

1. Create Fix joint at one end and Translation joint at other as specified in below table:
S.N Label Vari Type Body 1 Body 2 Origin( Orientation Refere Referen
o able s) Method nce 1 ce 2
nam
e
1 Fix Joint j_fix Fixed Joint Rubber Ground Rubber

Strip Body End 1
2 Translatio j_tra Translatio Rubber Ground Rubber Alignment axis Global X

n Joint ns nal joint Strip Body End 2 (Vector)
2. Create motion on the Translation joint to apply axial pull.
S.No Label Variable Define Motion Joint Property

name
1 Axial Motion mot_axial On Joint Translation Joint Displacement
3. In Properties tab, specify the following properties:
Define by: Expression
Expression: `50*time`

Motion expression
4. Go to the Solver Gravity dataset and change the Gravity option to Off.
5. Click the Save Model icon on the Standard toolbar and save your model as
rubber_strip.mdl in your <working directory>.
Step 4: Adding outputs.

Create outputs to measure engineering strain and engineering stress values.
Engineering Strain =
Engineering Stress =
1. Add an Output of the Type Expressions with the Label as Eng strain(F2), Eng Stress
(F3) and the expressions as shown below:
F2: `(DM({j_trans.i.idstring},{j_fix.i.idstring})-50)/50`
F3: `MOTION({mot_axial.idstring},{0},{2},{0})/50`
Output requests
Note In the above expression F2, the solver function DM() measures the distance magnitude
between two markers; the I marker of the Translation Joint and the I marker of the Fix
Joint. Expression F3 uses the solver function MOTION() which measures the reaction
force due to the imposed motion Axial Motion.

1. To solve the model, go to Run panel .
2. Specify the MotionSolve file name as rubber_yeoh.xml.
3. Select the Simulation type as Transient; the End time: 4, and the Print interval: 0.01.
4. Click Run.
5. As the solver is executing, a warning message similar to the one shown below may be displayed:
WARNING: Maximum vonMises strain exceeded maximum strain (YS) specified for NLFE
element BEAM12 (id=20000000) on Body_Flexible (id=30102) at time=1.183E+00
Maximum strain Computed : 2.015E+00
Maximum strain Specified: 2.000E+00
Future warning for yield strain violation suppressed.
This message states that the maximum vonMises strain in your NLFE component exceeded what
was specified (2.0) at time 1.18s. This message lets you know if your component is deforming
more than what you would expect it to, which allows you to inspect your results and make
corrections in modeling your system if required.
6. After the simulation is completed, click on Animate to view the animation in HyperView.
7. Click the Start/Pause Animation button to play the animation.

8. Go to the Contour panel and select NLFE Stress (t), XX, and click Apply.
Stress contour
9. Return to MotionView Run panel and click on Plot button to load the .abf file in HyperGraph.
10. Plot Engineering Stress vs Engineering Strain by selecting the data below in HyperGraph.
X Type Expression
X Request REQ/70000000 Eng strain(F2), Eng Stress(F3)
X Component F2
Y Type Expression
Y Request REQ/70000000 Eng strain(F2), Eng Stress(F3)
Y Component F3

Stress versus strain curve
Note The animation shows the true stress due to cross-section deformation.
11. Save the model.
12. Save this session as hyperelastic.mvw.
References:
1) JUSSI T, SOPANEN and AKI M. MIKKOLA: Description of Elastic Forces in Absolute Nodal
Coordinate Formulation. Journal of Nonlinear Dynamics 34: 5374, 2003.
2) Oleg Dmitrochenko:Finite elements using absolute nodal coordinates for large-deformation
flexible multibody dynamics. Proceedings of the Third International Conference on Advanced
Computational Methods in Engineering (ACOMEN 2005).
3) Sung Pil Jung, TaeWon Park, Won Sun Chung: Dynamic analysis of rubber-like material using
absolute nodal coordinate formulation based on the non-linear constitutive law. Journal of
Nonlinear Dyn (2011) 63: 149157.

MV-2110: Using an NLFE Helical Spring in a
Cam-Follower Mechanism
In this tutorial, you will learn the following:
Using a pre-defined NLFE Helical Spring sub-system component in a model.

This will be demonstrated by replacing the traditional coil spring in a Cam follower mechanism.
C am Follower Mechanism
What are NLFE Components in MotionView?

You can add NLFE bodies in MotionView version 14.0 (onwards) using the traditional Body icon in
toolbars or through the browser. In addition to this, ready-to-use sub-systems or Components have
been provided. These are components (MotionView system definition) that can be added to the model
using very few user inputs such as, for example for a Helical Spring: wire diameter, coil diameter,
material properties, number of coils, etc. MotionView will automatically create the building block
entities (such as points, bodies, and joints) and standard outputs needed to represent such a
subsystem.
The following components are made available:
1. Helical Spring
2. Stabilizer Bar
3. Belt-Pulley

Why use an NLFE Spring?
An NLFE sub-system offers the following advantages:
The spring component is added as a body, which means the mass and inertia of the spring is
included in the model.
The dynamics induced by the mass of the spring can be modeled and simulated (for example,
surge in springs).
If the deformations in the model are likely to go beyond the linear assumptions, NLFE will
account for it.
Stress strain and deformation contours can be visualized.
Coil-to-coil clash is modeled automatically.
Exercise
Copy the CamFollower_stg1.mdl and CamProfile.h3d files, located in the mbd_modeling\nlfe
\helicalspring folder, to your <working directory>.
Step 1: Reviewing the Model.

2. Load the CamFollower_stg1.mdl file from your working directory.
3. Review the model. From the Project Browser the following can be seen - the Model is organized
using a CamFollower system which contains:
A Cam, Follower, Joints, Graphics, and a Spring which make the complete topology.
The spring with a pre-load is acting between the Follower and Ground Body.

Browser showing the model topology
4. Click on the Run Solver toolbar icon , and Run the model with the settings as shown in the
Run panel image below. This will be the initial run which will be used to compare the results with
the NLFE spring model.
5. Click Animate to visualize the animation.
The coil spring will now be replaced with an NLFE Helical Spring component in the next section.

Step 2: Adding an NLFE Helical Spring.
1. Deactivate the Coil spring in the model by right-clicking on the Spring and selecting the
Deactivate option from the context menu.

2. An NLFE spring will be added between Ground Body on the top and Follower at the bottom.
The corresponding points that will be used are: Spring_top_relaxed and Spring_bottom.
NLFE spring interface bodies and points

3. Add an NLFE Helical Spring Subsystem by clicking the NLFE Helical Spring Subsystem icon
in the Subsystems toolbar as shown:
Note This toolbar may not be turned on by default. From the View menu, select Toolbars >
MotionView and then click on the toolbar name to turn the display on/off.
The Add an NLFEHelicalSpring Subsystem dialog is displayed.

Add an NLFEHelicalSpring Subsystem dialog
4. Assign an appropriate Label and Variable.

5. Double click on the parent System collector to bring up the model tree. Select CamFollower as
the parent system.
Resolving the parent System
6. Resolve the other collectors for attachments as shown below:
Body 1: Resolve to Ground Body.

Point 1: Resolve to Spring_top_relaxed.
Body 2: Resolve to Follower.

Point 2: Resolve to Spring_bottom.
MaterialProperty: Select Steel.

7. Fill in the spring parameters and details for label and varnames as shown below and click on OK in
the dialog.
Spring parameters
Wire diameter Specify the coil spring wire diameter. 3
Spring diameter Specify the coil mean diameter: center-to- 20

center.
Num. of inactive coils Specify the inactive/dead coils at each end. 1
Num. of active coils Specify the active coils which contribute to 7

spring stiffness.
Additional parameters
Number of elements Specify the element density per coil. 10

per coils
Variable Specify varname prefix for the spring profile p_spr_

points created.
Label Specify label prefix for the spring profile Point Spring
points created.
Note These parameters have been chosen for the following reasons:
The stiffness of the coil spring being replaced is: 14.6 N/mm.
The equation for the coil spring stiffness: G.d4 /[8.n.D3 ] (Where: G = Modulus of
rigidity; d = Wire dia.; n = No. of active coils; D = Spring mean diameter).
Substituting the values from the table above in the equation and using Steel with
80769 N/mm2 for material:
Spring stiffness k = 80769x34 /[8x7x203 ] = 14.6 N/mm

C ompleted dialog

8. The spring will be added between the Follower and Ground Body.
The spring overshoots the upper plate as shown above. This is because the spring has been
created with no pre-load on it.
9. Review the NLFE Spring systems added. The following entities are available in the System:
An NLFE Spring.
DataSet with spring parameters that were used to create the spring.
Fixed joints connecting the spring to the suspension.
Markers for reference.
Points that define the spring profile.
Template with unsupported elements. These are automatically created and include elements
that define coil-to-coil contacts.
NLFE spring topology in the browser

10. Next, the pre-loaded positions for the spring will be added. To do this,
Select the NLFE Spring 0 body under the subsystem.
Go to the Connectivity tab. In this tab there is a View drop-down menu with two options
available: No Load and Loaded. The No Load view shows the unloaded positions of the
spring.
Select the Loaded option. In this view the Import Loaded Profile button can be used to
browse a .csv file containing the pre-loaded positions and gradients of the spring.
Click on the Import Loaded Profile button to invoke the Import Loaded Points Information
From File dialog.
NLFE C onnectivity tab - Loaded View
Browse the file PreLoaded_positions.csv from the working directory and click OK to import
the loaded positions.
The spring will be displayed in wireframe and solid. The one in wireframe is the No Load
position (free/relaxed configuration) and the solid representation is that of pre-loaded spring.
Note Refer to the Appendix in the NLFE Body Panel Connectivity Tab topic to learn how
you can generate a preloaded position CSV file.

Free/Relaxed and Pre-loaded position of the spring
11. The pre-loaded positions can be viewed using the expansion button in the panel.
Pre-loaded positions and gradients imported from the .csv file
12. The fixed joints created by the NLFEHelicalSpring Component utility will be at the free
positions. You need to move one of these to the pre-loaded positions. Inspecting the spring
positions reveals that the spring is compressed at the top while the bottom position is the same in
both the configurations.

13. Change the origin point of the joint Spring_toUpperBody_att in the NLFE Helical Spring 0
system from Spring_top_relaxed to Spring_top (in the parent CamFollower system).
C hanging the connection to pre-loaded position
14. Save the model as CamFollower_nlfe_spring.mdl.
Step 3: Solving the Model and Post-processing.

1. To solve the model, invoke the Run panel using the Run Solver button in the toolbar.
2. Assign a name for the .xml file and click on the Run button.
HyperView.
4. Use the Start/Pause Animation button to play the animation.

5. Coil-to-coil clash can be viewed at the bottom/top set of coils.
C oil-to-coil contact visualization in HyperView
6. Click the Contour icon on the toolbar to activate the Contour panel.
7. Under Result type: select NLFE Stress (t), Averaging method: Simple, and click Apply to
view stress contours.
Viewing results in HyperView

C ontours in HyperView
Similarly, you can view Displacement, Strain, etc. for an NLFE body in HyperView. All FE contours
and types are available for an NLFE body.
Step 4: Comparing Results.

Now we will compare the results from NLFE spring and the regular spring (generated in Step 1) against
each other.
1. Use the Add Page button, , to add a new page.

2. Change the client to HyperGraph 2D .
3. Split the window into two using the Page Window Layout button on the toolbar.
4. In the left window open the .abf file corresponding to the solver run with the original spring
(created in Step 1), make the selections shown below and click Apply.
X Type Time
Layout Use current plot
Y Type Marker Displacement
Y Request REQ/70000003 FollowerDisplacement- (on Follower)
Y Component DY
Plot selections Follower displacement
5. Select the right window, make the following selections and click Apply.
X Type Time
Y Type Marker Force
Y Request REQ/70000002 Spring(ForcesOnFollower)
Y Component FY
Plot selections Spring force on follower: regular spring
6. Select the left window, browse to the .abf file of NLFE results and plot the corresponding
displacement.
7. Select the right window, make selections as shown below and click Apply.

X Type Time
Y Type Marker Force
Y Request REQ/70000002
Spring_toLowerBody_att(ForcesOnFollower)
Y Component FY
Plot selections Spring force on follower: NLFE spring
8. Apply axis labels and formatting as appropriate. The comparison is shown below:
Result comparison: Regular spring versus NLFE spring
Upon closer inspection there are some differences in the results, especially in the Spring Forces.
These could be attributed to the following reasons:
NLFE spring has mass and inertias associated with it as it is represented as a body. A regular
spring is a force entity without any mass/inertias.
The difference in force outputs is particularly seen when the spring displacement is high. This
is the point where the coil-to-coil contact happens. During this event, the effective number of
coils reduces, thus increasing the spring stiffness marginally and hence the force outputs.
9. Save your work in a session file named camfollower_nlfe.mvw.

Advanced Simulation
MV-1015: Using Spline3D to model the Combustion Forces in an Engine
MV-1023: Using Python Subroutines in MotionView Model Building
MV-1024: Using User Subroutines in MotionSolve Models
MV-1025: Modeling Point-to-Curve (PTCV) higher-pair constrain
MV-1026: Modeling Curve-to-Curve using Templates
MV-1027: Modeling Point-to-Deformable-Curve (PTDCV) Higher-Pair Constraint
MV-1028: Modeling Point-to-Deformable-Surface (PTdSV) Higher-Pair Constraint
MV-1029: Modeling Point-to-Deformable-Surface Force (PTdSFforce)
MV-7000: Modeling Differential Equations Using MotionView and MotionSolve
MV-7001: Building User Subroutines in Altair MotionSolve
MV-7002: Co-simulation with Simulink SMP Approach
MV-7003: Simulating a Single Input Single Output (SISO) Control System Using MotionView and
MotionSolve_2
MV-7004: Inverted Pendulum Control Using MotionSolve and MATLAB
MV-7005: Linking Matlab/Simulink Generated Code with MotionSolve
MV-7009: Co-simulation with Simulink IPC Approach

MV-1015: Using Spline3D to Model Combustion Forces
in an Engine
In this tutorial you will learn how to:
Use Spline3D to model an input which depends on two independent variables.

This will be accomplished by building a Single Cylinder Engine model similar to the one shown below:
What are Spline3Ds?
Spline3Ds are reference data plotted in three-dimensional coordinates which have two independent
vectors or axis. These can be visualized as a number of 2D Splines (Curves) placed at regular
intervals along a third axis. For instance, a bushing is generally characterized by a Force versus the
Displacement curve. Lets say, the Force versus displacement also varies with temperature.
Effectively, there are two independent variables for the bushing force - Displacement and
Temperature. Another example is the Engine Pressure (or Force) versus the Crank angle map
(popularly known as P-Theta diagram). The P-theta map will vary at different engine speeds (or
RPM). Such a scenario can be modeled using Spline3D.

Exercise
In this exercise, an engine mechanism is simulated where the combustion force that varies with regard
to the crank angle and engine speed is modeled using Spline3D.
Step 1: Reviewing the model.

1. Copy the files SingleCylEngine.mdl and FTheta.csv , located in the mbd_modeling
\interactive\spline3d folder, to your <working directory>.
3. Open the SingleCylEngine.mdl model file.
4. Review the model.
The model is a piston cylinder mechanism with a flywheel.
The model has two systems: System Cyl1 and System Flywheel.
In the System Flywheel, the Flywheel (fixed to Crank) is driven by a velocity based Motion
between markers which refers to a curve (Crank_RPM) for inputs.
Motion Panel - C onnectivity Tab
Motion Panel - Properties Tab (with Expression referring to the C urve using AKISPL function)

The curve Crank_RPM indicates the time history of crank speed during the simulation. The
speed ramps up to 500 RPM and then to 1000, 1500, and 2000 RPM.
C urve C rank_RPM
Two Solver Variables: Crank_angle (deg) and Crank_RPM keep track of the angular rotation
(in degrees) and velocity (in RPM) of the crank respectively.
Outputs are defined to measure the crank angle and RPM.
In System Cyl1:
o The solver variables in System Flywheel are passed as attachments to this system and
carry the variable names arg_Crank_angle_SolVar and arg_Crank_RPM_SolVar. These
will be used in defining the independent variables while defining the combustion force using
Spline3D
o A Combustion_ref marker exists as a reference for a combustion force whose Z axis is

aligned along the direction of travel of the piston.
Next, a combustion force will be added on the piston using a Spline3D.

Step 2: Adding a Spline3D entity.
1. Add a Spline3D using one of the following methods:
From the Project Browser, right-click on System Cyl1 and select Add > Reference Entity >
Spline3D from the context menu.
OR
Select System Cyl1 in the Project Browser and then right-click on the Spline3D icon on
the Reference Entity toolbar.
The Add Spline3D dialog is displayed.

2. Enter F_ThetaSpline for the Label and spl3d_F_ThetaSpline for the Variable.
The Spline3D panel is displayed in the panel area with the Properties tab active.
4. Click on the Type drop-down menu and select Value.
The data for the spline can be defined using either the File or Value methods. For the File type,
a reference to an external file in .csv format must be provided. In case of the Value type, the
values can be imported from a .CSV file (using Import) or they can be entered in manually. In
this tutorial, we will import the values from an external file.

5. Click the Import button to display the Import Values From File dialog.
6. Browse to the FTheta.csv file in your <working directory> and click OK.

7. In the Warning dialog that appears, click Yes to continue.
The .csv file that is to be used as the source for Spline3D needs to be in the following format:
The first column must hold the X-axis values (shown in blue below) which is the first
independent variable.
The top row holds the Z-axis values (shown in red below) which is the second independent
variable.
The other columns must have the Y-axis values (shown in green below) with each column
belonging to the particular Z-axis values heading that column.
Note The same format is applicable when using the File input type.

8. Once imported, the values are populated in the panel. You may review these by clicking on the
Expansion button in the panel to open the Spline Values Table Data window.

9. When manually keying in the values, context menus are available which allow you to Insert/
Delete/Append row and column data. You can access these menus by right-clicking on any of
the row or column headers. If the right-click is made on the last row/column, an Append option
will also be available.
C ontext Menu (Row)
C ontext Menu (C olumn)

10. Click Close to close the Spline Values Table Data table.
11. Activate the Linear Extrapolation check box. This will ensure that the values are extrapolated if
the Solver starts looking for values beyond the range of the user provided data.
12. To visualize the spline graphically, click on the Show Spline button to display the Spline3D
viewer dialog.
All three axes can be viewed in an isometric view in this window.

13. Click Close to close the viewer.
The imported values are Combustion Force on Piston vs Theta (crank angle) diagrams at
different speeds (as shown below). The F-Theta profiles vary slightly at different engine or crank
speeds. The same plot was visualized in the previous section in the Spline3D viewer by placing
the four different plots along the Z-axis.
Input Data for Spline3D
Step 3: Adding a force using the Spline3D.

A force will now be added to represent the combustion in the cylinder. This force will be mapped to
the Spline3D added in the previous section.
1. Add a Force using one of the following methods:
From the Project Browser, right-click on System Cyl1 and select Add > Force Entity > Force
from the context menu.
OR
Select System Cyl1 in the Project Browser and then right-click on the Force icon on the
Force Entity toolbar.
The Add Force or ForcePair dialog is displayed.

2. Enter an appropriate Label and Variable name and click OK.
The Force panel is displayed in the panel area with the Connectivity tab active.
3. From the Connectivity tab, use the Force drop-down menu to change the type to Action
reaction.
4. Resolve the connections as shown in the image below, either through picking in the graphics area
or using the model tree (by double clicking on the input collector).
Note The Body 2 reference to Ground Body is through an attachment to the System Cyl1
system.
5. Go to Trans Properties tab and change the Fz type to Spline3D.
6. Double click on the Spline3D collector, , to display the Select a Spline3D dialog.

7. Select System Cyl1 in the model tree and then navigate to and select the F_ThetaSpline
Spline3D (which will then be displayed in the right pane).
8. Click OK to close the window.
9. In the Independent variable X field, enter in the following expression:

`MOD({arg_Crank_angle_SolVar.VARVAL}, 720)`.
10. In the Independent variable Z field, enter in the following expression:

`{arg_Crank_RPM_SolVar.VARVAL}`.

11. Click the Check Model button on the Model Check toolbar to check the model for errors.
The completed panel is shown below:
Note The solver function MOD() used in Independent variable X refers to the solver variable
Crank_angle (deg) in System Flywheel (via attachment arg_Crank_angle_SolVar to
System Cyl1). This function calculates the remainder of the division of first argument
value (value of the solver variable) by the second argument value (720); thereby
resetting the value of Independent variable X every 720 degrees.
12. Save the model with a different name (File > Save As > Model).

1. To solve the model, invoke the Run panel using the Run Solver button on the General
Actions toolbar.
2. Since the crank RPM input data is for 40 seconds, enter 40 in the End time field and change the
Print interval to 0.001.
3. Assign a name and location for the MotionSolve XML file using the browser icon .
4. The Run panel with the inputs from the previous steps is shown below:
5. Click the Run button in the panel to invoke MotionSolve and solve the model.
6. Close the solver window after the job is completed.

7. Click the Animate button in the panel (now active) to load the animation results in a
HyperView window.
8. From the Animation toolbar, use the Start/Pause Animation button to animate the model.
9. Visualize forces on the Piston using the Vector panel (select the Piston graphics for the
Assemblies collector).
You may also set all graphics to be transparent for easy visualization using the WireFrame/
Transparent Elements and Feature Lines option located on the Visualization toolbar.
10. From the Page Controls toolbar, click the Add Page icon to add a new page.
11. Use the Select application drop-down menu to change the client on the new page to
HyperGraph 2D.
12. From the Page Controls toolbar, click the arrow next to the Page Window Layout button
and select the three window layout .
13. From the Build Plots panel, use the Data file browser to load the .plt file from the
MotionSolve run.
14. In the first window (top left), plot the Crank_angle (deg) by selecting the following:
Y Type = User Defined
Y Request = REQ/70000003 Crank_angle (deg)
Y Component = f3
Selections for plotting C rank_angle (deg)

15. Next, click in the graphics area of the second window (top right) to make it the active window
and plot the CombustionForce in the Z direction:
Y Type = Force
Y Request = REQ/70000002 CombustionForce (ForceOnPiston)
Y Component = Z
Selections for plotting C ombustionForce
16. Finally, we will plot the Force vs Theta plots at different speeds as applied on the piston (this will
demonstrate the usage of Spline3D input used in Step 2 of this tutorial). Click in the graphics
area of the third window (bottom) to make it the active window.
17. Click on the Define Curves icon on the Curves toolbar.
18. Click the Add button to add a curve.
19. Click in the Curve field and rename the curve as 500 RPM.
20. Change the Source to Math.
21. Enter the expressions shown below to extract the data from the curve in the first and the second
window respectively between 6 and 7 seconds.
x = p2w1c1.y[subrange(p2w1c1.x,6,7)]
y = p2w2c1.y[subrange(p2w2c1.x,6,7)]
Panel entries for plotting Force vs Theta
22. Click Apply to plot.
Note p2w1c1 refers to the Curve 1 plotted on Page 2, Window 1. If for any reason the page,
window, or curve numbering is different, suitable modifications should be made to the
expression.
The subrange function returns the indices of the vector within a specified range. For
more information on the subrange function, please refer to the Templex and Math
Reference Guide.

23. Similarly, add three more plots for 1000, 1500, and 2000 RPM. Use time values of: 16, 17; 26,
27; and 36, 37 respectively (in place of 6, 7 shown in the expression above).
24. Assign different colors to these curves using the Curve Attributes panel , or by selecting the
curves in the Plot Browser and changing the color in the Properties table.
25. After completing the plots, compare them with the input data for the Spline3D plot in Step 2. A
comparison is shown below:
Validating the Spline3D used by the Solver

MV-1023: Using Python Subroutines in MotionView
Model Building
The objective of this tutorial is to replace several entities in a MotionView model with Python user
subroutines. You will run a model initially, and then edit the file to incorporate Python scripts in place
of MotionView entities and compare the results from each simulation.
In this tutorial, you will learn how:
User subroutines are incorporated into MotionView

User subroutines are useful in customizing models
To create Python scripts that can be used to define these subroutines (and how they are
called by MotionView).
You must be familiar with the MotionView user interface and entities panel, as well as have some
experience defining and modifying entities. Some experience with the Python programming language is
necessary to fully understand the topics covered.
Exercise One - Introduction to User Subroutines

User subroutines are a useful tool to customize simulations and analyses. These subroutines, or
usersubs can be created using variety of programming languages like C, Ruby, TCL, and Python.
Subroutines created in programming languages like C, C++ and FORTRAN etc. are compiled to create
*.dll files using the MS UserSub Build Tool (located in the MotionView Tools menu). These dlls are
then used by the solver. In older versions of MotionView only compiled usersubs (*.dll) were
supported. Starting with MotionView version 11.0, usersubs are enabled to use Python and Matlab
scripts. In this tutorial, we will be using Python to create usersubs. User subroutines can make use
of external Python scripts in order to define complex simulations, which cannot be created through the
MotionView GUI. With a basic knowledge of the Python programming language, a user can easily
generate intricate experiments to simulate any complex mechanism.
This tutorial will show you how to replace five MotionView entities with their corresponding usersubs.
Copy the model file required for this exercise, engine_baseline.mdl, along with all of the H3D files
located in the mbd_modeling\motionsolve\python_usersub folder to your <working directory>.

The single cylinder engine model
The model we are using is a single cylinder engine, and uses a curve, an output, a force, and a motion
entity. The system also uses default damping.
The curve is read from a CSV file, and gives a force value based on the angular displacement
of the connecting rod.
The output returns the displacement magnitude of the piston.
The force entity uses the angle of the connecting rod and the curve to apply a variable
pressure force to the piston.
The motion entity applies an angular motion to the Crank_Grnd revolute joint.
The default damping of the system is 1, however it can be changed in the Bodies panel.
The following is a list of the entities and usersubs we will be using in this tutorial, along with a brief
description of their usage:
Entity Usrsub Description
Curve SPLINE_READ Reads the curve data file.

Entity Usrsub Description
Request REQSUB Outputs the requested values
Force GFOSUB Applies a force on the system.
Motion MOTSUB Applies a motion to the system.
Damping DMPSUB Defines the damping of a flexbody.
Step 1: Running the model.
1. Click the Run panel icon, , to access the Run panel.
2. Click on the folder icon located next to the Save and run current model option, and browse to
your <working directory>. Specify the name as engine_baseline.xml for the MotionSolve
input XML file.
3. Check your model for errors, and then click the Run button to run your model.
This will give you result files to compare with your usrsub results.
Exercise Two - Adding User Subroutines

Notes on using XML syntax in Python
Python can use many MotionSolve functions and inputs when certain syntax rules are followed. When
using a MotionSolve function such as AKISPL or SYSFNC, the string py_ must be added to the
beginning. For example, py_sysfnc( would be the correct usage of SYSFNC in Python. When
defining a usersub function in Python, the name of the function and the inputs must match those
outlined in the MotionSolve online help pages exactly. When accessing model data in python through
a function such as SYSFNC, use the exact property name in quotations as the id input. Model
properties that are passed into Python in the function definition can be accessed throughout the
script, and do not need additional defining to use. An example of these syntax rules being used is
shown below:
def REQSUB(id, time, par, npar, iflag):
[A, errflg] = py_sysfnc(DX,[par[0],par[1]])
return A
Step 1: Using SPLINE_READ to Replace the Curve Entity.

The first user-subroutine we will implement uses the SPLINE_READ function to return the curve from
the included pressure_curve.csv file. SPLINE_READ is the usersub that corresponds to the curve
entity in MotionView. It uses data points in an external file to create a curve, which can then be
used by other entities.

Writing the Python script:
1. Open a new Python file, and define a function with the name SPLINE_READ using def
SPLINE_READ():", giving the appropriate inputs and outputs. The inputs and outputs used are:
id, file_name, and block_name.
2. Import the Python CSV package by including import csv after the function definition.
3. Open pressure_curve.csv in the function, and read the file to your Python script as a variable.
This can be done with variable = open(pressure_curve.csv, r).
4. Change the format of this variable from csv by defining a new variable, and using csv.reader()
to read your variable file.
5. Define an empty list, L, to store the pressure_curve data values. Iterate through the list
using for item in curv:. Append each item as a separate list value with L.append(item).
6. Remove the headers from the csv file by redefining the list from the second value till the end of
the list. This can be done with L = L[1:].
7. Define a counter variable to be used later. Define two lists that are half the length of L, and set
them equal to zero. To do this, use x = 16*[0.0] twice; once with the x value and once with
the y value.
8. Create a while loop dependent on your counter variable being less than the length of your list,
minus one.
9. In each iteration of the loop, define your x and y data values for the index i as a floating value
of each half of your L data sets. This should look like x[i] = float(L[i][0]) and y[i] =
float(L[i][1]). Increase your counter variable by 1.
10. Define a z variable with a floating value of 0.0, and close the csv file. Defining a z variable is
necessary, as the next function we will use requires an x, y, and z variable.
11. Use the put_spline MotionSolve function, and return the id, as well as the lists containing the
first and second column of values and the z variable. This should be done with errflg =
py_put_spline(id,x,y,z) followed by return errflg.
12. Save this file to your working directory as nonlin_spline.py.
Your nonlin_spline.py Python script should resemble the following:
def SPLINE_READ(id, file_name, block_name):
import csv
ifile= open('pressure_curve.csv','r') ## opens data file as readable variable
curv = csv.reader(ifile) ## reads csv data, stores as useable
var.
L = [] ## creates empty list

for item in curv:
L.append(item) ## separates file values into list
L = L[1:] ## removes block names from list

i=0 ## creates counter
x = 16*[0.0]
y = 16*[0.0] ## splits list into x and y lists
while i < (len(L)-1):
x[i] = float(L[i][0]) ## changes values from str to float
y[i] = float(L[i][1])
i+=1 ## counter increment
z = 0.0 ## defines z value

ifile.close() ## closes data file
errflg = py_put_spline(id,x,y,z) ## var to create MotionSolve spline
return errflg ## returns var
Implementing the Python script:
1. In MotionView, go to the Curve panel , and locate the Force_Pressure curve in the project
directory tree to the left of the MotionView workspace.
2. From the Properties tab, check the box marked User-defined.
3. From the Attributes tab, make sure Linear extrapolation is checked.
4. Click on the User-Defined tab, and use the File name file browser to select the
pressure_curve.csv file.
5. Check the box marked Use local file and function name. Use the Local File file browser (the
folder button to the right) to locate and select the nonlin_spline.py file.
6. Change the Function Type in the drop-down menu from DLL to Python, and ensure the function
name is SPLINE_READ. You do not need to enter anything for the Block name, as it is not
needed in this tutorial.
The curve panel using the SPLINE_READ usersub

Step 2: Using REQSUB to Request an Output.
The second user-subroutine will use Python to specify which values to return. In this tutorial, the
returned values will be the magnitude of displacement for the piston.
1. Create another Python file, and define a function named REQSUB with the appropriate inputs and
outputs. The syntax for this is def REQSUB(id, time, par, npar, iflag).
2. Use the sysfnc utility to implement the DM (or displacement magnitude) function on the first
and second input parameters, and define a variable and an error flag by writing [D, errflg] =
py_sysfnc(DM,[par[0],par[1]]).
3. Return a list of eight values, where the second value is your variable, and the rest are equal to 0.
This will be your result variable, and should look like result = [0,D,0,0,0,0,0,0].
4. Save this file to your working directory as req_nonlin.py.
Your req_nonlin.py Python script should resemble the following:
def REQSUB(id, time, par, npar, iflag):
[D, errflg] = py_sysfnc("DM",[par[0],par[1]]) ## sets "D" as piston

displacement mag
result = [0,D,0,0,0,0,0,0] ## lists results for output return
return result ## sends list with results to motionsolve as output
1. In MotionView, go to the Outputs panel , and locate the Output_Conrod_Length output in

the project directory tree to the left of the MotionView workspace.
The Outputs panel is displayed.
2. From the Properties tab, select User Defined from the first drop-down menu.
3. Click in the text field labeled Output, and then click on the button to open the Expression
Builder.
4. In the text field of the Expression Builder, click inside the parentheses and add {},{}.

5. From the Expression Builder, locate and select the j_0.i.idstring (located in the Joints folder
in the directory) and insert this id string into the expression by positioning the cursor inside a set
of braces and clicking the Add button. In addition, add the j_1.i.idstring into the expression by
repeating this same process.
Expression Builder dialog
7. Check the Use local file and function name box, and select Python from the Function Type
drop-down menu.

8. Use the Local File file browser to locate and select the req_nonlin.py script, and make sure
that the Function name text field reads REQSUB.
Outputs panel using REQSUB
Step 3: Using GFOSUB to Replace the Force Entity.

The GFOSUB user subroutine replaces a force with a user defined Python script. The GFOSUB used here
will take the curve data defined with SPLINE_READ, and change depending on the Conrod angle
according to the curve.
1. Open a new Python file, and define the function GFOSUB by typing def GFOSUB(id, time, par,
npar, dflag, iflag):.
2. Import "pi" from the Python math library using from math import pi.
3. Use the AZ function for angle in the z direction with the sysfnc command, to save it as a
variable. To do this, type [A, errflg] = py_sysfnc(AZ,[par[1],par[2]]).
4. The angle will be measured in radians by default, so change the variable defined in the previous
step to degrees. As the model extends from the origin into the negative y direction, you will need
to multiply by -1. The method used in this tutorial is B = ((-1)*A*180)/pi.
5. Define another variable using the akispl utility, which interpolates the force values from the
curve. You will need input arguments of your angle B, zero to specify a two dimensional curve,
and zero for the curve input and the order. This line is written as [C, errflg] =
py_akispl(B,0,par[0],0).
6. Return a list three elements long, where the second element is the variable defined with the Akima
interpolation function. The data from interpolation is stored in the first column, so use return
[0,C[0],0].
7. Save this file to your working directory as gfo_nonlin.py.
Your gfo_nonlin.py Python script should resemble the following:
def GFOSUB(id, time, par, npar, dflag, iflag):
from math import pi
[A, errflg] = py_sysfnc("AZ",[par[1],par[2]]) ## retreives conrod angle

B = ((-1)*A*180)/pi ## converts radians to degrees

[C, errflg] = py_akispl(B,0,par[0],0) ## interpolates data to fit curve
return [0,C[0],0] ## returns C data as force values
1. In MotionView, go to the Forces panel , and locate the Force_Gas_Pressure force in the
project directory tree to the left of the MotionView workspace.
2. From the Connectivity tab, check the User-defined properties box.
3. From the User-Defined tab, edit the Force value with the Expression Builder to include the
curve idstring, the ground marker idstring, and the crank marker idstring.

5. Check the Use local file and function name box, and select Python from the Function Type
drop-down menu.
6. For Local File, select gfo_nonlin.py from your working directory.
7. Make sure the Function name is set to GFOSUB.
Step 4: Using MOTSUB to Define a Motion.

1. Open a new python file, and define the MOTSUB function, including the required inputs. The
correct syntax for this is def MOTSUB(id, time, par, npar, iord, iflag):.
2. The MOTSUB user subroutine requires a function or expression, and its first and second order
derivatives. Create conditional statements using the function order variable iord to define the
function and its first and second derivatives with if iord==0:, elif iord==1: and
else:.
3. The function and its derivatives should be defined with the same variable name. The function
used in this tutorial is A = 10.0461*time. This makes the first derivative equal to A =
10.0461, and the second derivative equal to A = 0.0.
4. Return the function variable with return A.
5. Save this file to your working directory as mot_nonlin.py.
Your mot_nonlin.py Python script should resemble the following:
def MOTSUB(id, time, par, npar, iord, iflag):
if iord==0: ## function
A = 10.0461*time
elif iord==1: ## first derivative
A = 10.0461
else: ## second derivative
A = 0.0
return A ## returns function based on iord input

1. In the directory tree on the left side of the HyperWorks desktop, locate the Motion_Crank
motion and click on it.
The Motions panel is displayed.
2. In the Motions panel, check the User-defined properties box.
3. Click on the User-Defined tab.
Because we defined the function in the Python script, we do not need to modify USER() text
field.
4. Check the box labeled Use local file and function name, select Python from the Function Type
drop-down menu.
5. Use the Local File file browser to locate and select the mot_nonlin.py file.
Motions panel using MOTSUB
Step 5: Using DMPSUB to Add Custom Flexbody Damping.

1. Open a new Python file and define the DMPSUB function with def DMPSUB():, giving it the
following inputs: id, time, par, npar, freq, nmode, h.
2. Define a list the length of nmode using cratios = nmode*[0.0].
nmode is the number of modes in the flexbody.

3. Create an if statement to iterate along the list of modes in the flexbody. The xrange()
function can be used here, resulting in for I in xrange(nmode):.
4. In each iteration of the loop, set each index in your variable equal to 1 by adding cratios[i] =
1.0.
5. At the end of your script, return the list variable with return cratios.
6. Save your script as dmp_nonlin.py.
Your dmp_nonlin.py Python script should resemble the following:
def DMPSUB(id, time, par, npar, freq, nmode, h):
cratios = nmode*[0.0] ## makes preallocated list for markers
for i in xrange(nmode):
cratios[i] = 1.0 ## sets marker damping to 1
return cratios ## returns damping values
1. In the directory tree on the left side of the HyperWorks desktop, locate the Conrod body and
click on it (this is a flexbody in the model).
2. From the Properties tab, click on the Modes button (located in the lower right corner of the
panel) to display the Modes dialog.

3. Use the drop-down menu to select the User Function Damping option.
Because we defined the damping in our dmp_nonlin.py script, we do not need to change the
USER() expression.
4. Go to the Run panel .
5. Change the End time to 5.0, and the Print interval to 0.01.
6. Now, export the MotionSolve file using File > Export > Solver Deck.
Note Currently there is no GUI option available to specify the DAMPSUB file defining flexbody damping,
therefore the dmp_nonlin.py must be manually added to the MotionSolve file (*.xml) by
adding following statements to the flexbody definition:
is_user_damp = "TRUE"
usrsub_param_string = "USER()"
interpreter = "Python"
script_name = "dmp_nonlin.py"
usrsub_fnc_name = "DMPSUB"

Your flexbody definition should look like below:
<Body_Flexible
id = "30104"
lprf_id = "30104002"
mass = "7.424574879203591E-02"
inertia_xx = "1.471824534365642E+02"
inertia_yy = "4.505004745855096E+00"
inertia_zz = "1.501914135052064E+02"
inertia_xy = "-5.546373592613223E-03"
inertia_yz = "-1.984540442733755E-03"
inertia_xz = "1.557626595859531E-03"
cm_x = "1.191728011928773E-03"
cm_y = "-2.225471002399553E+01"
cm_z = "5.469513396916666E-05"
h3d_file = "conrod.h3d"
is_user_damp = "TRUE"
usrsub_param_string = "USER()"
script_name = "dmp_nonlin.py"
usrsub_fnc_name = "DMPSUB"
flexdata_id = "30104"
animation_scale = "1."
/>
Exercise Three - Running Your Simulation with Usersubs

Now that all the user subroutines have been implemented, run your model, and compare your results
to those from your initial test.
Step 1: Using the Run Solver Panel to Run Your Model.
1. Go to the Run panel , click on/activate the Run MotionSolve file radio button.
2. Now browse to the *.xml file saved in previous step.

Exercise Four - Comparing Your Results

Now that we have results for both the initial model and the model using user subroutines, we will
compare the data to ensure accuracy. We will do this using HyperGraph and Hyperview to compare
the outputs and deformations of the system.
Step 1: Using HyperGraph to Plot the Displacement Magnitudes.

Using the outputs from both simulations, we will compare the displacement magnitude of the piston. A
correct result from the usersub run will match the results from the initial run.
1. Begin by opening a new window by clicking the Add Page button .
2. Switch the application from MotionView to HyperGraph 2D by selecting it from the Client
Selector drop-down menu (located on the left-most end of the Client Selector toolbar).
3. In HyperGraph, click the Build Plots panel button on the Curves toolbar.
4. In the Build Plots panel, locate your baseline results from your working directory using the Data
file file browser. Select the file baseline.abf, and click Open.
5. The x and y axes options are be shown below. The default x variable is Time. For the y variable:
select Marker Displacement for Y Type, leave the default for Y Request, and select DM for Y
Component.
6. Click the Apply button (located on the far right side of the panel).
7. For your usersub results, repeat steps 4 through 6, using REQSUB and RESULT(2) for Y Type
and Y Component respectively.

8. Click Apply.
C omparison of output results from both model simulations
Step 2: Using HyperView to Compare Flexbody Stresses.

Using HyperView, you can view the stresses and deformations on the flexbody. The results between
the two simulations should be the same.
1. Add a new window by clicking the Add Page button .
2. Switch the application from HyperGraph 2D to HyperView using the Client Selector drop-down
menu.
3. Click the Load Results button on the Standard toolbar.
4. Locate your baseline.h3d results file in your working directory, and click Open.
5. Click Apply.
6. Open the Entity Attributes panel , and click the Off button next to the Display option.
Make sure that the Auto apply mode check box is checked.
7. In the model window, click on the piston head, and both crank components.
Only the flexbody component should be displayed.

8. Click the Contour panel button located on the Results toolbar.
The Contour panel is displayed.
9. Set Result type to Deformation->Displacement (v), and click on the flexbody in the model
window.
10. Click the Apply button (located in the lower middle portion of the panel).
11. Next, click on the Tracking Systems panel button located on the Results toolbar.
12. From the Track drop-down menu, select Component, then click on the flexbody in your model
window.
13. Separate your model window into two halves using the Page Window Layout drop-down menu
(located on the Page Controls toolbar).
14. In the blank model window, repeat steps 3 through 12 for your usersub h3d file.
15. Click on the Start/Pause button on the Animation toolbar to animate your models.
C omparison of flexbody deformation in HyperView

MV-1024: Using User Subroutines in MotionSolve
Models
User subroutines are created for various reasons. Some include:
To describe a physical phenomenon that is determined by non-trivial logical conditions.

When it is impractical to formulate a complicated expressions in an explicit form.
To take full advantage of a programming language like C/C++ or Fortran and simpler
programming with interpreters like Tcl, Python, and Ruby.
To use your own subroutines in MotionSolve, follow these steps:
1. Create a C/C++, FORTRAN, Tcl, or Python source file that contains the user-defined modeling
entity.
Refer to the MotionSolve User's Guide for a list of supported solver subroutines and a general
guideline on setting up and using subroutines in your model.
2. Obtain a DLL by compiling and linking your user subroutine(s) for C/C++ or Fortran, or use the source
file directly for Tcl or Python.
MotionSolve supports two separate levels of user DLLs and the algorithm attempts to resolve the
symbols, starting from the most specific library.
A) Element Level DLL (most specific)
Specify the name of the DLL in the modeling element definition.
B) Machine Level DLL
You can create an environment variable called MS_USERSUBDLL and set it to the DLL file. This
environment variable is not defined automatically when MotionSolve is installed. However, Fortran,
and C/C++ DLLs are provided in the installation folder <installation_directory>\hwsolvers
\usersub\subdll\win32\. This allows you to run some of the test models that use user
subroutine DLLs.
Note The DLL that is loaded is based on the "most specific" rule: number one overrides
number two.
3. Modify the corresponding entity in your multi-body model to be "user defined" and point it to your
DLL. This can be done in two ways:
A) By modifying the entity in the MotionView interface.
B) By editing the MotionSolve XML file.
Regardless of the method you select, you will end up with an XML file where one or more entities
are now user defined.
For example, consider the coupler modeling element in the XML file:

<Constraint_Coupler
id = "1"
type = "TwoJoint"
i_marker_id_joint1 = "30603030"
j_marker_id_joint1 = "30602031"
body1_id_joint1 = "30603"
joint_type_joint1 = " "
usrsub_param_string = "USER(-8.5)"
usrsub_dll_name = "C:/work/testsub.dll">
</Constraint_Coupler>
The usrsub_dll_name argument defines C:/work/testsub.dll as the element level DLL for this
coupler element. Any element can be defined by pointing to a different DLL.
The coupler modeling element in the XML file can also be defined as:
<Constraint_Coupler
id = "1"
type = "TwoJoint"
usrsub_param_string = "USER(-8.5)"
usrsub_dll_name = "NULL">
</Constraint_Coupler>
In this case, MotionSolve looks for a machine level DLL as defined by the value of the
MS_USERSUBDLL environment variable.
4. Run MotionSolve, verifying that it picks up the appropriate DLL during simulation.

Exercise
Copy the model file required for this exercise, Pendu_model.mdl, from the mbd_modeling
\motionsolve to your <working directory>.
Step 1: Using an expression to define motion.

1. Launch a new MotionView session.
2. Load the MDL model file Pendu_model.mdl from your <working directory>.
3. From the Project Browser, right-click on Model and select Add Constraint > Motions (or right-
click the Motions icon, , from the toolbar). Add a Displacement motion to the revolute joint
between the Pendulum Body and the Ground Body.
Set an expression of 3.142* TIME for the displacement motion.
5. Click the Outputs panel icon, , to access the Outputs panel.
Review the output request.
7. Click the Save and run current model: folder icon, , and browse to your <working
directory>. Specify the name as Pendu_model.xml for the MotionSolve input XML file.
8. Confirm that the Simulation type: is set to Transient.
9. Specify 1 as the End Time.
10. Click the Check button, , to check for any modeling errors.
11. After verifying that there are no errors, click the Run button.
12. Once the run is complete, the Animate button is activated. Click Animate to view the animation
of the simulation.
13. From the Run panel, click the Plot button to view the time-histories of the output request.

Step 2: Using the MOTSUB user subroutine to define motion.
In this step, we will use the user subroutine MOTSUB. This user subroutine has been compiled and
linked in the DLL ms_csubdll.dll. This machine level DLL is provided in the HyperWorks installation.
For the Windows 32-bit platform, the DLL is located at: <installation_directory>\hwsolvers
\usersub\subdll\WIN32\.
We will use the ms_csubdll.dll as a machine level DLL.
1. Create an environment variable MS_USERSUBDLL and set the value to the DLL file.
For Windows 32-bit platform users, this will be: <installation_directory>\hwsolvers

\usersub\subdll\WIN32\ms_csubdll.dll
Right-click on the My Computer icon. From the Advanced tab, select Environment
variables > New (under User variables).
Set Variable name: to MS_USERSUBDLL.
Set Variable value: to <installation_directory>\hwsolvers\usersub\subdll\win32

\ms_csubdll.dll.

2. With the Pendu_model.mdl from the previous step open in the MotionView model window, go to
the Motions panel, .
3. From the Connectivity tab, check the User-defined properties check box.
4. Click the User-Defined tab and enter `USER(100001,5,2)` in the text-box.
Note To use an element level (specific) DLL/Interpreter function, you can check the Use local
dll and function name check-box and point to the DLL using the folder icon, .
The string `USER(100001,5,2)` is used to pass arguments to the MOTSUB user subroutine. The
MOTSUB user subroutine calculates motion using the parameters par1 and par2 in
USER(branch_id, par1, par2) as follows:
motion_val= par1*TIME^par2
5. From the File menu, select Export > Model.
Note Click the Save File icon, , on the Main toolbar to save the file in working directory
with the existing name. If its a new model, you will be prompted for the name of the
model.
The Export Model panel is displayed.
Specify the file name as Pendu_model_usersub.mdl.
7. Save and run current model , , and browse to your <working directory>. Specify
Pendu_model_usersub.xml for the MotionSolve input XML file.

8. Confirm that the Simulation type: is set to Transient.
9. Specify 1 as the End Time.
10. From the Main tab, click the Check button to check for any modeling errors.
11. After verifying that there are no errors, click the Run button.
12. In the plot window, plot the results from the ABF file Pendu_model_usersub.abf to overlay the
results on top of the results from the Pendu_model.abf file
13. In the animation window, check the Overlay option on the Load Model panel.
14. Select the file Pendu_model_usersub.h3d using the Load model folder icon .
15. Click Apply.
This will overlay the new animation over the existing animation.
Note If the value of the usrsub_param_string is set as USER(3.142, 1) the results from
step 2 will be the same as results from step 1.
17. Open the MotionSolve XML file Pendu_model.xml (saved in step 1) from the <working
directory>.

18. Browse through the XML file to locate the Motion_Joint block.
<Motion_Joint
id = "301001"
label = "Motion 0"
type = "EXPRESSION"
val_type = "D"
expr = "3.142*TIME"
joint_id = "301001"
joint_type = "R"
/>
19. Open the MotionSolve XML file Pendu_model_usersub.xml from the <working directory>.
20. Browse through the XML file to locate the Motion_Joint block.
<Motion_Joint
id = "301001"
label = "Motion 0"
type = "USERSUB"
val_type = "D"
usrsub_param_string = "USER(100001,5,2)"
usrsub_dll_name = "NULL"
usrsub_fnc_name = "MOTSUB"
joint_id = "301001"
joint_type = "R"
/>
Note When the value for the usrsub_dll_name parameter in the above block is set to NULL,
MotionSolve looks for the subroutine in a machine level DLL. This DLL is passed to
MotionSolve by the MS_USERSUBDLL environment variable.
To use an element level DLL, set the value of the usrsub_dll_name parameter to point to the
DLL.
The usrsub_param_string parameter is used to pass arguments to the user subroutine.
For example, the MOTSUB user subroutine calculates motion using the parameters par1 and par2 in
USER(branch_id, par1, par2) as follows:
motion_val= par1*TIME^par2
MotionSolve uses the value returned from the user subroutine to calculate the motion.

MV-1025: Modeling Point-to-Curve (PTCV) Higher-Pair
Constraint
Model a PTCV (point-to-curve) joint

A PTCV (point-to-curve) joint is a higher pair constraint. This constraint restricts a specified point on
a body to move along a specified curve on another body. The curve may be open or closed, planar or
in 3-d space. The point may belong to a rigid, flexible or point body. This constraint can help avoid
modeling contact in some systems. It may prove advantageous since proper contact modeling (refer
tutorial MV-1010) in many cases involves fine-tuning of contact parameters. One good example for
such a system is a knife-edge cam follower mechanism. One can avoid modeling the contact between
the cam and follower by defining a PTCV joint: the curve being the cam profile and the point being the
tip of the follower.
A Knife-edge C am Follower Mechanism
In this tutorial, we will model a knife-edge cam follower mechanism with the help of a PTCV joint.
Exercise
Copy all the files from the mbd_modeling\interactive folder to your <Working directory>.
Step 1: Creating Points.

Lets start with creating points that will help us locate the bodies and joints as required. We will define
points for center of mass of the bodies and joint locations.
1. Start a new MotionView Session. We will work with the default units (kg, mm, s, N).

2. From the Project Browser right-click on Model and select Add Reference Entity > Point (or
right-click the Points icon on the Model-Reference toolbar).
3. For Label, enter PivotPoint.
4. Accept the default Variable name and click OK.
5. Click on the Properties tab and specify the coordinates as X = 0.0 , Y = 0.0, and Z = 0.0.
6. Follow the same procedure and create the points specified in the following table:
Point X Y Z
FollowerCM 0.0 65.557 0.0
FollowerPoint 0.0 25.0 0.0
FollowerJoint 0.0 85.0 0.0
CamCM 0.0 -14.1604 0.0
Step 2: Creating Bodies.

We will have two bodies apart from the ground body in our model visualization; the cam and the
follower. Pre-specified inertia properties will be used to define the bodies.
1. From the Project Browser right-click on Model and select Add Reference Entity > Body (or
right-click the Body icon on the Model-Reference toolbar).
2. For Label, enter Cam and click OK.
4. For Label, enter Follower and click OK.
5. From the Properties tab, specify the following for the two bodies:
Body Mass Ixx Iyy Izz Ixy Iyz Izx
Cam 0.174526 60.3623 63.699 123.276 0.0 0.0 0.0
Follower 0.0228149 7.10381 0.219116 7.22026 0.0 0.0 0.0

6. For the Cam body, under the CM Coordinates tab, check the Use center of mass coordinate
system box.
7. Double click on Point.
The Select a Point dialog is displayed. Choose CamCM and click OK.
8. Accept defaults for axes orientation properties.
9. For the Follower body, under the CM Coordinates tab, check the Use CM Coordsys box.
The Select a Point dialog is displayed. Choose FollowerCM and click OK.
Step 3: Creating Joints.

Here, we will define all the necessary joints except the PTCV joint which will be defined as an
advanced joint later. We require two joints for the model. The first of them is the revolute joint
between the cam and ground body. The second joint we need is a translational joint between the
follower and ground body.
1. From the Project Browser right-click on Model and select Add Constraint > Joint (or right-click
the Joints icon on the Model-Constraint toolbar).
2. For Label, enter CamPivot.
3. Select Revolute Joint as the Type and click OK.
4. From the Connectivity tab, double-click on Body 1.
The Select a Body dialog is displayed. Choose Cam and click OK.
The Select a Body dialog is displayed. Choose Ground Body and click OK.
6. From the Connectivity tab, double-click on Point.
The Select a Point dialog is displayed. Choose PivotPoint and click OK.
7. For Axis click on the arrow and choose Vector. Now click on Vector.
The Select a Vector dialog is displayed. Choose Global Z and click OK.
9. For Label, enter FollowerJoint.
10. Select Translational Joint as the Type and click OK.

The Select a Body dialog is displayed. Choose Follower and click OK.
The Select a Body dialog is displayed. Choose Ground Body and click OK.
The Select a Point dialog is displayed. Choose FollowerJoint and click OK.
The Select a Vector dialog is displayed. Choose Global Y and click OK.
Step 4: Creating Markers.

Now, we will define some markers required for the definition of the PTCV joint. We need two markers,
one associated with the cam (for the curve) and the other associated with the follower (for the
point).
1. From the Project Browser right-click on Model and select Add Reference Entity > Marker (or
right-click the Markers icon on the Model-Reference toolbar).
The Add Marker or MarkerPair dialog is displayed.
2. For Label, enter CamMarker and click OK.
3. From the Properties tab, double-click on Body.
4. The Select a Body dialog is displayed. Choose Cam and click OK.
5. From the Properties tab, double-click on Point.
6. The Select a Point dialog is displayed. Choose PivotPoint and click OK.
7. Accept the defaults for axes orientation.
8. Add another marker by right-clicking on Model in the Project Browser and selecting Add
Reference Entity > Marker (or right-click the Markers icon on the Model-Reference
toolbar).
9. For Label, enter FollowerMarker and click OK.
11. The Select a Body dialog is displayed. Choose Follower and click OK.
13. The Select a Point dialog is displayed. Choose FollowerPoint and click OK.

Step 5: Creating Graphics.
Graphics for the cam and follower have been provided as h3d files. We need to associate the h3ds
with bodies defined in our model. To make visualization better, we will also create some graphics for
the joints.
1. From the Project Browser right-click on Model and select Add Reference Entity > Graphic (or
right-click the Graphics icon on the Model-Reference toolbar).
The Add Graphics or GraphicPair dialog is displayed.
2. For Label, enter Cam.
3. Choose File from the drop-down menu.
4. Click on the file browser icon and select CamProfile.h3d from the model folder.
5. Click Open and then OK.
6. From the Connectivity tab, double-click on Body.
The Select a Body dialog gets displayed. Choose Cam and click OK.
7. Add another graphic by right-clicking on Model in the Project Browser and selecting Add
Reference Entity > Graphics (or right-click the Graphics icon on the Model-Reference
toolbar).
8. For Label, enter Follower.
9. Choose File from the drop-down menu and click OK.
10. Click on the browser icon and select FollowerProfile.h3d from the model folder.
11. Click Open.
12. Under the Connectivity tab, double-click on Body.
The Select a Body dialog gets displayed. Choose Follower and click OK.
Next, we will add some joint graphics for better visualization and aesthetics.
2. For Label, enter PivotGraphicOne (the first graphic to show the cam pivot).
3. Choose Cylinder from the drop-down menu and click OK.

The Select a Body dialog gets displayed. Choose Ground Body and click OK.
6. Click on the arrow below Direction and select the Vector option.
7. Click on Vector.
8. From the Properties tab, specify the following values:
Property Value
Length 7.5
Offset -3.75
Radius 1 4.000
Radius 2 4.000
9. For the Cap properties, choose Cap Both Ends.
toolbar).
11. For Label, enter PivotGraphicTwo (the second graphic to show the cam pivot).
The Select a Body dialog gets displayed. Choose Cam and click OK.
16. Click on Vector.

Property Value
Length 7.6
Offset -3.8
Radius 1 2.000
Radius 2 2.000
toolbar). Add.
20. For Label, enter FollowerJointGraphic (the graphic for the follower translational joint).
21. Choose Box from the drop-down menu and click OK.
The Select a Body dialog gets displayed. Choose Ground Body and click OK.
23. For Type, choose Center from the drop-down menu.
24. Double-click on Point.
The Select a Point dialog gets displayed. Choose FollowerJoint and click OK.
25. For axis orientation, use the vector Global Z as the Z-axis and the vector Global X, to define
the ZX plane.
26. From the Properties tab, specify the following properties:
Property Value
Length X 15
Length Y 10
Length Z 10

At the end of this step, your model should look like the one shown in the figure below:
A Knife-edge C am Follower Mechanism in MotionView
Step 6: Creating the Curve.

The curve that we will use here is the curve that defines the profile of the cam. The data for this
curve has been provided in .csv format. We need to define the curve using the data in the given file.
1. From the Project Browser right-click on Model and select Add Reference Entity > Curve (or
right-click the Curves icon on the Model-Reference toolbar).
2. For Label, enter CamProfile and click OK.
to 3D Cartesian.
4. From the Properties tab, click on the x radio button.
5. Click on the file browser icon and select CamProfile.csv. Click Open.

6. Choose the properties of the curve as shown in the figure below:
7. From the Properties tab, click on the y radio button.
10. From the Properties tab, click on the z radio button.
Notice the different column numbers used for x, y, and z properties.
13. From the Properties tab, use the fourth drop-down menu to set the curve type to Closed
Curve.
Step 7: Creating the PTCV Joint.

Now, we will create the PTCV joint.
1. From the Project Browser right-click on Model and select Add Constraint > Advanced Joint (or
right-click the Advanced Joints icon on the Model-Constraint toolbar).
The Add AdvJoint dialog is displayed.
2. For Label, enter PTCV.
3. Choose PointToCurveJoint from the drop-down menu and click OK.

The Select a Body dialog gets displayed. Choose Follower and click OK.
The Select a Point dialog gets displayed. Choose FollowerPoint and click OK.
6. From the Connectivity tab, double-click on Curve.
The Select a Curve dialog gets displayed. Choose CamProfile and click OK.
7. From the Connectivity tab, double-click on Ref Marker.
The Select a Marker dialog gets displayed. Choose CamMarker and click OK.
Step 8: Specifying the Cam Motion.

After we have the topology and constraints specified, we need to provide the cam motion. The most
natural choice here is a uniform motion imposed on the revolute joint.
1. From the Project Browser right-click on Model and select Add Constraint > Motions (or right-
click the Motions icon on the Model-Constraint toolbar).
The Add Motion or MotionPair dialog is displayed.
2. For Label, enter CamMotion and click OK.
3. From the Connectivity tab, double-click on Joint. Choose CamPivot and click OK.
4. From the Properties tab, specify the properties as `10*TIME`.
Step 9: Specifying Gravity.

Since our shaft is along the Y-axis, we want the gravity to be in the negative Y direction. To specify
this:
1. Click the Forms icon on the Model-General toolbar.

2. Select Gravity and specify the following values:
Direction Value
X 0
Y -9810
Z 0
Step 10: Specifying Output Requests.

We would like to monitor the reaction on PTCV joint since it can help us verify the correctness of our
results. This will be discussed in detail towards the end of the tutorial when the topic of 'lift-offs' will
be discussed.
1. From the Project Browser right-click on Model and select Add General MDL Entity > Output
(or right-click the Outputs icon on the Model-General toolbar).
2. For Label, enter PTCV Reaction and click OK.
3. From the Properties tab, choose Expressions from the drop-down menu.
4. Click in the F2 expression box.
5. Click on the button.

6. Populate the expression as 'PTCV({aj_0.idstring},0,2,0)'.
7. Click OK.

8. Repeat the process for F3, F4, F6, F7, and F8 by changing the 3rd parameter to 3, 4, 6, 7, and
8 accordingly.
The PTCV(id, jflag, comp, ref_marker) function returns the reaction on the PTCV joint:
id ID of the PTCV joint
jflag 0 gives reaction on the I-marker and 1 on J-marker
comp component of the reaction
ref_marker reference marker (0 implies Global Frame)
Step 11: Running the Model.

We now have the model defined completely and it is ready to run.
1. Click the Run icon on the toolbar.
2. From the Main tab, specify values as shown below:
3. Choose the Save and run current model radio button.
4. Click on the browser icon and specify a file name of your choice.
5. Click Save.
6. Click Check Model button on the Model Check toolbar to check the model for errors.
7. To run the model, click the Run button on the panel.
The solver will get invoked here.

Step 12: Viewing the Results.
1. Once the solver has finished its job, the Animate button will be active. Click on Animate.
The icon can be used to start the animation, and the icon can be used to stop/pause the
animation.
One would also like to inspect the displacement profile of the follower in this mechanism. For this,
we will plot the Y position of the center of mass of the follower.
2. Use the Page Layout drop-down menu on the Page Controls toolbar to select the three-
window layout .
3. Highlight the lower right window and use the Select application drop-down menu to change the
application from MotionView to HyperGraph 2D .
4. Click the Build Plots icon on the Curves toolbar.
5. Click on the browser icon and load the result.abf file.
6. Make selections for the plot as shown below:
We are plotting the Y profile of the center of mass of the follower.
7. Click Apply.
8. The profile for the Y-displacement of the follower should look like the one shown below:

9. If we set the X-axis properties to zoom in on one cycle, the profile looks as shown below:
The profile of the cam has been designed to obtain the above Y-profile for the follower.
Now, we come to the discussion regarding lift-offs. In some cases, the dynamics of the system may
cause the follower to lose contact with the cam. This is called lift-off. In such cases, modeling the
system using a PTCV joint will give us incorrect results. This is because the PTCV joint constrains the
follower point to be always on the curve and hence cannot model lift-offs. For such cases, contact
modeling has to be used (refer tutorial MV-1010 for contact modeling). However, one would like to
start with a PTCV model since modeling a PTCV joint is a lot easier than modeling contact. Given this
scenario, the following modeling steps should be followed:
1. Model the system using a PTCV joint.
2. Monitor the PTCV joint reaction. If the reaction on the follower is a pulling reaction, it means lift-
off would have occurred and one needs to go for a contact model. Otherwise, the PTCV model is
good enough.
Now, lets check if our PTCV model is good enough. For this, we need to plot the reaction profile
on the follower. Since the follower is moving along the Y-axis, any negative reaction along the Y-
axis is a pulling reaction. So, lets plot the Y-reaction on the follower. For this:
3. Add a new page to the session by clicking on the Add Page icon .
4. Choose HyperGraph 2D and click on Build Plots .

We are plotting the Y profile of the PTCV reaction on the follower.
7. Click Apply.
The profile should look like the one shown below:
If we zoom in on one cycle by scaling the X-axis, the profile looks like this:
We see that the Y component of the PTCV reaction on the follower is always positive and hence
it is never a pulling reaction. Thus, our PTCV model is good enough to model the dynamics since
there is no expected lift-off.
In this tutorial, we learned how to model a PTCV joint and use it to model a cam-follower mechanism.
We also discussed lift-offs and ways of verifying the suitability of a PTCV joint model for modeling the
dynamics of a particular system.

MV-1026: Modeling Curve-to-Curve (CVCV)
Higher-Pair Constraint
Model a CVCV (curve-to-curve) joint

A CVCV (curve-to-curve) joint is a higher pair constraint. The constraint consists of a planar curve on
one body rolling and sliding on a planar curve on a second body. The curves are required to be co-
planar. This constraint can act as a substitute to contact modeling in many cases where the contact
occurs in a plane. One such case is the cam-follower system, in which the follower is in the form of a
roller. Instead of modeling the contact between the cam and the follower, we can specify a CVCV
constraint between their profiles.
A cam roller mechanism
In this tutorial, we will model a roller type cam-follower mechanism with the help of a CVCV
constraint.
Exercise
Copy the files CamProfile.h3d and CamProfile.csv , located in the mbd_modeling\interactive
folder, to your <Working directory>.

Lets start with creating points that will help us locate the bodies and joints that we would like to.
We will define points for center of mass of the bodies and joint locations.
1. Start a new MotionView Session. We will work in the default units (kg, mm, s, N).

3. For Label, enter PivotPoint.
4. Accept the default variable name and click OK.
5. Click on the Properties tab and specify the coordinates as X = 0.0 , Y, = 0.0, and Z = 0.0
6. Follow the same procedure for the points specified in the following table:
Point X Y Z
FollowerShaftCM 0.0 67.5 0.0
FollowerTransJoint 0.0 85.0 0.0
FollowerRevJoint 0.0 30.0 0.0
CamCM 0.0 -14.1604 0.0

We will have three bodies apart from the ground body in our model visualization: the cam, the follower
shaft and the follower roller. Pre-specified inertia properties will be used to define the bodies.
2. For Label, enter Cam and click OK.
3. Right-click on Bodies in the Project Browser and select Add Body to define a second body.
4. For Label, enter FollowerShaft and click OK.
5. Right-click on Bodies in the Project Browser and select Add Body to define a third body.
6. For Label, enter FollowerRoller and click OK.

7. From the Properties tab, specify the following for the three bodies:
Cam 0.1724 59.339 62.6192 121.240 0.0 0.0 0.0
FollowerShaft 0.0072 3.4270 0.0144 3.4270 0.0 0.0 0.0
FollowerRoller 0.0030 0.0251 0.0251 0.0375 0.0 0.0 0.0
8. For the Cam body, under the CM Coordinates tab, check the Use CM Coordsys box.
Choose CamCM and click OK.
11. For the FollowerShaft body, under the CM Coordinates tab, check the Use CM Coordsys box.
Choose FollowerShaftCM and click OK.
14. For the FollowerRoller body, under the CM Coordinates tab, check the Use CM Coordsys box.
Choose FollowerRevJoint and click OK.

Here, we will define all the necessary joints except the CVCV joint which will be defined as a advanced
joint later. We require three joints for the model. The first of them is the revolute joint between the
cam and ground body. The second joint we need is a translational joint between the follower shaft
and ground body and the third joint is the revolute joint that connects the roller to the shaft.
2. For Label, enter CamPivot.
3. Select Revolute Joint as the type and click OK.

Choose Cam and click OK.
Choose Ground Body and click OK.
6. Again from the Connectivity tab, double-click on Point.
Choose PivotPoint and click OK.
The Select a Vector dialog is displayed.
Choose Global Z and click OK.
8. Right-click on Joints in the Project Browser and select Add Joint to define a second joint.
9. For Label, enter FollowerTransJoint.
10. Select Translational Joint as the type and click OK.
Choose FollowerShaft and click OK.
Choose FollowerTransJoint and click OK.
14. For Axis, click on the arrow and choose Vector. Now click on Vector.
Choose Global Y and click OK.
15. Right-click on Joints in the Project Browser and select Add Joint to define a third joint.
16. For Label, enter FollowerRollerJoint.
17. Select Revolute Joint as the type and click OK.

Choose FollowerRoller and click OK.

Now, we will define markers required for the definition of the CVCV joint. We need two markers, one
associated with the cam and the other associated with the follower roller.
2. For Label, enter CamMarker and click OK.
6. Right-click on Markers in the Project Browser and select Add Marker to define a second
marker.
7. For Label, enter FollowerMarker and click OK.


Graphics for the cam have been provided as an h3d file. We need to associate the h3d with the cam
body defined in our model. The follower shaft and roller can be represented using primitive graphics.
To make the visualization better, we will also create some graphics for the joints.
2. For Label, enter Cam.
3. Choose File from the drop-down menu.
4. Click on the browser icon and select CamProfile.h3d from the model folder.
5. Click Open and then OK.
7. Right-click on Graphics in the Project Browser and select Add Graphic to define a second
graphic.
8. For Label, enter FollowerShaft.
Choose FollowerShaftCM and click OK.

Choose Global Y and click OK.
Property Value
Length 75
Offset -37.5
Radius 1 2.000
Radius 2 2.000
16. Right-click on Graphics in the Project Browser and select Add Graphic to define a third
graphic.
17. For Label, enter FollowerRoller.

Property Value
Length 5.0
Offset -2.5
Radius 1 5.000
Radius 2 5.000
Next, we will add some joint graphics for better visualization and aesthetics.
1. Right-click on Graphics in the Project Browser and select Add Graphic to define another
graphic.
2. For Label, enter CamPivotGraphicOne (first graphic to show the cam pivot).
7. Click on Vector.
Property Value
Length 7.5
Offset -3.75
Radius 1 4.000
Radius 2 4.000

graphic.
11. For Label, enter CamPivotGraphicTwo (second graphic to show the cam pivot).
Property Value
Length 7.6
Offset -3.8
Radius 1 2.000
Radius 2 2.000
Repeat this process for the FollowerRevJoint and label the graphics as:
RollerPivotGraphicOne on FollowShaft with a length of 7.5 and radius of 2.
and
RollerPivotGraphicTwo on FollowRoller with a length of 7.6 and radius of 1.
graphic.
20. For Label, enter FollowerTransJointGraphic (the graphic for the translational joint).

21. Choose Box from the drop-down menu and click OK.
23. For Type, choose Center from the drop-down menu.
24. Double-click on Point.
Choose FollowerTransJoint and click OK.
25. For axis orientation, use the vector Global Z as the Z-axis and the vector Global X to define
the ZX plane.
26. From the Properties tab, specify the following properties:
Property Value
Length X 15
Length Y 10
Length Z 10
At the end of this step, your model should look like the one shown in the figure below:

Step 6: Creating the Curves.
The curves that we will use here are the curves that define the profile of the cam and the roller. The
data for the cam profile curve has been provided in csv format. Since the roller profile is circular - it
can be defined using mathematical expressions.
1. From the Project Browser right-click on Model and select Add Reference Entity > Curve (or
right-click the Curves icon on the Model-Reference toolbar).
2. For Label, enter CamProfile and click OK.
to 3D Cartesian.

Notice the different column numbers used for the x, y and z properties.
13. From the Properties tab, use the fourth drop-down menu to set the curve type to Closed
Curve.
14. Right-click on Curves in the Project Browser and select Add Curve to define another curve.
15. For Label, enter FollowerRollerProfile and click OK.
to 3D Cartesian.
18. Select Math from the second drop-down menu on the left.
19. Enter 5*sin(2*PI*(0:1:0.01)) in the Expression Builder.
21. Select Math from the second drop-down menu on the left.
22. Enter 5*cos(2*PI*(0:1:0.01)) in the Expression Builder.
24. Select Math from the second drop-down menu at the left.
25. Enter 0.0*(0:1:0.01) in the Expression Builder.
26. From the Properties tab, use the fourth drop-down menu to change the curve from Open Curve
to Closed Curve.
We now have both of the curves defined.
Step 7: Creating the CVCV Joint.

Now, we will create the CVCV joint.
1. From the Project Browser right-click on Model and select Add Constraint > Advanced Joint
(or right-click the Advanced Joints icon on the Model-Constraint toolbar).
2. For Label, enter CVCV.

3. Choose CurveToCurveJoint from the drop-down menu and click OK.
4. From the Connectivity tab, double-click on Curve 1.
Choose CamProfile and click OK.
5. From the Connectivity tab, double-click on Curve 2.
Choose FollowerRollerProfile and click OK.
6. From the Connectivity tab, double-click on Ref Marker 1.
Choose CamMarker and click OK.
7. Again from the Connectivity tab, double-click on Ref Marker 2.
Choose FollowerMarker and click OK.
Step 8: Specifying the Cam Motion.

After we have the topology and constraints specified, we need to provide the cam motion. The most
natural choice here is a uniform motion imposed on the revolute joint.
1. Click the Project Browser right-click on Model and select Add Constraint > Motions (or right-
click the Motions icon on the Model-Constraint toolbar).
2. For Label, enter CamMotion and click OK.
3. From the Connectivity tab, double-click on Joint. Choose CamPivot and click OK.
4. From the Properties tab, specify the properties as `10*TIME`.

Step 9: Specifying Gravity.
Since our shaft is along the Y-axis, we want the gravity to be in the negative Y direction. To specify
this:
1. Click the Forms icon on the Model-General toolbar.
2. Select Gravity and specify the following values:
Direction Value
X 0
Y -9810
Z 0
Step 10: Specifying Output Requests.

We would like to monitor the reaction on CVCV joint since it can help us verify the correctness of our
results. This will be discussed in detail towards the end of the tutorial where we will also discuss lift-
offs.
1. From the Project Browser right-click on Model and select Add General MDL Entity > Output
(or right-click the Outputs icon on the Model-General toolbar).
2. For Label, enter CVCV Reaction and click OK.
3. From the Properties tab, choose Expressions from the drop-down menu.
4. Click in the F2 expression box.

6. Populate the expression as 'CVCV({aj_0.idstring},1,2,0)'.
7. Click OK.

8. Repeat the process for F3, F4, F6, F7, F8 by changing the third parameter to 3, 4, 6, 7, and 8
accordingly.
The CVCV (id, jflag, comp, ref_marker) function returns the reaction on the CVCV joint:
id ID of the CVCV joint
jflag 0 gives reaction on the I-marker and 1 on J-marker
comp component of the reaction
ref_marker reference marker (0 implies Global Frame)

We have the model defined completely and it is now ready to run.
1. Click the Run icon on the Model-Main toolbar.
4. Click on the browser icon and specify a file name of your choice.
5. Click Save.

animation.
One would also like to inspect the displacement profile of the follower in this mechanism. For this,
we will plot the Y position of the center of mass of the follower.

2. Use the Page Layout drop-down menu on the Page Controls toolbar to select the three-
window layout .
3. Highlight the lower right window and use the Select application drop-down menu to change the
application from MotionView to HyperGraph 2D .
We are plotting the Y profile of the center of mass of the follower.
7. Click Apply.
The profile for the Y-displacement of the follower should look like the one shown below:

If we set the X-axis properties to zoom in on one cycle, the profile will look as shown below:
The profile of the cam has been designed to obtain the above Y-profile for the follower.
Now, we come to the discussion on lift-offs. In some cases, the dynamics of the system may cause
the follower to lose contact with the cam - this is called lift-off. In such cases, modeling the system
using a CVCV joint will give us incorrect results. This is because the CVCV joint constrains the
follower point to be always on the curve. For such cases, contact modeling has to be used. However
one would like to start with a CVCV model whenever applicable, since modeling a CVCV joint is a lot
easier than modeling contact. Given this scenario, the following modeling steps should be followed:
1. Model the system using a CVCV joint.
2. Monitor the CVCV joint reaction. If the reaction on the follower is a pulling reaction, it means
that 'lift-off' would have occurred and one needs to go for a contact model. Otherwise, the CVCV
model is good enough.
Now, lets check if our CVCV model is good enough. For this, we need to plot the reaction profile
on the follower roller. Since the follower is moving along the Y-axis, any negative reaction along
the Y-axis is a pulling reaction. So, lets plot the Y-reaction on the follower roller. For this:
3. Add a new page to the session by clicking on the Add Page icon .
4. Choose HyperGraph 2D and click on Build Plots .

We are plotting the Y profile of the CVCV reaction on the follower roller.
7. Click Apply.
The profile should look like the one shown below:
If we zoom in on one cycle by scaling the X-axis, the profile looks like this:
We see that the Y component of the CVCV reaction on the follower is always positive, and hence
it is never a pulling reaction. Thus, our CVCV model is good enough to model the dynamics since
there is no expected lift-off.
In this tutorial, we learned how to model a CVCV joint and use it to model a cam-follower mechanism.
We also discussed 'lift-offs' and ways of verifying the suitability of a CVCV joint model for modeling
the dynamics of a particular system.

MV-1027: Modeling Point-to-Deformable-Curve
(PTdCV) Higher-Pair Constraint
Model a PTdCV (point-to-deformable-curve) joint
A PTdCV (point-to-deformable-curve) joint is a higher pair constraint. This constraint restricts a

specified point on a body to move along a specified deformable curve on another body. The curve may
be open or closed, planar or in 3-d space. The point may belong to a rigid, flexible or a point mass. For
this, we define a deformable curve on a beam supported at its ends by revolute joints. A mass is
constrained to move along the curve with a PTdCV constraint.
Exercise
Copy the file KG_N_MM_S_50elems2.h3d, located in the mbd_modeling\interactive folder, to your

Lets start with creating points that will help us locate the bodies and joints as required. We will
define points for center of mass of the bodies and joint locations.
3. For Label, enter PointbeamInterface1.
5. Click on the Properties tab and specify the coordinates as X = 152.4, Y, = 0.0, and Z = 0.0.
6. Follow the same procedure for the other points specified in the table below:
Point X Y Z
PointbeamInterface2 460.80 0.0 0.0
Point0 183.24 0.0 0.0
Point1 214.08 0.0 0.0
Point2 244.92 0.0 0.0
Point3 275.76 0.0 0.0
Point4 306.60 0.0 0.0

Point X Y Z
Point5 337.44 0.0 0.0
Point6 368.28 0.0 0.0
Point7 399.12 0.0 0.0
Point8 429.96 0.0 0.0

We will have two bodies apart from the ground body in our model visualization: the beam and the ball.
Pre-specified inertia properties will be used to define the ball.
2. For Label, enter Beam and click OK.
For the remainder of this tutorial - accept the default names that are provided for the rest of the
variables that you will be asked for.
4. From the Properties tab, check the Deformable box.
5. Click on the Graphic file browser icon , select KG_N_MM_S_50elems2.h3d from the <working
directory> and click Open.
The same path will automatically appear next to the H3D file browser icon .
6. Right-click on Bodies in the Project Browser and select Add Body.
7. For Label, enter Ball and click OK.
8. From the Properties tab, specify the following for the Ball:
Ball 100 1e6 1e6 1e6 0.0 0.0 0.0
9. For the Ball body, under the CM Coordinates tab, check the Use center of mass coordinate
system box.

11. Choose Point4 and click OK.
13. For the Ball body, from the Initial Conditions tab - check the Vx box under Translational
velocity and enter a value of 100 into the text box.
This sets a value of 100 for the translational velocity of the ball in the X-direction. A somewhat
high value of Vx is introduced to make the motion of the ball clearly visible in the animation.
14. Accept all the other default values.

Now, we will define some markers required for the beam. We will totally define eleven markers here at
equal distances along the span of the beam.
2. For Label, enter Marker0 and click OK.
3. Under the Properties tab, double-click on Body.
4. Choose Beam and click OK.
5. Under the Properties tab, double-click on Point.
6. Choose PointbeamInterface1 and click OK.
Accept the defaults for axes orientation.
7. Right-click on Markers in the Project Browser and select Add Marker to define a second
marker. Continue adding markers until Marker10 is reached.
8. For subsequent labels; enter Marker1, Marker2, etc. until Marker10 is reached.
9. From the Properties tab, always select the Beam (after double-clicking on Body each time).

10. From the Properties tab, select Point0 through Point8, and finally PointbeamInterface2 for
Marker10 (by double-clicking on Point every time).
Always accept the defaults for axes orientation.
A table is provided below for reference:
Marker No. Body Point
0 Beam PointbeamInterface1
1 Beam Point0
2 Beam Point1
3 Beam Point2
4 Beam Point3
5 Beam Point4
6 Beam Point5
7 Beam Point6
8 Beam Point7
9 Beam Point8
10 Beam PointbeamInterface2

Here, we will define all the necessary joints except for the PTdCV joint, which will be defined as an
advanced joint later. We require two joints for the model, both of them being fixed joints between the
beam and ground body.
2. For Label, enter Joint0.
3. Select Fixed Joint as the type and click OK.

6. Under the Connectivity tab, double-click on Body 2.
7. Choose Ground Body and click OK.
10. Right-click on Joints in the Project Browser and select Add Joint to define a second joint.
11. For Label, enter Joint1.
Step 5: Creating Deformable Curves.

Here we will now define the deformable curve on the surface of the beam. The ball is constrained to
move along this curve.
1. Click the Project Browser tab, right-click on Model and select Add Reference Entity >
Deformable Curve (or right-click the Deformable Curves icon on the Model-Reference
toolbar).
The Add DeformableCurve dialog is displayed.
2. For Label, enter DeformableCurve0, and click OK.
3. From the Properties tab, select Marker for Data type, and NATURAL for Left end type and
Right end type.
4. Check the box just to the left of the Marker collector (which situated to the far right of Data
Type).
The intermediate Add button is changed to an Insert button.

5. Enter 10 into the text box located just to the right of the Insert button, and then click on the
Insert button.
Eleven Marker collectors are displayed.
6. Click on the individual collectors.
7. Select all the markers one by one, starting from Marker 0 to Marker 10.
Step 6: Creating Advanced Joints.

Now we will define the advanced PTdCV joint.
1. From the Project Browser right-click on Model and select Add Constraint > Advanced Joint
2. For Label, enter AdvancedJoint 0.
3. From the Connectivity tab select: PointToDeformableCurveJoint, Ball for Body, Point4 for
Point, and DeformableCurve 0 for DeformableCurve.
Step 7:Creating Graphics.

Graphics for the ball will now be built here.
1. Click the Project Browser tab, right-click on Model and select Add Reference Entity > Graphic
(or right-click the Graphics icon on the Model-Reference toolbar).
2. For Label, enter Graphic0.
3. For Type, choose Sphere from the drop-down menu and click OK.
5. Choose Ball and click OK.
7. Choose Point4 and click OK.
8. From the Properties tab, enter 2.0 as the radius of the Ball.
9. From the Visualization tab, select a color for the Ball.

Step 8: Return to the Bodies Panel.
1. Click the Body icon on the Model-Reference toolbar.
2. For the beam which has already been defined, click on the Nodes button.
The Nodes dialog is displayed.
3. Uncheck the Only search interface nodes box and then click on Find All.
4. Close the the Nodes dialog.
At the end of these steps your model should look like the one shown in the figure below:
One final comment before running the model:

This type of constraint does not ensure that the contact point will stay within the range of
data specified for the curve. Additional forces at the end need to be defined by the user to
satisfy this requirement. If the contact point goes out of range of the data specified for this
curve, the solver encounters an error (unless additional forces are defined to satisfy this). In
that case, one has to change the initial velocities for the ball, or increase the range of data
specified for the curve, or run the simulation for a shorter interval of time.

We now have the model defined completely and it is ready to run.
4. Click on the browser icon and save the file as result.xml.
5. Click Save.

animation.
One would also like to inspect the displacement profile of the beam and the ball. For this, we will
plot the Z position of the center of mass of the ball.
2. Click on the Add Page icon and add a new page.
3. Use the Select application drop-down menu to change the application from MotionView to
HyperGraph 2D .

We are plotting the Z position of the center of mass of the ball.
7. Click Apply.
The profile for the Z-displacement of the ball should look like the one shown below:

MV-1028: Modeling Point-to-Deformable-Surface
(PTdSF) Higher-Pair Constraint
Model a PTdSF (point-to-deformable-surface) joint
A PTdSF (point-to-deformable-surface) joint is a higher pair constraint. This constraint restricts a

specified point on a body to move along a specified deformable surface on another body. The point
may belong to a rigid, flexible, or point body. The deformable surface for this tutorial is defined on a
rigidly supported plate. A mass is constrained to move on the surface with a PTdSF constraint.
Exercise
Copy the files membrane.h3d and membrane.fem, located in the mbd_modeling\interactive folder,
to your <working directory>.

2. Click the Project Browser tab, right-click on Model and select Add Reference Entity > Point
(or right-click the Points icon on the Model-Reference toolbar).
3. For Label, enter BallCM.
5. Click on the Properties tab and specify the coordinates as X = 0.0, Y = 0.0, and Z = 0.0.
6. Follow the same procedure for the other points specified in the following table:
Point X Y Z
PointMembInterface39 -55.00 -55.00 0.0
PointMembInterface40 55.00 -55.00 0.0
PointMembInterface41 55.00 55.00 0.0
PointMembInterface42 -55.00 55.00 0.0

We will have two bodies apart from the ground body in our model visualization: the membrane and the
ball. Pre-specified inertia properties will be used to define the ball.
1. From the Project Browser, right-click on Model and select Add Reference Entity > Body (or
2. For Label, enter Membrane.
For the remainder of this tutorial - accept the default names for the rest of the variables that you
will be asked for.
5. Click on the Graphic file browser icon and select membrane.h3d from the <working
directory>.
6. Right-click on Bodies in the Project Browser and select Add Body to define a second body.
Ball 1.00 4000.00 4000.00 4000.00 0.0 0.0 0.0
system box.
11. Choose BallCM and click OK.
13. For the Ball body, from the Initial Conditions tab - check the Vx box under Translational
velocity and enter a value of 1 into the text box.
This sets a value of 1 for the translational velocity of the ball in the X direction.
14. Repeat the same for Vy.

Step 3: Creating Markers and a Deformable Surface.
Now, we will define some markers required for the membrane.
1. From the Macros menu, select Create Markers For Deformable Surface.
The Create Markers For Deformable Surface utility is displayed at the bottom of the screen.
2. For Select the body, use the Body input collector to select Membrane.
3. Click on the Select the FEM file file browser icon and select the membrane.fem file.
4. Use the default values for the Maximum number of marker rows and Maximum number of
marker columns.
5. Click Generate Surface.
The Markers and Deformable Surface are created.

Here, we will define all the necessary joints except the PTdSF joint, which will be defined as an
advanced joint later. We require four joints for the model, all of them being fixed joints between the
membrane and the ground.
1. From the Project Browser, right-click on Model and select Add Constraint > Joint (or right-
click the Joints icon on the Model-Constraint toolbar).

2. For Label, enter Joint 1.
5. Choose Membrane and click OK.
9. Choose PointMembInterface39 and click OK.
10. Repeat the same procedure for the other three joints.
A table is provided below for your convenience:
Label Type of Joint Body 1 Body 2 Point
Joint 2 Fixed Membrane Ground Body PointMembInterface40
Step 5: Creating Advanced Joints.

Now we will define the advanced PTdSF joint.
1. From the Project Browser, right-click on Model and select Add Constraint > Advanced Joint
2. For Label, enter AdvancedJoint 0.

4. From the Connectivity tab, select:
PointToDeformableSurface Joint
Ball for Body
BallCM for Point
DeformableSurface 1 for DeformableSurface.

1. From the Project Browser, right-click on Model and select Add Reference Entity > Graphic (or
2. For Label, enter Ball.
The Select a Body dialog gets displayed.
6. Again under the Connectivity tab, double-click on Point.
The Select a Point dialog gets displayed.
8. Under the Properties tab, enter 1.0 as the radius of the Ball.
9. Under the Visualization tab, select a color for the Ball.
2. For the membrane which has already been defined, click on the Nodes button.

One final comment before running the model:

This type of constraint does not ensure that the contact point will stay within the range of
data specified for the surface. Additional forces at the end need to be defined by the user to
satisfy this requirement. If the contact point goes out of range of the data specified for this
curve, the solver encounters an error (unless additional forces are defined to satisfy this). In
that case, one has to change the initial velocities for the ball, or increase the range of data
specified for the curve, or run the simulation for a shorter interval of time.

Now we have the model defined completely and it is ready to run.

End time = 2.000
Print interval = 0.0100
3. Click on the Simulation Settings button.
The Simulation Settings dialog is displayed.
4. Click the Transient tab and as specify the Maximum step size as 0.001 (as the solution is not
converged for the default step size of 0.01):
5. Click Close to close the dialog.
6. Verify that the Save and run current model radio button is selected.

7. Click on the browser icon and save the file as result.xml in the <working directory>.
8. Click Save.

animation.
One would also like to inspect the displacement profile of the beam and the ball. For this, we will
plot the Z position of the center of mass of the ball.
HyperGraph 2D .
5. Click on the browser icon and load the result.abf file from the <working directory>.

7. Click Apply.

MV-1029: Modeling Point-to-Deformable-Surface
Force (PTdSF)
Model a PTdSFforce (point-to-deformable-surface) joint with a contact force
A PTdSFforce (point-to-deformable-surface) joint is a higher pair constraint with an added contact

force. The force is either modeled as a linear one or a Poisson type here. This constraint restricts a
specified point on a body to move along a specified deformable surface on another body. The point
may belong to a rigid, flexible or point body. The deformable surface for this tutorial is defined on a
rigidly supported plate. A mass is constrained to move on the surface with a PTdSFforce constraint.
The added feature here is that a flexible contact force acts at the center of mass of the ball between
it and the deformable surface. In this tutorial we will take up the case of the linear force model.
Exercise
Copy the following files Plate.h3d and membrane.fem, located in the mbd_modeling\interactive
folder, to your <working directory>.

3. For Label, enter BallCM.
5. Click on the Properties tab and specify the coordinates as X = 0.0, Y = 0.0, and Z = 50.0.
6. Follow the same procedure for the other points specified in the following table:
Point X Y Z
PointMembInterface39 -55.00 -55.00 0.0
PointMembInterface40 55.00 -55.00 0.0
PointMembInterface41 55.00 55.00 0.0
PointMembInterface42 -55.00 55.00 0.0

We will have two bodies apart from the ground body in our model visualization: the membrane and the
ball. Pre-specified inertia properties will be used to define the ball.
2. For Label, enter Membrane and click OK.
For the remainder of this tutorial - accept the default names that are provided for the rest of the
variables that you will be asked for.
5. Click on the Graphic file browser icon and select Plate.h3d from the <working directory>.
6. Right-click on Bodies in the Project Browser and select Add Body.
Ball 1.00 40000.00 40000.00 40000.00 0.0 0.0 0.0
system box.

Step 3: Creating Markers and a Deformable Surface.
Now, we will define some markers required for the membrane.
1. From the Macros menu, select Create Markers For Deformable Surface.
The Create Markers For a Deformable Surface utility is displayed at the bottom of the screen.
2. For Select the Body, use the Body input collector to select Membrane.
3. Click on the Select the FEM file file browser icon and select the membrane.fem file.
4. Use the default values for the Maximum number of marker rows and Maximum number of
marker columns.
5. Click Generate.
The Markers and Deformable Surface are created.

Here, we will define all the necessary joints. We require four joints for the model, all of them being
fixed joints between the membrane and the ground.
2. For Label, enter Joint 1.
5. Choose Membrane and click OK.
9. Choose PointMembInterface39 and click OK.
10. Repeat the same procedure for the other three joints.
A table is provided below for your convenience:
Label Type of Joint Body 1 Body 2 Point

Step 5: Creating Contacts.
Here we will define the contact force between the deformable membrane and the ball.
1. From the Project Browser right-click on Model and select Add Force Entity > Contact (or right-
click the Contacts icon on the Model-Force toolbar).
2. For Label, enter Contact 0.
3. Select PointToDeformableSurfaceContact for the type of contact and click OK.
4. From the Connectivity tab; select Linear as the calculation method, Ball for Body, BallCM for
Point, and DeformableSurface 1 for DeformableSurface.
5. Uncheck the Flip normal checkbox.
6. Click on the Properties tab and enter 10 for Radius, 1000 for Stiffness, and 0.2 for Damping.

2. For Label, enter Ball.
8. From the Properties tab, enter 10 as the radius of the Ball.
9. From the Visualization tab, select a color for the Ball.

2. For the membrane which has already been defined, click on the Nodes button.

Now we have the model defined completely and it is ready to run.
The Run panel gets displayed.
4. Click on the browser icon and save the file as result.xml in the <working directory>.
5. Click Save.

The can be used to start the animation, and the icon can be used to stop/pause the
animation.
One would also like to inspect the displacement profile of the membrane and the ball. For this, we
will plot the Z position of the center of mass of the ball.
HyperGraph 2D .

5. Click on the browser icon and load the result.abf file from the <working directory>.
7. Click Apply.
We can also plot the penetration distance for this flexible contact.
2. Click Apply.

3. The penetration profile as a function of time looks like the one shown below:

MV-7000: Modeling Differential Equations Using
Differential equations are very versatile and have many different applications in modeling multi-body
systems. User-defined dynamic states are commonly used to create low pass filters, apply time lags
to signals, model simple feedback loops, and integrate signals. The signal may be used to:
define forces.
used as independent variables for interpolating through splines or curves.
used as input signals for generic control modeling elements.
define program output signals.
The MotionSolve expressions and user-subroutines allow you to define fairly complex user-defined
dynamic states.
The expression type is used when the algorithm defining the differential equation is simple enough to
be expressed as a simple formula. In many situations, the dynamic state is governed by substantial
logic and data manipulation. In such cases, it is preferable to use a programming language to define
the value of a differential equation. The user-defined subroutine, DIFSUB, allows you to accomplish
this.
Step 1: Build and analyze a simplified model.

In the following exercise, we will build and analyze a simplified model of a pressure vessel blown down
using MotionView and MotionSolve.
1. We specify the following parameters (state variables) as solver variables:
2. Model the following differential equations:

The three states of the system are PT ,T T and mT.
3. Specify the initial conditions for the system as:
4. Run the model in MotionSolve and post-process the results in HyperGraph.
Creating Solver Variables

A solver variable defines an explicit, algebraic state in MotionSolve. The algebraic state may be a
function of the state of the system or any other solver variables that are defined. Recursive or
implicit definitions are not allowed at this time.
Two types of solver variables are available. The first, and probably the most convenient, is the
expression valued variable. The second is the user-subroutine valued variable.
The expression method is used when the algorithm defining the algebraic state is simple. In many
situations, the algebraic state is governed by substantial logic and data manipulation. In those cases,
it is preferable to use a programming language to define the value of a solver variable. The user-
defined subroutine, VARSUB, enables you to do this.
Solver Variables are quite versatile and have many different applications in modeling multi-body
systems. They are commonly used to create signals of interest in the simulation. The signal may
then be used to define forces, independent variables for interpolation, inputs to generic control
elements, and output signals.
MotionSolve expressions and user-subroutines allow for fairly complex algebraic states to be defined.
For more information, please refer to the MotionView and MotionSolve User's Guides in the on-line
help.
Step 2: Add a solver variable.

1. Launch a new session of MotionView.
2. From the Project Browser, right-click on Model and select Add > Control Entity > Solver
Variable (or right-click on the Solver Variables icon, , from the toolbar).
3. The Add Solver Variable dialog is displayed.
4. In the Label field, assign the label K to the solver variable.
5. In the Variable field, assign a variable name to the solver variable or leave the default name.

6. Click OK.
7. From the Properties tab, under Type:, select Linear and enter a value of 1.4 in the field.
8. Repeat steps 1 through 7 to create the three remaining solver variables:

Step 3: Modeling differential equations.
1. From the Project Browser, right-click on Model and select Add General MDL Entity > Solver
Differential Equation (or right-click on the Solver Differential Equation icon, , from the
toolbar.
2. The Add SolverDiff dialog is displayed.
3. In the Label field, assign a label to the solver diff or leave the default label.
4. In the Variable field, assign a variable name to the solver diff or leave the default name.
5. Click Apply twice.
6. Click OK. Now, three solver differential equations will be created.
7. Next, we'll model the first differential equation:
This is an implicit differential equation that has a constant (Cp/R). The initial condition of the
differential equation (IC) and its first derivative (IC dot) are known (given).
8. Select SolverDiff 0. From the Properties tab, select Implicit and specify IC and IC dot as 2000
and -58875, respectively.
9. Select the type as Expression.

10. To access the expression builder, click in the text field and select the F(x) button, , from the
trio of buttons at the top of the panel, . This will display the Expression Builder. In
this dialog, you can enter expressions in text boxes without extensive typing and memorization. It
can be used to construct mathematical expressions.

11. Populate the expression as shown in the image below:
`-DIF1 ({diff_0.id})/DIF({diff_0.id})+{sv_3.value.lin}*DIF1({diff_1.id})/
DIF({diff_1.id})`
You can use the model tree to access entity variables in your model. As you can see for the
above expression, to refer to the ID of the differential equation, browse for it from the list-tree on
the Properties tab and select the ID. Click Apply. The name of the selected entity or property
is inserted into the expression.

12. Click OK. The new expression is displayed in the text box on the panel.
13. Repeat steps 8 through 13 to modify the remaining two differential equations:
Implicit: Yes.
IC: 560
IC_dot: -4710
Value Expression:
`DIF1({diff_0.id})/DIF({diff_0.id})-DIF1({diff_1.id})/DIF({diff_1.id})-
DIF1({diff_2.id})/DIF({diff_2.id})`
Implicit: No.
IC: 0.000256
Value Expression:
`-{sv_1.value.lin} *sqrt({sv_0.value.lin}*DIF({diff_2.id})*DIF({diff_0.id}) /
{sv_2.value.lin})*0.5787`
Step 4: Running the model in MotionSolve.
1. Click the Run button, , on the toolbar. The Run panel is displayed.
2. Specify the values as shown below:

3. Under the Main tab, choose the Save and run current model radio button.
4. Click on the browser icon, , specify a filename of your choice.
5. Click Save.
6. Click Check Model button, , to check the model.
7. To run the model, click Run. The solver will get invoked here.
8. Post-process the results using Altair HyperGraph.

MV-7001: Building User Subroutines in Altair
MotionSolve
In this tutorial, you will learn how to compile and build a MotionSolve user subroutine. The user
subroutine can be implemented as C/C++ or FORTRAN source code, C/C++ or FORTRAN object files, or
a combination of these.
For your convenience, MotionSolve contains a subroutine build tool for Windows and Linux that can
build the subroutine for you. Using this subroutine requires no programming knowledge.
You can also build your user subroutine using an integrated development environment like Microsoft
Visual Studio on Windows. This is explained in this tutorial.
Minimum Software Requirements to Compile and Build MotionSolve User

Subroutine DLLs
Windows
Microsoft Visual Studio version 2005, both Express and Professional.

Intel Visual FORTRAN Compiler 10.
Linux
GCC, version 4.1.2
Using the MotionSolve Subroutine Build Tool to Create Shared

Libraries
The Altair Subroutine Builder is included in the MotionSolve installation for both Windows and Linux.
Follow these steps to build a MotionSolve-compatible shared library using available source code.
Launching the Build Tool on Windows

The build tool may be launched via the Start menu:
Start > All Programs > Altair HyperWorks (64-bit) > Tools > MotionSolve Subroutine Builder
The MotionSolve Subroutine Builder dialog is displayed:

Launching the Build Tool on Linux
You can launch the build tool from the desktop icon or from the command line by navigating to:
<altair_root>/altair/scripts/
and issuing the following command

./motionsolve_subroutine_builder
This displays the tools GUI:
Specify Source Code or Object Files
The next step is to specify the source code or the object files that you will be using to build the
shared library. The following are valid source file types and can be used to build a shared library:
C/C++ source code (*.c, *.cpp, *.cxx)
FORTRAN source code (*.f, *.f90)
FORTRAN or C/C++ object files (*.obj in Windows, *.o in Linux)
A combination of the above.

Note: The remainder of this section demonstrates using the build tool on Windows. The steps for
using the tool on Linux are identical.
The source code or object files must all be located in the same directory. You must
have write-to-disk permissions for this directory. If you do not have write-to-disk
permissions for this directory, please copy the source code to a location where you
Important do have write-to-disk permissions.
Also, if your source/object code is located in different folders on your disk, please
copy all source/object code, along with any relevant files (like headers, for example)
to one common directory. Use this as your working directory in the following steps.

1. To specify the source/object files, click next to the Source File(s) text box.
2. Navigate to your working directory and choose the source files as required. You can choose
multiple files by holding down the CTRL button while clicking the file names, or by clicking and
dragging your mouse pointer.
3. Click Open to select these files.

Specify the output directory
Next, you will specify the output directory where you would like the shared library to be built. Again,
you must have write-to-disk permissions for this directory.
1. Click Open, , next to the Output Name text box.
2. Navigate to the directory where you want the shared library to be built. Click Select Folder to
choose the current folder as the output directory.

Specify the name of the shared library
1. Before building the shared library, you need to specify a name for the shared library. To do this,
simply type in the name (without the extension) into the Output Name text box.
Note The shared library name must contain only alphanumeric characters (A-Z, a-z, 0-9) with
the exception of the underscore (_) character.
Build the shared library

1. To build your shared library, click Build.
2. For the Windows platform, if you have multiple compilers installed on your computer, you can
choose which compiler to use while building your shared library:

3. Upon building the source files successfully, the following dialog box is displayed:
Additionally, you will see the shared library built by the tool in your working directory (C:\Test in
this case). You can use this library in a MotionSolve simulation.
The tool also creates a temporary directory inside your working directory while building the shared
library. The contents of this temporary directory can be used for debugging and informational
purposes.
Note The temporary directory created inside of your working directory contains some useful
information:
build.bat: a batch file that contains the compiler and linker commands used to build the
shared library.
build_output.log: a log file that contains messages from the compiler and linker. The
contents of this file are useful when debugging an unsuccessful build.
For a successful build, this directory also contains compiled objects, the linked library and other
temporary files. If you specified only C/C++ source files and/or object files, the tool also creates
a Microsoft Visual Studio solution file in this directory.
4. If, however, your build is unsuccessful, the following dialog box is displayed:
5. To investigate the cause of build failure, you may want to look at the build_output.log file at
the location stated in the dialog box above. This file typically contains compiler/link time errors or
warnings that may help you debug your source code.

Exit the tool
1. After you have finished using the tool, you can exit by clicking Quit. If you built a shared library
before quitting, you are given the option to remove the temporary folder created by the tool.
FAQs
Q. Can the tool build a shared library when both FORTRAN and C/C++ source code is specified?
A. Yes, the tool can handle mixed source code as well as object files.
Q. What platform does the tool build my library for?
A. The supported platforms are 64-bit Windows and 64-bit Linux.
Q. Is my shared library a debug or release version?
A. The shared library created is a release version library.
Q. Where can I get sample templates for the syntax of the C/C++/FORTRAN code?
A. Sample user subroutine code is provided in the HyperWorks installation in the following locations:
For C/C++ source code:

<install>\Altair\<version>\hwsolvers\motionsolve\usersub\c_src
For FORTRAN source code:

<install>\Altair\<version>\hwsolvers\motionsolve\usersub\f_src
Note: For MotionSolve to use the functions defined in the source code, these functions must be
exported on the Windows platform (on Linux, all functions are automatically exported). The
syntax to do this for C/C++ and FORTRAN is described below.

C/C++
Include the header file msolvsub_c_include.h (located in <install>\Altair\<version>\hwsolvers

\motionsolve\usersub\c_src\include) in your code. To export a function, use the keywords
CLINKAGE, DLLFUNC, and STDCALL.
#include " msolvsub_c_include.h"

#include "stdlib.h"
CLINKAGE
DLLFUNC void STDCALL ARYSUB (int *id, double *time, double *par,
int *npar, int *dflag, int *iflag, int *nvalue, double *value)
{
}
FORTRAN
In FORTRAN syntax, the same function above can be exported as shown below:
SUBROUTINE ARYSUB (ID, TIME, PAR, NPAR, DFLAG,

& IFLAG, NVALUE, VALUE)
!DEC$ ATTRIBUTES DLLEXPORT :: ARYSUB
Q. Does the order in which I choose the source files matter?
A. Yes, this can matter in certain cases. For example, when building FORTRAN source code and
defining MODULES, you may want to include the source file that contains the definition of any defined
modules before the source files that refer to these modules.
Q. I am not able to compile FORTRAN files even though I have a supported Intel FORTRAN compiler
installed. Whats wrong?
A. The build tool relies on an environment variable to detect the version of the Intel FORTRAN compiler
and its location on your machine. Make sure you have the environment variable IFORT_COMPILERxx
(where xx is the version of the compiler 10, 11 or 12) defined correctly on your system and pointing
to the installed version.

Using the Microsoft Developer Studio to Build a Shared
Library
Note: To successfully build a shared library using the steps below, you will need to have write-to-
disk permissions for your HyperWorks installation directory.
Build a C++ user subroutine DLL using Microsoft Visual Studio

1. Open Microsoft Visual Studio 2005 (Express and Professional Editions will work).
2. From the File menu, select Open > Project/Solution.
3. Browse to <install>\Altair\<version>\hwsolvers\motionsolve\usersub\c_project, select

the file ms_csubdll.vcproj and click Open.
Note If you are using a version newer than Visual Studio 2005, you will be prompted to
convert the project file. Please proceed with the default options for the conversion.
Once converted, the new project file is loaded to your workspace.
4. In the Solution Explorer, the CPP subroutines that are part of the solution are listed.
5. Double-click any of the CPP files that you want to modify/view and make the required changes.
6. Click Save to save the changes made to the file.

7. Choose the configuration for your shared library.
Make sure that the target type for the shared library matches your HyperWorks installation. For
example, choose x64 for a 64-bit installation of HyperWorks.
8. Select Build > Build Solution to build the DLL. You will be prompted to save the solution. Save
the solution in a directory of your choice.
9. After successfully completing the build, Visual Studio displays a message as shown below:
10. The DLL ms_csubdll.dll is located in <install>\Altair\<version>\hwsolvers\motionsolve

\usersub\c_project\<platform>\<config>\ms_csubdll.dll.
Build a FORTRAN user subroutine DLL using Microsoft Visual Studio

The same steps can be repeated to build a FORTRAN user subroutine DLL for MotionSolve. The only
difference is that the Visual Studio project file to be opened is ms_fsubdll.vfproj. All the other
steps remain the same.

MV-7003: Simulating a Single Input Single Output
(SISO) Control System Using MotionView and
MotionSolve
This tutorial shows you how to implement a single input single output (SISO) controller in MotionView
and solve it using MotionSolve.
Consider the problem of maintaining the reference speed of a rotor in the presence of disturbances. A
block diagram of the control system is shown in Figure 1 below.
Figure 1 - Block diagram of the control system.
One simple approach is to design a proportional integral (PI) controller (Ogata, 1995), such that:
This tutorial shows you how to implement this PI controller.
Exercise
Step 1: Loading the rotor model.

1. From the Start menu, select All Programs > Altair HyperWorks 14.0 > MotionView.
2. Load the rotor.mdl file, located in the motionsolve folder.
The model contains a body called rotor that is attached to ground by a revolute joint. The joint
axis is parallel to the global Z-axis. There is a torsional spring-damper with only damping and no
stiffness.
The model also contains output requests for the displacement and velocity of the rotor body.

Step 2: Adding a solver variable for reference speed.
1. From the Project Browser, right-click on Model and select Add General MDL Entity > Solver
Variable (or right-click on the Solver Variables icon, , from the toolbar.
The Add SolverVariable dialog will be displayed.
2. Change Label to Reference Speed.
The variable name remains sv_0.
4. Click OK.
5. To maintain a linear speed of 3 rad/sec, from the Type drop-down menu, select Linear and enter
3 as the value of the solver variable.
Step 3: Adding a SISO Controller

In this section, add a SISO controller. The input to the controller is the error between the reference
speed solver variable and the rotor angular speed. The output of the controller is the torque to be
applied to the rotor. The parameters for the simulation are chosen, somewhat arbitrarily, as Kp=1 and
K=10.
1. From the Project Browser, right-click on Model and select Add General MDL Entity > Control
SISO (or right-click on the Control SISO icon, , from the toolbar).
The Add Control dialog will be displayed.
2. Click OK.
3. From the Input tab, select Expression from the Type drop-down menu and enter this expression:
'-WZ({MODEL.b_0.cm.idstring})+{sv_0.value}'
Note the single back quotes, indicating the expression is not to be processed by MDL, but by
Templex. The parameters inside the curly braces are evaluated.
5. To add Numerator coefficients, click Append.
6. Enter 10 and 1 for the coefficients of 1 and s, respectively.
7. Similarly, for Denominator coefficients, click Append and enter 0 and 1 for the coefficients of 1
and s, respectively.

Step 4: Adding the Control Torque
In this section, create a control torque acting on the rotor body. The Z-component of this torque is
the output of the controller.
1. From the Project Browser, right-click on Model and select Add Force Entity > Force (or right-
click on the Forces icon, , from the toolbar).
2. The Add Force or ForcePair dialog is displayed.
3. Leave the label and variable name default settings and click OK.
4. From the Connectivity tab, under Force, select Action Reaction and for Properties, select
Rotational.
5. Set Local ref. frame by double-clicking Ref Marker and selecting Global Frame.
6. Double-click Body 1 for Action force on: and select the rotor body.
7. Double-click Body 2 for Reaction force on: and select Ground Body.
8. Double-click Point 1 for Apply force at: and select Point 0.
9. Click the Rot Properties tab and leave Tx and Ty set to 0.
10. Under Tz, select Expression and enter `{MODEL.siso_0.OUTPUT}`.
11. You may also click to access the expression builder and create this expression using the model
tree.
Step 5: Adding Output Requests for Control Force

1. From the Project Browser, right-click on Model and select Add General MDL Entity > Output
(or right-click on the Outputs icon, , from the toolbar).
2. The Add Output dialog will be displayed.
3. Enter Control force for the Label name and click OK.
4. Specify other choices as shown in figure 2 below:
Figure 2 - Setting up the output request for control force.

Step 6: Running the Simulation
1. Click the Run button, , on the toolbar to display the Run panel.
2. Under Simulation type, select Transient and specify the output (.xml) filename.
3. Enter 25 for the End time:.
4. Click Run.
The results are displayed in the image below.
Figure 3 - Simulation results for the PI speed controller.
Reference
K. Ogata, Modern Control Engineering, 1990, Prentice-Hall Inc., Englewood Cliffs, N.J., US

MV-7004: Inverted Pendulum Control Using
MotionSolve and MATLAB
This tutorial illustrates how to use MotionView and MotionSolve to design a control system that
stabilizes an inverted pendulum. The goal is to design a regulator using the pole placement method.
The inverted pendulum MDL model file is supplied.
The tutorial steps include:
Check the stability of the open loop system.

Export linearized system matrices A,B,C, and D using MotionSolve linear analysis.
Design a controller using MATLAB.
Implement a controller in MotionView.

Check the stability of a closed loop system using MotionSolve linear analysis.
Add disturbance forces to the model and run simulation using MotionSolve.
Figure 1 shows the classic inverted pendulum on a slider. The system has two degrees of freedom
leading to four state variables. The vertically upright position of the pendulum is unstable. The goal
is to design a regulator to stabilize this configuration.
Figure 1: Inverted pendulum model

We want to find a full-state feedback control law to achieve our goal. The control input is a force
applied to the slider along the global X-axis. Plant output is the pendulum angle of rotation about the
global Y-axis.
Start by loading the file inv_pendu.mdl, located in the mbd_modeling\motionsolve folder, into
MotionView. Upon examination of the model topology, you will notice that everything needed for this
exercise is already included in the model. However, depending on which task you are performing, you
will need to activate or deactivate certain entities.
Step 1: Determine the stability of the open loop model

Compute the eigenvalues to determine the stability of the Inverted pendulum.
Compute Eigenvalues
1. From the Project Browser, click the Forces folder and make sure that Control ForceOL is
activated, while Control Force CL and Disturbance-step are deactivated.
2. From General Actions toolbar, click the Run icon, .
3. From the Simulation type drop-down menu, select Static + Linear.
4. Specify the output filename as inv_pendu_ol_eig.xml.
5. Select the MDL animation file (.maf) option.
6. Click Run.
7. Once the solution is complete, close the solver execution window and the message log.
8. The eigenvalues computed by MotionSolve are shown in the table below and can be viewed in
the inv_pendu_ol_eig.eig file using a text editor
Table - Open Loop Eigenvalues
EIGENVALUES
Number Real(cycles/unit time) Imaginary(cycles/unit time)

1
-1.625373E-02 0.00000000E+00
2
-4.003211E-01 0.00000000E+00
3
5.581881E-01 0.00000000E+00
4
-1.732850E+00 0.00000000E+00
There is one eigenvalue with a positive real part, indicating that the system is unstable in the
current configuration.
9. Click Animate.
The result animation H3D will be loaded in the adjacent window.

10. From the Results Browser, select individual modes.
11. Click Start/Pause Animation, , to visualize the mode shape.
Step 2: Obtaining a Linearized Model

Usually, the first step in a control system design is to obtain a linearized model of the system in the
state space form,
where A,B,C,and D are the state matrices, x is the state vector, u is the input vector, and y is the
output vector. The A,B,C,and D matrices depend on the choice of states, inputs, and outputs. The
states are chosen automatically by MotionSolve and the chosen states are reported in one of the
output files. We need to define only the inputs and outputs.
1. Expand the Solver Variables folder in the Project Browser and examine the entities..
a. Control Force Variable - CL is used to define the control input after the control law has
been found. Ignore this at this stage.
b. Control Force Variable - OL is used to define the control plant input, which is a force
named Control Force - OL. This force is applied to the slider body. This variable is set to
zero. It is needed by MotionSolve to properly generate the linearized system matrices.
c. Solver variable Pendulum Rotation Angle defines the control plant output and measures the
pendulum rotation about the Global Y-axis.
2. Expand the Solver Array folder in the Project Browser and examine the solver arrays that are
defined.
a. Select Plant-I This array defines a solver array entity of type Plant-Input. Ensure that
Solver Variable is set to Control Force Variable - OL. Click OK.
b. Select Plant-O This array defines a solver array entity of type Plant-Output. Ensure that
Solver Variable is set to Pendulum Rotation Angle.
Note Please note that the plant input and plant output IDs used in linearization are specified
automatically by MotionView while exporting the solver deck.
3. Click the Run icon, .
4. From the Simulation type drop-down menu, select Linear.

5. Specify the output filename as inv_pendu_state_matrices.xml.
Linear tab in Simulation Settings dialog for specifying the MATLAB matrix files output
6. From the Simulation Settings dialog > Linear tab, select the State-Space matrices (MATLAB)
option.
7. From the Main tab, click Run.
You should get six new files with base name inv_pendu_state_matrices and extensions
.a, .b, .c, .d, .pi, .po. The .pi and .po files contain information about the input and output
variables.
The states chosen by the MotionSolve solver are:
1. Angular displacement about the global-Y axis.
2. Translation displacement along the global X-axis.
3. Angular velocity about the global-Y axis.
4. Translation velocity along the global X-axis of the pendulum body center of mass marker.

Step 3: Control System Design in MATLAB
A detailed discussion of control system design is beyond the scope of this document. However, the
steps to design a regulator using pole placement [1] to stabilize the inverted pendulum are described
briefly. For details, refer to the standard controls text and the MATLAB documentation.
It can be easily verified using MATLAB that the system is completely state controllable [1, 2]. We
employ a full-state feedback control law
u = -k*x, where u is the control input, k is the gain vector, and x is the state vector. Then,
assuming the desired pole locations are stored in vector P, you may use the pole placement method to
compute k. For desired poles at [-20 20 20 20] (rad/s), the acker function in MATLAB yields
k=1e3[-2.4186 -0.0163 -0.070 -0.0033].
Step 4: Implementing the Control Force in MotionView

The control force is simply u=-k*x. The model contains a solver variable called Control Force
Variable - CL. It is defined using the expression:
`-1e3*(-2.4186*AY({b_pendu.cm.idstring})-0.0163*DX({b_pendu.cm.idstring}),-
0.070*WY({b_pendu.cm.idstring})-0.0033*VX({b_pendu.cm.idstring}))`
Notice that it is simply the dot product between the gain vector (k) and the state vector (x)
elements. This solver variable is used to define a force named Control Force - CL.
Activate the force Control Force - CL if it is deactivated.
Step 5: Check the Stability of a Closed Loop System

1. From the SolverMode menu, select MotionSolve. Activate the force Control Force - CL if it is
deactivated.
2. From the Run panel, under Simulation type, select Linear.
3. Specify the output file as inv_pendu_cl_eig.xml and click Run.
4. The eigenvalues are given below.
Table - Closed Loop Eigenvalues
EIGENVALUES at Time = 0.0
Number Real(cycles/unit time) Imag.(cycles/unit time)
1 -2.027203E+00 0.000000E+00
2 -3.673652E+00 0.000000E+00
3 -3.461575E+00 1.336447E+00
4 -3.461575E+00 -1.336447E+00
They all have negative real parts, hence the system is stabilized. Note that the negative real
parts are close to the desired poles (-20 rad/s = -3.038 Hz).

Step 6: Add Disturbance Force and Run the Simulation
1. Activate force acting on the slider titled Disturbance-step, defined using a step function:
Fx= `step(TIME,.1,0,.5,50) + step(TIME,1,0,1.5,-50)`
Fy=0
Fz=0
Run a dynamic simulation with MotionSolve.
Follow these steps.
1. From the Project Browser, activate deactivated outputs Output control force - final and
Output Disturbance step.
2. From the toolbar, click the Run icon, .
3. From the Simulation type drop-down menu, select Transient.
4. Specify the output filename as inv_pendu_dyn.xml.
5. Specify the End time and Print interval as 3.0 and 0.01, respectively.
6. From the Main tab, click the Run button.
7. Once the job is completed, close the solver window and plot the following results in a new
HyperGraph page using inv_pendu_dyn.abf.
Output Y-Type Y-Request Y-

Componen
t
control force Marker Force REQ/70000014 Output control force final FX
(on Body Slider)
disturbance force Marker Force REQ/70000017 Output Disturbance step (on FX

Body Slider)
slider displacement Marker REQ/70000006 Output slider-disp (on Body DX

-X Displacement slider)
pendulum angular Expressions REQ/70000016 Output Pendu rotation F2

displacement

The plots of disturbance force, control force, slider x displacement, and pendulum angular
displacement are shown below.
Figure 2: Plots of disturbance and control forces as well as slider translational and pendulum angular
displacements.
References
Feedback Control of Dynamic Systems, G. G. Franklin, J. D. Powell, and A. Emami-Naeini, Third Edition,
Addison Wesley.
See also
MATLAB Documentation, www.mathworks.com.

MV-7005: Linking Matlab/Simulink Generated Code
(Simulink Coder) with MotionSolve
This document describes how to generate a dynamic link library (DLL) using Simulink Coder (formerly
Real-Time Workshop) and link it with MotionSolve to run a co-simulation.
Pre-requisites:
1. A working installation of MotionSolve (v12 and above)
2. A working installation of MATLAB, Simulink, MATLAB Coder, and Simulink Coder
3. A working installation of Microsoft Visual Studio (MSVS) 2010
Check for supported versions of MATLAB and MSVS here:
Supported Versions - Third Party Software in the XML Format Reference Guide.
This example uses MATLAB R2011b with MSVS 2010.
Step 1: Prepare the MotionSolve Model

The MotionSolve model is set up to communicate with an external solver by using the modeling
statements Control_PlantInput and Control_PlantOutput:
<Control_PlantInput
id = "30100100"
num_element = "2"
variable_id_list = "30100400, 30100500"
sampling_period = "0.01"
offset_time = "0.0"
label = "for controller 1"
usrsub_param_string = "USER(987654321)"
usrsub_dll_name = "rtw_BusSuspension2PMIMODiscrete"
usrsub_fnc_name = "PINSUB"
hold_order = "2"
/>
<Control_PlantOutput
id = "30100200"
num_element = "2"
variable_id_list = "30100200, 30100300"
offset_time = "0.0"
usrsub_fnc_name = "POUTSUB"
hold_order = "2"
/>
<Control_PlantInput
id = "30100300"
num_element = "2"
variable_id_list = "30100800, 30100900"
offset_time = "0.0"

usrsub_fnc_name = "PINSUB"
hold_order = "2"
/>
<Control_PlantOutput
id = "30100400"
num_element = "2"
variable_id_list = "30100600, 30100700"
offset_time = "0.0"
usrsub_fnc_name = "POUTSUB"
hold_order = "2"
/>
The key attributes of Control_PlantInput and Control_PlantOutput needed to link a Simulink
Coder DLL are listed below.
Attribute Description
usrsub_param_string Set this parameter equal to "USER(id)", where the ID is an integer (for
example, 123) that you choose. The ID identifies the Simulink Coder
library, links all Control_PlantInput's and Control_PlantOutput's that
use the library, and must be unique.
Note: There can be more than one Control_PlantInput/
Control_PlantOutput per library.
usrsub_dll_name The name of the DLL that is used (for example, from Simulink Coder).
usrsub_fnc_name The name of the user function/subroutine that MotionSolve calls. This
has to necessarily be "PINSUB" for Control_PlantInput and "POUTSUB"
for Control_PlantOutput.
In this case, this MotionSolve model has been prepared for you. Copy the MotionSolve and Simulink
models, rtw_BusSuspension2PMIMODiscrete.xml and rtw_BusSuspension2PMIMODiscrete.mdl,
located in the motionsolve\cosimulation folder to your <working directory>.

Step 2: Preparing the Simulink Model Generating Code
Before starting with the simulation, the Simulink model needs to be created and prepared to work with
MotionSolve. After generating the contents of the Simulink model, MotionSolve requires the Simulink
components Inport and Outport, which represent the interface to the MotionSolve model. For
example, like the following (blocks labeled below as In1, In2, Out1, Out2):
Note: If you have multiple inports/outports, you must retain the above illustrated naming scheme. All
your inports must be defined as In1, In2, , Inx. Similarly, all your outports must be named as
Out1, Out2, , Outx. This is a limitation within the current co-simulation framework and will be
addressed in a future release. See Appendix B for more information.
The order of these Inport's and Outport's must match the order of the Control_PlantOutputs and
Control_PlantInput's, respectively, in the MotionSolve model.
1. Open rtw_BusSuspension2PMIMODiscrete.mdl in Simulink.

2. Specify the configuration parameters in the solver, which is used by Simulink Coder. To do this,
use the Simulation > Configuration Parameters menu option as shown below.

3. In the left-side browser/tree, select the Code Generation option:

4. Here, change the System target file by clicking Browse and search for grt.tlc Create
Visual C/C++ Solution File for the grt target. This is shown below:
5. Once this is done, change the Language option to C++ in this same Code Generation window.

6. Next, in the left-side browser/tree, select the Solver option:
Simulink Coder does not allow using a variable-step integrator for the Generic Real-Time target
that is required by MotionSolve to generate this code (more details on selecting the Generic Real-
Time target later in this tutorial). So, under the Solver option on the left, choose the Fixed-
step solver, as shown below:
Note See the Mathworks documentation for more details on selecting an appropriate fixed-step
size for your model (in particular, if the model has multiple sample times, you will likely
need to choose a step size equal to the least common denominator of the specified
sample times so that each sample time is hit by the solver).
7. Next, in the left-side browser/tree, select the Code Generation option again.

8. Click on Build to build the code. The code generation creates two folders in the current directory
of MATLAB (here <Simulink_model> is the name of the model):
<Simulink_model>_grt_rtw
slprj
You should see messages that look similar to those below and end with:
### Successful completion of Real-Time Workshop build procedure for model:

rtw_BusSuspension2PMIMODiscrete
or similar.

Step 3: Modifying, Compiling and Linking the Code to Create the DLL
At this point, Simulink Coder has generated source code for the Simulink model, but this must be
modified and recompiled to generate the DLL required by MotionSolve. In the next steps, you will use
a script to automatically compile and link this code and generate the Simulink Coder DLL that will be
used in the MotionSolve model.
1. Open a command prompt in your working directory (where Simulink has generated the code).
2. Issue the following command:

ms_rtw_pre <mdl_name> <altair_root> <msvs_root> <win32|win64>
where,
<mdl_name> is the name of the Simulink model (without the extension .mdl)
<altair_root> is the complete path to the root folder of the HyperWorks installation
<msvs_root> is the complete path to the root folder of the MSVS installation
<win32|win64> specify win32 or win64 depending on the required platform of the DLL
Notes:
1. To successfully issue the ms_rtw_pre command, please include the path of the MotionSolve
binaries in the PATH environment variable. This can be done locally by issuing the following
command on Windows:
set PATH = <MS_bin_path>;%PATH%
where <MS_bin_path> is the path to the MotionSolve binaries; for example, C:\Program Files
\Altair\13.0\hwsolvers\motionsolve\bin\win64
2. If the path to <altair_root> and/or <msvs_root> contains spaces, make sure to enclose the
path in quotes.
An example of the above command for this model is:

ms_rtw_pre rtw_BusSuspension2PMIMODiscrete "C:\Program Files\Altair\13.0" "C:\Program
Files (x86)\Microsoft Visual Studio 10.0" "win64"
Issuing the above command does the following:
Automatically modifies the project settings and source files of the original solution generated
by Simulink Coder
Compiles and links the source code to generate a DLL that can be used with MotionSolve
You can confirm that this process has completed successfully by looking at the output in the
command window. On successful execution, you should see something like the following:
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========
1 file(s) copied.
** RTW dll is ready **

Step 4: Run a MotionSolve Model with The Generated DLL
At this point, you simply need to point MotionSolve to the Simulink library to complete the co-
simulation. By default, it assumes that it is in the same directory as the MotionSolve model.
1. In this example, the ms_pre_rtw script should have created the generated DLL into the same
folder where the MotionSolve model (.xml) resides. If the DLL is created elsewhere, copy it to
the working directory of the MotionSolve .xml file.
2. Open a command window and change the path into this folder in order to run the model.
3. You will be running the MotionSolve model on command line, so certain environment variables must
be set to be able to invoke MotionSolve. See the MotionSolve Users Guide for more details on
the options to run on the command line.
4. Run the MotionSolve model in the command line by issuing the command mbd_d x.xml x.mrf.
The simulation should run quickly and you should review your results to confirm that the process
worked as expected.
Appendix A
This section discusses the access functions CoSimAPI_SimulinkRTW_Update_U(api,model,input)
and CoSimAPI_SimulinkRTW_Update_Y(api,model,output). These are added to the Simulink model
source code in order to help perform the co-simulation via the DLL.
CoSimAPI_SimulinkRTW_Update_U(void *api, const RT_MODEL_x x_M, ExternalInputs_x &x_U)
This method updates the input data structure in the Simulink Coder generated code with the output
from MotionSolve.
The first argument requests a pointer to the API ID. The API ID is passed from the model XML in the
line usrsub_param_string = "USER(987654320)". The first parameter in the USER() string is always
the ID of the API. The MotionSolve API provides the method void * CoSimAPI_Get_API_Ptr(int
api_id) to get the API pointer, where the api_id is the number specified in the XML file in the
USER() string.
The second argument requests data structure x_M related to the generated Simulink Coder model
information where x is the name of the model. The x_M data structure is inherent to the Simulink
code.
The last argument requests input x_U where x_U is the data structure used by the Simulink Coder
code to store the external inputs (see Appendix B).
CoSimAPI_SimulinkRTW_Update_Y(void *api, const RT_MODEL_x x_M, const
ExternalOutputs_x x_y)
This method updates the input for the MotionSolve solver with output from the RTW generated code.
The first and second arguments are the same as described in the previous section.
The last argument requests RTW output x_Y which is deposited to MotionSolve for that current time
step, where x_Y is the data structure used by the Simulink Coder code to store the external outputs
(see Appendix B).

Appendix B
This section describes the data structure that Simulink Coder generated code uses for representing
the external input/output ports. In the following lines, the name of the model is assumed to be
rtw_MS (rtw = Real Time Workshop, former name of Simulink Coder).
Typically, the Simulink Coder generated code (SCGC) uses the following notations:
Input port to Simulink with single channel rtw_MS_U.In1, rtw_MS_U.In2 etc.
Output port from Simulink with single channel rtw_MS_Y.Out1, rtw_MS_Y.Out2 etc.
Input port with multiple channels rtw_MS_U.In1[0], rtw_MS_U.In1[1] etc.
Output port with multiple channels rtw_MS_Y.Out1[0], rtw_MS_Y.Out1[1] etc.
So for example, for a model with two Control_PlantInput (CPI) elements where the first has three
channels and the second has two channels, the corresponding data structure in Simulink Coder code
would be:
CPI #1: rtw_MS_U.In1[0], rtw_MS_U.In1[1] and rtw_MS_U.In1[2]
CPI #2: rtw_MS_U.In2[0] and rtw_MS_U.In2[1]
The same scheme is applicable for the data structure that handles Control_PlantOutput ports.
Note If the Simulink model has labels defined for the input/output links, then these labels will replace
In and Out in the data structure described above. In and Out are the default names
used by Simulink in case the links are not named. In this scenario, you need to change the
first input variable name specified in the rtw api function template
CoSimAPI_SimulinkRTW_Update_U(api,model,input) into the one you specified.
For example, if you name the first input to be myIn instead of In1, you need to make the following
change to that function template:
double *u_ptr = (double *)&u.myIn;
to replace the original code:

double *u_ptr = (double *)&u.In1;

Use Python to make a user subroutine for MotionSolve. It is assumed that you are familiar with
Python and MotionSolve XML syntax.
Convert a model with six SFOSUBs, written in C, into a Python usersub.
Using scripting language such as Python gives you power with reduced complexity. These scripts are
interpreted and do not require compiling. Therefore, you do not need a building tool to build
subroutines. Furthermore, scripts are easier to read and understand, and can be used for faster
prototyping.
If you do not have much programming experience, writing scripts for user-subroutines is simpler than
writing C code. For a C user, the usage is even simpler. Besides following the language syntax of
Python, you only need to follow the rules to convert the C code into Python scripts.
For your reference, a sample set of Python user subroutines is available in the hwsolvers
\motionsolve\usersub\py_src folder.
Rules for Written Python User Subroutines

It is easy to understand the usage for py_* utility functions from the usage of their c_* counterparts,
with the help of the following rules:
1. The output arguments should be moved to the left-hand-side.

c_datout(&istat);
becomes
istat = py_datout()
In C utility functions, the input and output arguments are combined in an argument list. In
Python, the arguments of the py_* utility functions are strictly the input arguments. All output
arguments should be moved to the left-side as return values of the function call.
2. In C utility functions, any input or output array argument is generally followed by an integer
argument for the array size. In Python utility functions, the integer argument for the array size is
removed because it is not necessary.
ipar[0] = (int)par[0];
c_sysfnc("DM", ipar, 2, &dm, &errflg);
simply becomes
[dm, errflg] = py_sysfnc("DM", [par[0],par[1]])
and
c_sysary("TDISP", ipar, 2, u1, &nstates, &errflg);

becomes
[u1, errflg] = py_sysary("TDISP", [par[1],par[0]])
3. Change the function name from c_* to py_*.
c_rcnvrt(sys1, coord1, sys2, coord2, &istate);
becomes
[coord2, istate] = py_rcnvrt(sys1, coord1, sys2)
Step 1: Convert C sub into Python sub.

1. In this example, the model uses six SFOSUBs written in C code as shown below:
DLLFUNC void STDCALL SFOSUB (int *id, double *time, double *par,
int *npar, int *dflag, int *iflag, double *result)
{
// --- Add your local definitions here ---------------------
double vector[3],dm,vm;
int ipar[2], iord;
int errflg;
// --- Add your executable code here -----------------------
int itype = (int)par[0];

iord = 0;
if (itype==50)
{
c_sysfnc("DM", ipar, 2, &dm, &errflg);
c_sysfnc("VM", ipar, 2, &vm, &errflg);
c_impact(dm, vm, par[5], par[6], par[7], par[8], par[9], iord,
vector, &errflg);
*result = vector[0];
}
}
2. Following the rules specified in last section, the corresponding Python script is shown as:
def SFOSUB(id, time, par, npar, dflag, iflag):
[dm, errflg] = py_sysfnc("DM", [par[0],par[1]])

[vm, errflg] = py_sysfnc("VM", [par[2],par[3]])
[vector, errflg] = py_impact(dm, vm, par[4], par[5], par[6], par[7],
par[8], 0)
return vector[0]

3. Besides the Python scripts, you also need to specify in the XML model the Python scripts that are
used in the user subroutine. MotionSolve provides this definition through two attributes in the
corresponding elements that uysrsub can be defined.
1. interpreter = "Python"
2. script_name = "script_name.py"
This combination replaces the attribute usrsub_dll_name in that element.
4. The following image shows the difference between using C user sub and Python user sub in this
example:
5. In the original model, there are six Force_Scalar_TwoBody elements that use SFOSUB written in
C:
<Force_Scalar_TwoBody
id = "30701"
type = "Force"
i_marker_id = "30701010"
j_marker_id = "30701011"
usrsub_param_string =
"USER(50,30301010,30401010,30301010,30401010,10,10,2.0,0.001,0.01)"
usrsub_fnc_name = "SFOSUB"
/>
id = "30801"
type = "Force"
i_marker_id = "30801010"
j_marker_id = "30801011"

usrsub_param_string = "USER
(50,30301010,30501010,30301010,30501010,10,10,2.0,0.001,0.01)"
/>
id = "30901"
type = "Force"
i_marker_id = "30901010"
j_marker_id = "30901011"
(50,30301010,30601010,30301010,30601010,10,10,2.0,0.001,0.01)"
/>
id = "31001"
type = "Force"
i_marker_id = "31001010"
j_marker_id = "31001011"
"USER(50,30401010,30501010,30401010,30501010,10,10,2.0,0.001,0.01)"
/>
id = "31101"
type = "Force"
i_marker_id = "31101010"
j_marker_id = "31101011"
"USER(50,30401010,30601010,30401010,30601010,10,10,2.0,0.001,0.01)"
/>
id = "31201"
type = "Force"
i_marker_id = "31201010"
j_marker_id = "31201011"
"USER(50,30501010,30601010,30501010,30601010,10,10,2.0,0.001,0.01)"
/>
6. After changing C SFOSUB into Python SFOSUB, the XML content above is replaced with the
following:
id = "30701"
type = "Force"
i_marker_id = "30701010"
j_marker_id = "30701011"
"USER(30301010,30401010,30301010,30401010,10,10,2.0,0.001,0.01)"

script_name = "script/sfosub.py"
/>
id = "30801"
type = "Force"
i_marker_id = "30801010"
j_marker_id = "30801011"
(30301010,30501010,30301010,30501010,10,10,2.0,0.001,0.01)"
/>
id = "30901"
type = "Force"
i_marker_id = "30901010"
j_marker_id = "30901011"
"USER(30301010,30601010,30301010,30601010,10,10,2.0,0.001,0.01)"
/>
id = "31001"
type = "Force"
i_marker_id = "31001010"
j_marker_id = "31001011"
"USER(30401010,30501010,30401010,30501010,10,10,2.0,0.001,0.01)"
/>
id = "31101"
type = "Force"
i_marker_id = "31101010"
j_marker_id = "31101011"
"USER(30401010,30601010,30401010,30601010,10,10,2.0,0.001,0.01)"
/>
id = "31201"
type = "Force"
i_marker_id = "31201010"
j_marker_id = "31201011"
"USER(30501010,30601010,30501010,30601010,10,10,2.0,0.001,0.01)"

/>
7. With these changes (C code into Python code and XML model change), the model with Python
user subroutines are ready to run with MotionSolve.

In this tutorial, you will learn more about:
The MotionSolve joint friction model.

How to model Joint friction in MotionView/MotionSolve.
How to review the friction results.
Introduction
Friction is defined as a resistance force opposing motion. Friction appears at the physical interface
between any two surfaces in contact. Friction force arises mainly due to adhesion, surface roughness
and plowing at the contact surfaces.
1. When contacting surfaces are smoother and brought to closer proximity; molecular adhesive
forces forms resistance to motion.
2. When contact surfaces are highly rough to cause abrasion on sliding; surface roughness resists
motion.
3. When one surface in contact is relatively soft, plowing effect causes most of resistance.
Friction forces generated depend on:
Surface contact geometry and topology

Properties of the bulk and surface materials
Displacement and relative velocity
Lubrication
Friction is highly non-linear and dependents on system states like stiction regime, transition regime
and sliding (or) dynamic regime.
The three characteristics of a friction function
The friction force varies based on its states (as shown in the above figure). The (a) section shows
Coulomb friction, (b) shows Stiction plus Coulomb friction, and F(c) shows how the friction force may
decrease continuously from the static friction level due to lubrication also known as Stribeck effect.

Dynamics of friction
Friction-velocity relation or damping characteristics of friction will aid in dampening vibrations. There
are other behaviors of friction such as pre-sliding and hydrodynamic effects of lubrications during
dynamic simulations. Resistant forces from the above mentioned effects need consideration in design
of drive systems and high-precision servo mechanisms. So, its important to model friction accurately
to capture system dynamics.
Joint friction
Friction in joint depends on its geometry. MotionSolve uses an analytical model to represent friction
for different joints based on geometry, preloads, torque and lubrication.
Characterizing joint friction using LuGre friction model
MotionSolve uses LuGre model for friction representation. LuGre model is a bristle model emerged for
controls applications. LuGre model was presented by Canudas de Wit, Olsson, strom, and Lischinsky.
Stemming from a collaboration among researchers at the Lund Institute of Technology (Sweden) and
in Grenoble France (Laboratoire dAutomatique de Grenoble), the LuGre model captures a variety of
behaviors observed in experiments, from velocity and acceleration dependence of sliding friction, to
hysteresis effects, to pre-slip displacement and lubrication.
The Bristle model for friction
LuGre model can model friction considering geometry of joint, preload, moment arm, force and torque.
Friction is supported for a subset of joints namely Revolute, Spherical, Translational Joint, Cylindrical,
and Universal Joint. Please refer to our MotionSolve online help for a detailed explanation of friction for
each constraint.
This tutorial uses an experimental model of a block sliding on a table to demonstrate friction forces
under stick-slip condition and frequency dependency of friction forces.

Exercise
Copy the SlidingTable.mdl file, located in the mbd_modeling\motionsolve folder, to your <working
directory>.
The leader and follower model constitutes two rigid bodies namely Leader and Follower respectively
connected to the Ground body by translation joints and inter connected by a linear spring. In the
following steps you will add friction and apply motions to study friction behavior of the translation
joint.
Step 1: Adding Joint Friction.

1. From the Project Browser, browse to the Joints folder and select Follower Translation Joint.
2. From the Joints panel, go to the Friction Properties tab.
3. From the Friction Properties tab, check the Use Friction option to activate friction on joint.
Note MotionView populates the panel with default properties that are appropriate with units N,
mm, second. You will need to scale properties such as Stiction Transition Velocity,
Force Preload, and Geometric properties (Initial Overlap, Reaction Arm) according to
the units.

4. Uncheck the Bending Moment and Torsion Moment options to exclude joint reaction forces due
to geometry misalignments. Modify the Initial Overlap value to 10mm and leave the remaining
values at their default settings.
5. Select the LuGre Parameters tab to modify the Bristle properties. Modify the Damping
Coefficient value to 0.0316.
Note Default properties of bristle are appropriate with units N, mm, second.
6. Leave all the LuGre parameters at their default values.
Step 2: Adding output requests for friction force.

In this step you will create an output to measure the friction forces on the Follower Translation Joint.
1. Right click the Output icon from General MDL Entity Tool bar.
2. Change the Label to Friction_Force.

3. Change the Variable to o_friction.
4. Click OK to add output request.
5. From the Properties tab, select the output type as Expressions.
6. Click in the F2 expression field.

8. Populate the Expression Builder with the FRICTION function expression as:
`FRICTION({j_contact.id},1)`.
Follower Translation Joint ID = {j_contact.id},
Fx component =1
9. Click OK.
10. Repeat the process for F3, F4, F6, F7, and F8 by changing the second parameter to 2, 3, 4, 5,
and 6 accordingly.
The function FRICTION(ID, comp) computes the friction force component specified in the comp
corresponding to the joint ID.
ID The ID of the Joint.
comp The force component. Currently, a range of 1-18 is supported.
1 = Friction force FX along the x-axis of the J marker of the joint.
2 = Friction force FY along the y-axis of the J marker of the joint.
3 = Friction force FZ along the z-axis of the J marker of the joint.
4 = Friction torque TX along the x-axis of the J marker of the joint.
5 = Friction torque TY along the y-axis of the J marker of the joint.
6 = Friction torque TZ along the z-axis of the J marker of the joint.

Step 3: Adding output request for sliding velocity.
Friction forces are characterized with respect to the relative velocity between bodies under contact.
So, you will create an output request to measure Follower body velocity.
1. Right click the Outputs icon on the General MDL Entity toolbar.
2. For Label, enter Follower_Velocity.
3. For Variable, enter o_velocity.
4. Click OK to add the output request.
5. From the Properties tab, select the output type as Velocity.
6. Select Entity from the drop-down menu below Velocity.
7. Select entity type to be .
8. Leave to be Global Frame.

Step 4: Add a constant velocity motion to the leader translation joint.
In this next step we will add constant velocity to the Leader Body. Follower body connected by a
linear spring will observe a stick-slip motion due to the friction forces.
1. Right click the Motion icon from the Constraint toolbar.
2. For Label, enter Stick Slip.
3. For Variable, enter mot_leader.
4. Click OK to add motion.
5. From the Connectivity tab:
Select On Joint from the drop-down menu for Define motion.
Select Leader Translation Joint for .
Select Velocity from the drop-down for Property.
6. From the Properties tab:
Select Linear from the drop-down menu for Define by.
Enter 100 for Value.

Step 5: Simulate the model.
1. Click on the icon to check the model.
2. Switch to the Run panel by clicking on the Run icon
3. Under the Main tab, click on the icon to specify the name and location of the MotionSolve
.xml file. Save the file with the name Stick_Slip.xml in your working directory.
4. Notice that after saving the file, the Run button to the right becomes active.
5. Specify the End time as 25 sec and leave the other values at their default setttings.
6. Click on the Run button to run the simulation.
Step 6: Viewing animation and plots.

Once the run is complete, the other buttons on the right side of the panel are activated.
1. Click on the Animate button to view the animation.
This invokes HyperView and loads the Stick_Slip.h3d animation file.
2. Next, click on the Plot button to view the plots.
This invokes HyperGraph and loads the Stick_Slip.abf results file.
3. Click on the HyperGraph window to activate it.
4. Plot Follower velocity versus Time.
Select X-axis Data Type as Time.
Y Type Marker Velocity
Y Request Follower_Velocity - (on Follower)
Y Component VX
Note Scale velocity value to m/sec from mm/sec.

5. Plot Friction force versus Time.
Y Type Expression
Y Request Friction_Force
Y Component F4
Animation and Plot windows
6. To start the animation, click the Start/Pause Animation icon on the toolbar.

7. The Stick_Slip motion is clearly observed from the animation and plots.
Velocity and Friction Force on Time Scale
The Leader body moving at a constant velocity elongates the spring increasing spring force
linearly. The friction force counteracts the spring force, and there is a small displacement of
Follower body when the applied force reaches the break-away force.
Break away force = mu static x Normal Load
= 0.15x1x9.81
= 1.47 Newton.
Step 7: Adding time varying velocity to follower translation joint.

In this step you will add Time varying velocity to Follower translation joint. Velocity is varied
between 1.1 mm/sec to 3mm/sec at different frequencies (1 rad/sec, 10 rad/sec & 25rad/sec) to
observe Hysteresis in friction.
1. Right-click the Motions icon on the Constraint toolbar.
2. For Label, enter Hysteresis.

3. For Variable, enter mot_freq_varying.
4. Click OK to add motion.
5. From the Connectivity tab:
Select On Joint from the drop-down menu for Define motion.
Select Follower Translation Joint for .
Select Velocity from the drop-down for Property.

6. From the Properties tab:
Select Expression from the drop-down menu for Define by.
Click on the button.
The Expression Builder is displayed.
Populate the Expression Builder with the following expression: `1.1

+1.9*ABS(sin(PI*(time)))`
This expression varies velocity from 1.1 mm/sec to 3 mm/sec at a frequency of 1 rad/sec.
Velocity variation
Note Multiply `time` with 10, 25 will vary velocity at frequencies 10rad/sec and 25 rad/sec
respectively.

7. Deactivate motion on the Leader Translation Joint created in earlier steps.
Step 8: Simulate model for varying velocities at different frequencies.
1. Click on the icon to check the model.
2. Switch to the Run panel by clicking on the Run icon
3. Under the Main tab, click on the icon to specify the name and location of the MotionSolve
.xml file. Save the file with the name Hysteresis_1radpersec.xml in your working directory.
4. Specify the End time as 3 seconds and the Print Interval as 0.0001 seconds.
5. Click on the Run button to run the model.
6. Modify the velocity expression of the Follower Translation Joint and run the model with the file
names and end times specified in the table below:
Frequency Expression File name End Time

(sec)
10 rad/sec `1.1+1.9*ABS(sin(PI*(10*time)))` Hysteresis_10radpersec.xml 0.3
25 rad/sec `1.1+1.9*ABS(sin(PI*(25*time)))` Hysteresis_25radpersec.xml 0.12

Step 9: Plotting Hysteresis curves.
1. Select HyperGraph by clicking in the window.
2. Load results for the 1 rad/sec frequency.
Click on the Open Data File icon .
Browse to the working directory and select the Hysteresis_1radpersec.abf file.
3. Plot Follower velocity versus Time.
Select the following for the Y-axis data:
Y Type Marker Velocity
Y Request Follower_Velocity- (on Follower)
Y Component VX

4. Plot Friction force versus Time.
Select the following for the Y-axis data:
Y Type Expression
Y Request Friction_Force
Y Component F4
Follower Velocity and Friction Force
5. Plotting Friction Hysteresis curve (Friction Force versus Velocity).
There is an initial transition of friction force values, therefore you will plot hysteresis curve
excluding first cycle data (in other words, 0 to 1 sec.).
Click on the Define Curves icon on the Curves toolbar.
Click on the Add button to add a new curve.

Rename Curve3 as 1rad/sec.
For the X and Y data, select the Source type as Math.
Populate X data to select velocity between time interval 1 to 3 secs using the subrange
function: p1w2c1.y[subrange(p1w2c1.x,1,3)].
Populate Y data to select Friction force between time interval 1 to 3 secs using the subrange
function: p1w2c2.y[subrange(p1w2c1.x,1,3)].

Click the Apply button.
6. Similarly, plot hysteresis curves for frequencies 10rad/sec (Hysteresis_10radpersec.abf) and

25 rad/sec (Hysteresis_10radpersec.abf) following Steps 3 -5 above.
Hysteresis curves at different frequencies
The velocity variation with higher frequency will have widest hysteresis loop.

With the addition of a co-simulation interface between MotionSolve and AcuSolve, you can now solve
multi-physics problems that involve complex rigid body movement, coupled with fluid flow, that
generates pressure forces on the rigid bodies. This capability lets you enhance the fidelity of your
multi-body system, letting you generate more realistic results.
In this scenario, MotionSolve computes the displacements and rotations for the rigid bodies, while
AcuSolve computes the forces and moments on those bodies. Both solvers exchange data with each
other while stepping forward in time via the TCP socket protocol. This means that the two solvers
can be located on different machines and on different platforms and still communicate with one
another. For example, the CFD simulation can run on an HPC, while the MBS simulation can run locally
on a laptop.
Tutorial Objectives
In this tutorial, you will learn how to setup a model in MotionView that will be coupled with AcuSolve.
You will use the MotionSolve-AcuSolve co-simulation interface to couple the rigid body dynamics of a
check valve within a pipe with the flow field. The AcuSolve model has already been setup for you and
is located at <installation directory>\14.0\tutorials\mv_hv_hg\mbd_modeling\motionsolve
\cosimulation\Check_Valve_Coupled.acs. Steps for running this model in AcuSolve are included as
part of this tutorial.
To learn more about how to setup the model in AcuSolve, please refer to <installation_directory>
\14.0\acusolve\<platform>\help\acu\acusolve_tut\Tutorials\Check_Valve_Coupled\.
Software Requirements
To successfully complete this tutorial, the following must be installed:
1. HyperWorks Desktop (MotionView) v14.0.
2. HyperWorks Solvers (MotionSolve) v14.0.
3. AcuSolve v14.0.
The following scenarios are supported for the MotionSolve-AcuSolve co-simulation:
Machine A Machine B
Software Platform Software Platform
MotionSolve/MotionView Windows 64-bit AcuSolve Windows 64-bit
MotionSolve/MotionView Windows 64-bit AcuSolve Linux 64-bit
MotionSolve/MotionView Windows 64-bit - -

and AcuSolve
From the table above, the co-simulation is currently only supported for the Windows 64-bit platform
for MotionView and MotionSolve. You may use either a Windows 64-bit or a Linux 64-bit installation of
AcuSolve.

Simulation Environment
The co-simulation interface between MotionSolve and AcuSolve consists of a middleware utility
executable, acuMSI.exe. This executable is responsible for:
Establishing a connection to both MotionSolve and AcuSolve.

Communicating the displacements and rotations from MotionSolve to AcuSolve.
Communicating the forces and moments from AcuSolve to MotionSolve.
Managing runtime and licensing.
This is shown schematically in Figure 1 below.
Figure 1: C o-Simulation setup
Pipe with a check valve

A check valve is a mechanical device that permits fluid to flow in only one direction. This is controlled
by a shutter body. Fluid flowing in one direction pushes the shutter body in one direction, thereby
opening the valve. Fluid flowing in the opposite direction pushes the shutter body in the other
direction, which causes the valve to shut and prevents flow reversal in the pipe. Check valves are
found in pumps, chemical and power plants, dump lines, irrigation sprinklers, hydraulic jacks, for
example.
The geometry that is modeled in this tutorial is illustrated in Figure 2 below. It consists of:
A pipe with an inlet and outlet for the fluid flow.

A check valve assembly that consists of a shutter plate attached to a stem.
A stop mounted on a perforated plate downstream of the shutter body.

The fluid flow in the pipe is assumed to be axisymmetric. This allows you to model only a part of the
check valve. In this example, a 30 degree section of the geometry is modeled, as shown by the blue
part in Figure 2. The advantage of doing this is a reduced simulation time while still capturing an
accurate solution.
Figure 2: Pipe with check valve model setup
The check valve assembly consists of a disc-like body mounted on a stem. When fluid flows in the
direction specified by the red arrows in Figure 2 above, the fluid forces the shutter body to translate
in the same direction as the fluid. The motion of the shutter body is also affected by a spring damper
attached between the shutter body and the perforated plate. Finally, 3D rigid body contact is
modeled between the shutter body and the stop to arrest the motion of the shutter body in the
direction of the flow.
For the MBS model, only 1/12 of the shutter body and the perforated plate are modeled.
At the start of the simulation, the flow field is stationary. A pressure specified at the inlet drives the
flow, which varies over time as a piecewise linear function. This is illustrated in Figure 3. As this
pressure rises, the flow accelerates which in turn pushes the shutter body open and allows flow
through the pipe.

Figure 3: Inlet pressure
This dynamics of this kind of model can be termed as being tightly coupled between the two solvers.
This means that the motion of the rigid bodies affects the fluid flow field, which in turn affects the
rigid body motion in a cyclical fashion.
The rest of this tutorial assumes that this model has been correctly setup in AcuSolve. Note that the
model is designed to translate the shutter body until it collides with the perforated plate. The
MotionView model has been designed with a contact between these two bodies that causes the
shutter body to rebound appropriately. To allow the rigid bodies to come into contact without the
AcuSolve finite element mesh fully collapsing, the perforated plate in the fluid model has been offset
by 0.002m in the positive X direction. This allows the MotionView model to react as specified by the
contact entity while keeping the AcuSolve mesh from fully collapsing.
Step 1: Load the model in MotionView

1. From the Start menu, select All Programs > Altair HyperWorks 14.0 (64-bit) > MotionView.
2. Open the model Valve_model.mdl from <altair>\14.0\tutorials\mv_hv_hg\mbd_modeling

\motionsolve\cosimulation.
This model is prepared to run in MotionSolve but requires modifications to run in co-simulation with
AcuSolve. These steps are outlined below.
Once the model is loaded into MotionView, the graphical window displays the shutter valve,
perforated plate, joint and spring entities, as well as a graphical representation of the spring
damper as shown in Figure 4.

Figure 4: The MotionSolve model of the pressure check valve
The MotionSolve model consists of the following components:
Ground Body Rigid Body Ground Body
Shutter Body Rigid Body 30 degree section of the shutter body.
Perforated Body Rigid Body 30 degree section of the perforated plate.
Contact 3D Rigid-Rigid 3D rigid-rigid contact force between the

Contact Force Shutter body and the Perforated Body.
Solver Units Data Set The units for this model (Newton, Meter,
Kilogram and Second).
Gravity Data Set Gravity specified for this model. The gravity
is turned on and acts in the negative Y
direction.
Shutter Body Graphic Graphic The graphic that represents the shutter
body. This graphic is used both for the co-
simulation and for the contact force
calculations.

Perforated Plate Graphic Graphic The graphic that represents the perforated
plate body. This graphic is used both for
the co-simulation and for the contact force
calculations.
Spring Graphic The graphic that represents the spring

modeled between the shutter body and the
perforated plate body. This is only for
visualization and does not affect the co-
simulation results.
Fixed Fixed Joint This fixed joint clamps the perforated plate
body to the ground.
Translation Translational Joint This translational joint allows motion of the

shutter body along the X axis.
Spring Spring Damper This is a simple spring damper mounted

between the shutter body and the
perforated plate body.
ContactOutput Output An output signal that measures the

contact force.
Displacement Output An output signal that measures the

displacement between the shutter body
and the ground.
Velocity Output An output signal that measures the

velocity of the shutter body with respect
to the ground.
Step 2: Specify the wet body that will interact with AcuSolve
To couple with AcuSolve, you need to specify one or more "wet" bodies. A "wet" body is a body in
the MotionSolve model which interacts with the fluid flow and thus has forces and moments acting on
it. Such a body can translate or rotate due to the actuating fluid force/moment as computed by
AcuSolve as well as due to any actuating forces/moments in the MotionSolve model. In this example,
we will define a single "wet" body the shutter body that translates along the X axis due to fluid
impinging on it.
To specify a body as "wet" in MotionView, you have to make use of a system definition, which is
described below.
1. Add the system definition to your model by locating the Model system in your Project Browser
and select it.
This changes the panel selection at the bottom.

o From the Import/Export tab, select Import as shown in Figure 5 below.
o Click the file open icon, .
Figure 5: Adding the system definition to the model
2. The system definition that is used for this co-simulation is located at <altair>\14.0\utility
\mbd\fluid_force\sys_fluid_force.mdl. Click Import to import the file.
The Import Definition dialog is displayed. Leave the labels as-is and click OK.
Figure 6: Adding the system definition to the model
A new system called System Wet Body is created in your model.

3. Specify the "wet" body by clicking the newly created System Wet Body and clicking the
Attachments tab as shown in Figure 7.
Figure 7: Defining the rigid body associated with the wet body
4. Click the Body collector and resolve it to Shutter Body.
If you examine the contents of this system under the project browser on the left, you will see the
following new components have been created:
Component Name Component Type Description
Shutter Body - AcuSolveForce Action Only, The force and moment calculated by
TransRotational Force AcuSolve is applied to the wet body
through this force component.
Plant Input Control Plant Input AcuSolve deposits the forces and
torques into this modeling element.
FromAS_FX Solver Variables These variables hold the forces (X, Y

and Z) and the moments (X, Y, Z)
FromAS_FY values from AcuSolve.
FromAS_FZ
FromAS_TX
FromAS_TY
FromAS_TZ
Define wet_body attribute Template This template adds the attribute

is_wet_body to the wet body that is
chosen for this system.
Define co-simulation with Template This template adds the attribute

AcuSolve acusolve_cosim to the model to
instruct MotionSolve to co-simulate
with AcuSolve.
At this point, you have setup the model in MotionView to interact with AcuSolve.

Step 3: Run the model without co-simulating with AcuSolve
To make sure that the MotionView model is setup correctly, run the model in MotionSolve and make
sure there are no warning/error messages from MotionSolve.
1. Deactivate the template Define co-simulation with AcuSolve as shown in Figure 8 below:
Figure 8: Deactivate the co-simulation template
2. To deactivate the template, right-click on it in the browser and select Deactivate.
By doing this, you are deactivating the flag which tells MotionSolve that this model is intended for
co-simulation with AcuSolve. Thus, MotionSolve simulates this model as a stand-alone model
without co-simulating with AcuSolve.
You may run this model using the Run panel in MotionView and ensure that there are no error or
warning messages reported. This is recommended to ensure that the model works properly before
attempting a co-simulation.
If you load the animation H3D generated from running this model, you will see that there is no
motion in any of the parts. This is because all of the actuation for this model comes from
AcuSolve, which was disabled for this simulation.
3. After you have verified the model, re-activate the template Define co-simulation with AcuSolve
to perform a co-simulation, shown in Figure 9 below:
Figure 9: Activate the co-simulation template

4. To activate the template, right-click on it in the browser and select Activate.
Step 4: Export the model to XML
1. To export the model to your working directory, click the Export to Solver button, , and export
the solver deck to your working directory.
You may change the default name of the model.
Figure 10: Exporting the model to XML
Step 5: Verify the model between MotionSolve and AcuSolve

To successfully run the co-simulation, the model created in MotionView and the model created in
AcuSolve must be consistent. The following criteria need to be met in order for the two models to be
consistent.
1. The name of the wet body/bodies need to match between MotionSolve and AcuSolve. The
names of the wet body/bodies are specified in the *.inp file on the AcuSolve side.
Note The names are case-sensitive and must match exactly (see the text in red below).
MotionSolve (.xml):

<Body_Rigid
full_label = "Model-Shutter Body"
AcuSolve (.inp):
EXTERNAL_CODE_SURFACE( "Valve wall" ) {
rigid_body_name = "Model-Shutter Body"
2. The print_interval for the MotionSolve model needs to match the step size for the AcuSolve
model. For this tutorial it is set to 0.002s.

3. You must set the MotionSolve step size, h_max, to match the print_interval (0.002s in this
case).
4. Also, verify that the end times for both models are set to the same values. For this tutorial, the
end times for both the AcuSolve and MotionSolve models are set to 0.35s.
See the Run Panel in MotionView to set the print_interval, step size (h_max), and end times.
Note that the units in the MotionSolve and AcuSolve models do not need to match to run the co-
simulation; however, the units must match to overlay the results animations in HyperView. The
units in MotionView are set via the Units form shown below:
Figure 11: Setting the units in MotionView
All values in the MotionSolve model are set with respect to these units settings.
Step 6: Run the MotionSolve and middleware executables for co-simulation

from the MotionSolve Run Manager
1. From the Start menu, select All Programs > Altair HyperWorks (14.0) 64-bit > MotionSolve
to open the HyperWorks Solver Run Manager. Locate the model you just exported by clicking
on the file open icon, .
Figure 12: Select the exported model from disk

2. Click the ellipsis button next to Options field to open the Available Options dialog.
Figure 13: Selecting the co-simulation flag
3. Activate the as_cosim option. When this flag is enabled, it tells the Run Manager to do the
following:
Invoke the MotionSolve executable and run the model that is specified.
Invoke the middleware acuMSI, which enables communication between MotionSolve and
AcuSolve.
When you activate this option, the following dialog is displayed and you are prompted for
additional options:
Figure 14: Specifying options for the co-simulation
You may specify the following options here:
acuMSI options
-aport <integer> Specifies the communication port number for communication between
AcuSolve and acuMSI. The default is 48000.
Note If you need to change the default port for communication between
AcuSolve and acuMSI, in addition to changing this argument, you
also have to specify the changed port number in the AcuSolve input
file.

-mport <integer> Specifies the communication port number for communication between
MotionSolve and acuMSI. The default is 94043.
Note If you need to change the default port for communication between
MotionSolve and acuMSI, in addition to changing this argument, you
also have to specify the changed port number in an environment
variable MS_AS_PORT. MotionSolve checks for this environment
variable at the start of the simulation and changes its listening port
accordingly.
-mi <integer> Specifies the maximum number of iterations per time step between the two
solvers. The default is 0.
-v <integer> Specifies the verbosity level of the output file from acuMSI. The default is
set to 0 (verbosity OFF).
4. If you retain the default options, click None.
5. Click Apply Options and click Close.
Figure 15: Specifying the co-simulation flag
6. You are now setup to start the co-simulation on the MotionSolve side. Click Run.
Figure 16: Run the MotionSolve model

This launches MotionSolve as well as the acuMSI executable. The MotionSolve run is paused at
the first time step it is now in waiting mode and the co-simulation will start as soon as AcuSolve
is run.
Figure 17: The MotionSolve simulation is waiting for a connection to AcuSolve
Step 7: Run the AcuSolve executable for co-simulation

1. To run the co-simulation model in AcuSolve, first copy the model file Check_Valve_Coupled.acs
from <installation_directory>\14.0\tutorials\mv_hv_hg\mbd_modeling\motionsolve
\cosimulation to your working directory.
2. From the Start menu, select All Programs > Altair HyperWorks 14.0 (64-bit) > AcuSolve >
AcuSolve Job Launcher. In the window that is displayed, change the field Problem name as
specified by the AcuSolve .inp file. Make sure your Problem directory is set to your current
working directory.

Figure 18: Launching AcuSolve for the co-simulation
For this model, the default values are used. AcuSolve runs using a single processor, and
AcuConsole generates the input files and launches AcuSolve.
3. Press Launch to launch the solution process.
As the solution starts, an AcuTail window opens. After executing acuPrep, AcuSolve stops at the
acuRun path step. Its waiting for the execution of the MotionSolve process.
Soon, AcuSolve and MotionSolve should begin to communicate with one another. You should be
able to see relevant time stepping information in both solver windows. For example, you should
see something like the following in the MotionSolve window at the beginning of the co-simulation:
INFO: [AS-COSIM] Connected to AcuMsi on port 94043
INFO: [AS-COSIM] License checked out.
Time=2.000E-06; Order=1; H=2.000E-06 [Max Phi=1.314E-16]
Time=3.600E-02; Order=2; H=2.000E-03 [Max Phi=1.653E-08]
The co-simulation should take roughly 15 minutes to complete on a laptop (Intel i7. 2.8GHz).
Note that there is no order dependency on launching the co-simulation either MotionSolve or
AcuSolve can be launched first.

Step 8: Post process the results from the co-simulation
HyperView and HyperGraph can be used to post process the co-simulation results within the
HyperWorks Desktop environment.
1. To launch HyperView (HyperGraph), from the Start menu, select All Programs > Altair
HyperWorks 14.0 (64-bit) > HyperView (HyperGraph).
Animating the Co-simulation Results in HyperView
The animation H3D generated by the MotionSolve part of the co-simulation contains only the results
from MotionSolve. Similarly, the result files from AcuSolve only contain the results for the AcuSolve
model. To animate the results from the co-simulation, follow these steps:
1. Load the animation H3D generated by MotionSolve in HyperView.
o Go to the Load Model panel.
o Click the file open button, , next to Load model and navigate to the results directory
(the same directory where the .xml file is located).
o Select the .h3d file and click Open.
o Click Apply.
Figure 19: Loading MotionSolve H3D in HyperView
HyperView loads the MotionSolve results file into the graphical window at the first time step.
From this point, you can animate the transient results using Start/Stop on the Animation
Slider.
2. To load the AcuSolve results, they must first be converted to the .h3d format. This can be
accomplished by using the AcuSolve utility, acuTrans. AcuTrans is available from the Start
menu. Select All Programs > Altair HyperWorks 14.0 (64-bit) > AcuSolve > AcuSolve Cmd
Prompt.
3. Navigate to the results directory and execute the following command to convert the AcuSolve
database into the .h3d format:
acuTrans -out -to h3d -h3dopt single -ts A

This creates a single .h3d file containing all of the time steps available for the simulation.
4. Using acuTrans, overlay the newly-created H3D over the MotionSolve result H3D in HyperView.

This is accomplished by repeating Step 1 described above and activating Overlay when selecting
the AcuSolve result H3D.
Figure 20: Overlaying AcuSolve H3D over the MotionSolve H3D in HyperView
Once loaded, the graphical window contains both results and can be animated as before. To
visualize the information contained within the AcuSolve results, a Contour plot may be used. Click
on the Contour button, , to display the panel.
5. Set the options as shown in Figure 19 below and click Apply.
Figure 21: Overlaying AcuSolve H3D over the MotionSolve H3D in HyperView
This creates a contour plot of the velocity magnitude overlaid with the results from MotionSolve in
one window.
Figure 22: Velocity magnitude plot overlaid with the MotionSolve results in HyperView

Plotting the MotionSolve Results in HyperGraph
You can also interpret the results with a two dimensional plot using HyperGraph. HyperWorks Desktop
can be used in a multi-window layout, allowing both HyperView and HyperGraph to be open at the
same time.
1. First, open HyperView following the steps described in the previous section.
2. From the toolbar, click the Page Window Layout button, , and split the page into two
vertical pages.
Figure 23: Splitting the page into two vertical pages
This automatically adjusts the graphical window to accommodate two pages, defaulting to two
instances of HyperView.
3. Click anywhere in the page on the right and switch to HyperGraph by clicking the Page Selector
button, , and selecting HyperGraph 2D from the drop-down list.
Figure 24: C hange the page on the right to HyperGraph 2D
4. Click the Build Plots button, , to load the .plt file from the same results directory.

Figure 25: Load the plot results in HyperGraph
Once the .plt file is loaded into HyperGraph, the two outputs are available for plotting.
5. Perform the following selections:
o Under Y Type, select Displacement
o Under Y Request, select Displacement (on Shutter Body)
o Under Y Component, select X
o Click Apply.
HyperGraph can be used to create additional traces on the same plot to generate the following
plots.
Figure 26: Select the signals for plotting
Figure 27: The MotionSolve animation side-by-side with the MotionSolve plot results

MV-7002: Co-simulation with Simulink SMP
Approach
Tutorial Objectives
In this tutorial, you will learn how to use the MotionSolve-Simulink co-simulation interface, driving the
model from Simulink via an S-Function. MotionSolve provides two ways to drive co-simulation from
within Simulink using the Shared Memory (SMP) or Inter Process Communication (IPC) approach.
SMP co-simulation uses shared memory while exchanging data between the two solvers. This
approach requires that both MotionSolve and MATLAB be installed on the same machine. Additionally,
the two software must be both 64-bit. The rest of this tutorial describes the co-simulation using the
SMP approach.
For IPC co-simulation, the two solvers are run on two separate processes with data being exchanged
through sockets. Since the two solvers run on different processes, this method allows you to run a
co-simulation between MotionSolve and MATLAB installed on separate machines. Additionally, the two
software need not be 64-bit. As an example, a 32-bit MATLAB can be used to co-simulate with a 64-
bit installation of MotionSolve on a different machine.
Software and Hardware Requirements

Software requirements:
MotionSolve
MATLAB/Simulink (MATLAB Version 7.6(R2008a), Simulink Version 7.1(R2008a)) (or newer)
Hardware requirements:
PC with 64bit CPU, running Windows XP Professional or higher

Linux RHEL5 64
Inverted pendulum controller

Consider an inverted pendulum, mounted on a cart. The pendulum is constrained at its base to the
cart by a revolute joint. The cart is free to translate along the X direction only. The pendulum is given
an initial rotational velocity causing it to rotate about the base.
Both the pendulum and the cart are modeled as rigid bodies. The controller, modeled in Simulink,
provides a control force to the cart to stabilize the inverted pendulum and prevent it from falling. This
control force is applied to the cart via a translational force. The model setup is illustrated in Figure 1
below.

Figure 1: Inverted pendulum model setup
The pre-designed controller generates a control force that keeps the pendulum upright. The controller
uses the pendulums orientation and angular velocity along with the carts displacement and velocity
as inputs to calculate the direction and magnitude of the force needed to keep the pendulum upright.
A block diagram of the control system is shown in Figure 2.
Figure 2: Block diagram representation of the controller
In the image above:
is the angular displacement of the pendulum from its model configuration
is the angular velocity of the pendulum about its center of gravity as measured in the
ground frame of reference
x is the translational displacement of the cart measured from its model configuration in the
x& is the translational velocity of the cart measured in the ground frame of reference
R
is a reference signal for the pendulums angular displacement

R is a reference signal for the pendulums angular velocity
Rx is a reference signal for the carts translational displacement
Rx&
is a reference signal for the carts translational velocity
A disturbance is added to the computed control force to assess the system response. The controller
force acts on the cart body to control the displacement and velocity profiles of the cart mass.
In this exercise, you will do the following:
Solve the baseline model in MotionSolve only (i.e., without co-simulation) by using the inverted
pendulum model with a continuous controller modeled by a Force_Vector_OneBody element.
You can use these results to compare to an equivalent co-simulation in the next steps.
Review a modified MotionSolve inverted pendulum model that mainly adds the
Control_PlantInput and Control_PlantOutput entities that allow this model to act as a plant for
Simulink co-simulation.
Review the controller in Simulink.
Perform a co-simulation and compare the results between the standalone MotionSolve model
and the co-simulation model.
Before you begin, copy all the files in the <installation_directory>\tutorials\mv_hv_hg
\mbd_modeling\motionsolve\cosimulation folder to your working directory (referenced as
<Working Directory> in the tutorial). Here, <altair> is the full path to the HyperWorks installation.
Step 1: Run the baseline MotionSolve model.

In this step, use a single body vector force (Force_Vector_OneBody) to model the control force in
MotionSolve. The force on the cart is calculated as:
Fcart Fcontrol Fdist

, where
Fdist
is the disturbance force,
Fcontrol K1 error K 2
error K 3 errorx K 4 errorx&
is the control force,
Ki
are gains applied to each of the error signals
error is the error (difference between reference and actual values) on the input signals.
The angular displacement and velocity of the pendulum are obtained by using the AY() and WY()
expressions respectively. The translational displacement and velocity of the cart are obtained similarly,
by using the DX() and VX() expressions.

1. From the Start menu, select All Programs > Altair HyperWorks 14.0 > MotionView. Open the
model InvertedPendulum_NoCosimulation.mdl from your <Working Directory>.
Figure 3: The MotionSolve model of the inverted pendulum
Component name Component Type Description
Slider cart Rigid body Cart body
Pendulum Rigid body Pendulum body
Slider Trans Joint Translational Joint Translational joint between the cart body
and the ground
Pendulum Rev Joint Revolute Joint Revolute joint between the pendulum body
and the cart body
Control Force Vector Force The control force applied to the cart body
Output control force Output request Use this request to plot the control force
Output slider displacement Output request Use this request to plot the carts
displacement
Output slider velocity Output request Use this request to plot the carts velocity
Output pendulum Output request Use this request to plot the pendulums
displacement displacement
Output pendulum velocity Output request Use this request to plot the pendulums
velocity

Pendulum Rotation Angle Solver Variable This variable stores the rotational
displacement of the pendulum via the
expression AY()
Pendulum Angular Velocity Solver Variable This variable stores the rotational velocity
of the pendulum via the expression VY()
Slider Displacement Solver Variable This variable stores the translational

displacement of the cart via the expression
DX()
Slider Velocity Solver Variable This variable stores the translational

velocity of the cart via the expression VX()
2. In the Run Panel, specify the name InvertedPendulum_NoCosimulation.xml for the

MotionSolve model name and click Run.
The results that we get from Step 2 will be used as the baseline to compare the results that we
get from co-simulation.
Step 2: Use modified MotionSolve Model to define the plant in the control
scheme.
A MotionSolve model needs a mechanism to specify the input and output connections to the Simulink
model. The MotionSolve model (XML) used above is modified to include the Control_PlantInput and
Control_PlantOutput model elements and provide these connections. In this tutorial, this has already
been done for you, and you can see this by opening the model
InvertedPendulum_Cosimulation.mdl from your <Working_Directory>.
This model contains two additional modeling components:
Component name Component Type Description
Plant Input Simulink Plant input This Control_PlantInput element is used to define
the inputs to the MotionSolve model
Plant Output Simulink Plant output This Control_PlantOutput element is used to define
the outputs from the MotionSolve model
The Control_PlantInput element defines the inputs to a mechanical system or plant. For this
model, only one input is defined in the Plant Input Simulink solver array. This is set to the ID
of the solver variable that holds the control force from Simulink.
Figure 4: The definition of the input channel to MotionSolve

The Control_PlantOutput element defines the outputs from a mechanical system or plant. For
this model, four outputs are defined in the Plant Output Simulink solver array. These are the
pendulum rotation angle, the pendulum angular velocity, slider displacement and slider
velocity.
Figure 5: The definition of the output channels from MotionSolve
The inputs specified using the Control_PlantInput and Control_PlantOutput elements can be
accessed using the PINVAL() and POUVAL() functions, respectively. Since the Control_PlantInput
and Control_PlantOutput list the ids of solver variables, these input and output variables may also
be accessed using the VARVAL() function. For more details, please refer to the MotionSolve User's
Guide on-line help.
In this model, we have the following connections:
Plant Input: A single control force that will be applied to the cart.
Plant Output: The pendulums angular displacement and angular velocity; the carts
translational displacement and velocity.
Step 3: Setting up environment variables to run MotionSolve from MATLAB

\Simulink.
A few environment variables are needed for successfully running a co-simulation using MATLAB. These
can be set using one of the following methods:
Control Panel (Windows)
In the shell/command window that calls MATLAB (with the set command on Windows, or the
setenv command on Linux)
Within MATLAB, via the setenv() command
An example of the usage of these commands is listed below:
Environment Value Windows shell Linux shell MATLAB shell

variable
PATH \mypath set PATH=\mypath setenv PATH setenv(PATH,\mypat

\mypath h)

Set the following environment variables
Environment Path
variable
Windows Linux
NUSOL_DLL_DI <altair>\hwsolvers <altair>\hwsolvers\motionsolve\bin\linux64
R \motionsolve\bin\win64
RADFLEX_PATH <altair>\hwsolvers <altair>\hwsolvers\common\bin\linux64

\common\bin\win64
PATH <altair>\hwsolvers <altair>\hwsolvers\common\bin\linux64;$PATH

\common\bin\win64;%PATH%
LD_LIBRARY_PA- <altair>\hwsolvers\motionsolve\bin\linux64: <altair>

TH \hwsolvers\common\bin\linux64:$LD_LIBRARY_PATH
where <altair> is the full path to the HyperWorks installation. For example, on Windows, this would
typically be C:\Program Files\Altair\14.0.
Note that other optional environment variables may be set for your model. See MotionSolve
Environment Variables for more information on these environment variables.
Step 4: Perform the co-simulation.

The core feature in Simulink that creates the co-simulation is an S-Function (System Function) block
in Simulink. This block requires an S-Function library (a dynamically loaded library) to define its
behavior. MotionSolve provides this library, but the S-Function needs to be able to find it. To help
MATLAB/Simulink find the S-Function, you need to add the location of the S-Function to the list of
paths that MATLAB/Simulink uses in order to search for libraries.
The S-Function libraries for co-simulation with MotionSolve are called either:
mscosim for Shared Memory (SMP) communication
mscosimipc for Inter Process Communication (IPC) using TCP/IP sockets for communication.
Please see the tutorial MV-7003 for details on how to use IPC for co-simulation. The rest of this
tutorial is described for the Shared Memory (SMP) communication process.
Changing the name of this library in the S-Function block in Simulink changes the communication
behavior of the co-simulation.
These files are installed under <altair>\hwsolvers\motionsolve\bin\<platform>.
The location of these files needs to be added to the search path of MATLAB for the S-Function to use
mscosim.

This can be done in one of the following ways:
1. Use the menu options.
a. From the Matlab menu, select File > Set Path This is shown in Figure 6 below.
Figure 6: Add path through the MATLAB GUI
b. From the dialog box, add the directory where the mscosim libraries reside.
(for example, <altair>\hwsolvers\motionsolve\bin\win64).
c. Select Save and Close. This procedure permanently adds this directory to the MATLAB/
Simulink search path.
2. Use MATLAB commands.
At the MATLAB command line, type:

addpath(<altair>\hwsolvers\motionsolve\bin\<platform>)
to add the directory where mscosim library resides into the MATLAB search path. It remains valid
until you exit MATLAB. You can also create a .m script to make this process more easily
repeatable.
For example, you can set the MATLAB Path and the necessary environment variables using
MATLAB commands in a MATLAB (.m) script:
addpath('<altair>\hwsolvers\motionsolve\bin\win64')
setenv('NUSOL_DLL_DIR','<altair>\hwsolvers\motionsolve\bin\win64')

setenv('RADFLEX_PATH',['<altair>\hwsolvers\common\bin\win64')
setenv('PATH',['<altair >\hwsolvers\common\bin\win64;' getenv('PATH')])
For a Linux machine, additionally:
setenv(LD_LIBRARY_PATH, '<altair>\hwsolvers\motionsolve\bin\linux64:<altair>
\hwsolvers\common\bin\linux64\')
Step 5: View the controller modeled in Simulink

1. In the MATLAB window, select File > Open.
The Open file dialog is displayed.
2. Select the InvertedPendulum_ControlSystem.mdl file from your <Working Directory>.
3. Click Open.
You will see the control system that will be used in the co-simulation.
Figure 7: The control system in MATLAB
4. The model contains an S-function block. Name the S-function mscosim.
The S-function (system-function) is one of the blocks provided by Simulink and represents the
MotionSolve model. It can be found in the Simulink User-Defined Functions block library. An S-
Function allows you to model any general system of equations with inputs, outputs, states, and
so on, and is somewhat analogous to a Control_StateEqn in MotionSolve. See the MATLAB/
Simulink documentation for more details.

5. Double-click the S-function with name mscosim. In the dialog box that is displayed, under the S
Function Parameters, enter the following using single quotes:
' InvertedPendulum_Cosimulation.xml', ' InvertedPendulum_Cosimulation.mrf', ''
The three parameters are the following:
1. MotionSolve XML model name
2. Output MRF name
3. MotionSolve user DLL name (optional); enter empty single quotes ('') if not used.

1. Click Simulation > Start to start the co-simulation. Simulink uses ODE45 to solve the Simulink
model. From this, the co-simulation should begin and MotionSolve should create an output .mrf
file for post-processing. Set the Scopes in the Simulink model to display the results. Also, check
the .log file to make sure no errors or warnings were issued by MotionSolve.
Figure 8: Running the co-simulation from Simulink
Step 7: Compare the MotionSolve-only results to the co-simulation results.

1. From the Start menu, select All Programs > Altair HyperWorks 14.0 > HyperGraph.
2. Click the Build Plots icon, .
3. Click the file browser icon, , and load the InvertedPendulum_NoCosimulation.mrf file. This
was the baseline results created by running MotionSolve by itself.

4. In the Page Controls toolbar, create two vertical plot windows.
Figure 9: C reate two plot windows
5. Select Marker Displacement for Y-Type, then REQ/70000004 Output slider displacement (on
Slider cart) for Y Request, and DX for Y Component to plot the carts translational displacement:
Figure 9: Plot the carts displacement
6. Select the window on the left and click Apply.
7. Select Marker Force for Y-Type, then REQ/70000002 Output control force- (on Slider cart)
for Y Request, and FX for Y Component to plot the X component of the control force:
Figure 10: Plot the control force on the cart
8. Click the file browser icon, , and load the InvertedPendulum_Cosimulation.mrf file. This
was the co-simulation results run with Simulink.
9. Select Marker Displacement for Y-Type, then REQ/70000004 Output slider displacement
(on Slider cart) for Y Request, and DX for Y Component to overlay the plot in the left window.

for Y Request, and FX for Y Component to overlay the plot in the right window.
You will notice that both the signals match as shown below.
Figure 11: C omparison of the cart displacement and cart control force between the two models
The blue curves represent results from the MotionSolve-only model and the red curves represent
results from the co-simulation.

MV-7009: Co-simulation with Simulink IPC
Approach
Tutorial Objectives
In this tutorial, you will learn how to use the MotionSolve-Simulink co-simulation interface, driving the
model from Simulink via an S-Function. MotionSolve provides two ways to drive co-simulation from
within Simulink using the Shared Memory (SMP) or Inter Process Communication (IPC) approach.
SMP co-simulation uses shared memory while exchanging data between the two solvers. This
approach requires that both MotionSolve and MATLAB be installed on the same machine. Additionally,
the two software must be both 64-bit. Please see MV-7002 for additional information.
For IPC co-simulation, the two solvers are run on two separate processes with data being exchanged
through sockets. Since the two solvers run on different processes, this method allows you to run a
co-simulation between different build types (32-bit/64-bit) for MotionSolve and MATLAB. As an
example, a 32-bit MATLAB can be used to co-simulate with a 64-bit installation of MotionSolve on the
same or different machine. The rest of this tutorial describes the co-simulation using the IPC
approach.
Software and Hardware Requirements

Software requirements:
MotionSolve
MATLAB/Simulink (MATLAB Version 7.6(R2008a), Simulink Version 7.1(R2008a)) (or newer)
Hardware requirements:
PC with 64bit CPU, running Windows XP Professional or higher

Linux RHL5 64
Simulation Environment
In this tutorial, it is assumed that MATLAB is installed on Machine A and MotionSolve is installed on
Machine B. The following scenarios are feasible:
Machine A Machine B IPC Co-simulation possible?
MATLAB/Simulink, 32-bit MotionSolve, 64-bit Yes
MATLAB/Simulink, 32-bit MotionSolve, 32-bit Yes*
Note When you start the co-simulation from Simulink, a few MotionSolve binaries are loaded by
Simulink at runtime. For this purpose, MotionSolve is needed to be installed on the machine
where Simulink resides. Also, this installation of MotionSolve must be of the same build type as
Simulink. For example, to do an IPC co-simulation between Simulink 32-bit and MotionSolve 64-
bit, you would need to install a 32-bit MotionSolve on the same machine where the Simulink
32-bit software is installed. The table above is updated below to reflect this:

Machine A Machine B IPC Co-simulation possible?

(Requires a 32-bit MotionSolve
installation)

installation)

installation)

installation)
* Altair HyperWorks no longer supports 32-bit version of MotionSolve starting version 13.0 and beyond. To
use the 32-bit version of MotionSolve, you will need to install the 12.0.x version of HyperWorks.
This tutorial describes the process to perform a co-simulation between a 64-bit installation of Simulink
on Machine A and a 64-bit installation of MotionSolve on Machine B i.e., the scenario that is in
blue text in the table above. This is illustrated better in Figure 1 below.
Figure 1: C o-Simulation environment used for this tutorial
Inverted pendulum controller
Consider an inverted pendulum, mounted on a cart. The pendulum is constrained at its base to the
cart by a revolute joint. The cart is free to translate along the X direction only. The pendulum is given
an initial rotational velocity causing it to rotate about the base.

Both the pendulum and the cart are modeled as rigid bodies. The controller, modeled in Simulink,
provides a control force to the cart to stabilize the inverted pendulum and prevent it from falling. This
control force is applied to the cart via a translational force. The model setup is illustrated in Figure 2
below.
Figure 2: Inverted pendulum model setup
The pre-designed controller generates a control force that keeps the pendulum upright. The controller
uses the pendulums orientation and angular velocity along with the carts displacement and velocity
as inputs to calculate the direction and magnitude of the force needed to keep the pendulum upright.
A block diagram of the control system is shown in Figure 3.
Figure 3: Block diagram representation of the controller
In the image above:
is the angular displacement of the pendulum from its model configuration
is the angular velocity of the pendulum about its center of gravity as measured in the
x is the translational displacement of the cart measured from its model configuration in the

x& is the translational velocity of the cart measured in the ground frame of reference
R
is a reference signal for the pendulums angular displacement
R is a reference signal for the pendulums angular velocity
Rx is a reference signal for the carts translational displacement
Rx&
is a reference signal for the carts translational velocity
A disturbance is added to the computed control force to assess the system response. The controller
force acts on the cart body to control the displacement and velocity profiles of the cart mass.
In this exercise, you will do the following:
Solve the baseline model in MotionSolve only (i.e., without co-simulation) by using the inverted
pendulum model with a continuous controller modeled by a Force_Vector_OneBody element.
You can use these results to compare to an equivalent co-simulation in the next steps.
Review a modified MotionSolve inverted pendulum model that mainly adds the
Control_PlantInput and Control_PlantOutput entities that allow this model to act as a plant for
Simulink co-simulation.
Review the controller in Simulink.
Perform a co-simulation and compare the results between the standalone MotionSolve model
and the co-simulation model.
Before you begin, copy all the files in the <altair>\tutorials\mv_hv_hg\mbd_modeling
\motionsolve\cosimulation folder to your working directory (referenced as <Working Directory>
in the tutorial). Here, <altair> is the full path to the HyperWorks installation.
Step 1: Run the baseline MotionSolve model.

In this step, use a single body vector force (Force_Vector_OneBody) to model the control force in
MotionSolve. The force on the cart is calculated as:
Fcart Fcontrol Fdist

, where
Fdist
is the disturbance force,
Fcontrol K1 error K 2
error K 3 errorx K 4 errorx&
is the control force,
Ki
are gains applied to each of the error signals
error is the error (difference between reference and actual values) on the input signals.
The angular displacement and velocity of the pendulum are obtained by using the AY() and WY()
expressions respectively. The translational displacement and velocity of the cart are obtained similarly,
by using the DX() and VX() expressions.
1. From the Start menu, select All Programs > Altair HyperWorks 14.0 > MotionView. Open the
model InvertedPendulum_NoCosimulation.mdl from your <Working Directory>.

Figure 4: The MotionSolve model of the inverted pendulum
Slider cart Rigid body Cart body
Pendulum Rigid body Pendulum body
Slider Trans Joint Translational Joint Translational joint between the cart body
and the ground
Pendulum Rev Joint Revolute Joint Revolute joint between the pendulum
body and the cart body
Control Force Vector Force The control force applied to the cart
body
Output control force Output request Use this request to plot the control force
Output slider displacement Output request Use this request to plot the carts
displacement
Output slider velocity Output request Use this request to plot the carts
velocity
Output pendulum Output request Use this request to plot the pendulums
displacement displacement
Output pendulum velocity Output request Use this request to plot the pendulums
velocity

Pendulum Rotation Angle Solver Variable This variable stores the rotational
displacement of the pendulum via the
expression AY()
Pendulum Angular Velocity Solver Variable This variable stores the rotational
velocity of the pendulum via the
expression VY()
Slider Displacement Solver Variable This variable stores the translational

displacement of the cart via the
expression DX()
Slider Velocity Solver Variable This variable stores the translational

velocity of the cart via the expression
VX()
2. In the Run Panel, specify the name InvertedPendulum_NoCosimulation.xml for the

MotionSolve model name and click Run.
The results that we get from Step 2 will be used as the baseline to compare the results that we
get from co-simulation.
Step 2: Use modified MotionSolve Model to define the plant in the control
scheme.
A MotionSolve model needs a mechanism to specify the input and output connections to the Simulink
model. The MotionSolve model (XML) used above is modified to include the Control_PlantInput and
Control_PlantOutput model elements and provide these connections. In this tutorial, this has already
been done for you, and you can see this by opening the model
InvertedPendulum_Cosimulation.mdl from your <Working_Directory>.
This model contains two additional modeling components:
Plant Input Simulink Plant input This Control_PlantInput element is used

to define the inputs to the MotionSolve
model
Plant Output Simulink Plant output This Control_PlantOutput element is

used to define the outputs from the
MotionSolve model
The Control_PlantInput element defines the inputs to a mechanical system or plant. For this
model, only one input is defined in the Plant Input Simulink solver array. This is set to the ID
of the solver variable that holds the control force from Simulink.

Figure 5: The definition of the input channel to MotionSolve
The Control_PlantOutput element defines the outputs from a mechanical system or plant. For
this model, four outputs are defined in the Plant Output Simulink solver array. These are the
pendulum rotation angle, the pendulum angular velocity, slider displacement and slider
velocity.
The inputs specified using the Control_PlantInput and Control_PlantOutput elements can be
accessed using the PINVAL() and POUVAL() functions, respectively. Since the Control_PlantInput
and Control_PlantOutput list the ids of solver variables, these inputs and output variables may
also be accessed using the VARVAL() function. For more details, please refer to the MotionSolve
Users Guide on-line help.
In this model, we have the following connections:
Plant Input: A single control force that will be applied to the cart.
Plant Output: The pendulums angular displacement and angular velocity; the carts translational
displacement and velocity.
Step 3: Setting up environment variables to run MotionSolve from MATLAB

\Simulink.
A few environment variables are needed for successfully running a co-simulation using MATLAB. These
can be set using one of the following methods:
Control Panel (Windows)

In the shell/command window that calls MATLAB (with the set command on Windows, or the
setenv command on Linux)
Within MATLAB, via the setenv() command

An example of the usage of these commands is listed below
Environment Value Windows Linux shell MATLAB shell

variable shell
PATH \mypath set PATH= setenv PATH setenv(PATH,\mypa

\mypath \mypath th)
Set the following environment variables
Environment variable Path
Windows Linux
NUSOL_DLL_DIR <altair> <altair>\hwsolvers\motionsolve\bin\linux64

\hwsolvers
\motionsolve\bin
\win64
RADFLEX_PATH <altair> <altair>\hwsolvers\common\bin\linux64

\hwsolvers\common
\bin\win64
PATH <altair> <altair>\hwsolvers\common\bin\linux64;$PATH

\hwsolvers\common
\bin\win64;%PATH%
LD_LIBRARY_PATH - <altair>\hwsolvers\motionsolve\bin\linux64:
<altair>\hwsolvers\common\bin
\linux64:$LD_LIBRARY_PATH
MS_SERVER_IP_ADDRESS IP address of IP address of Machine B

Machine B
where <altair> is the full path to the HyperWorks installation on Machine A i.e. on the machine
where Simulink in installed. For example, on Windows, this would typically be C:\Program Files\Altair
\14.0.
The MS_SERVER_IP_ADDRESS environment variable needs to be set to the IP address of Machine B

i.e. the machine where only MotionSolve is installed. The IP address should be the full address that
can be obtained by using the ipconfig \all command on Windows or ip addr show command
in Linux.
Note that other optional environment variables may be set for your model. See MotionSolve
Environment Variables for more information on these environment variables.

The core feature in Simulink that creates the co-simulation is an S-Function (System Function) block
in Simulink. This block requires an S-Function library (a dynamically loaded library) to define its
behavior. MotionSolve provides this library, but the S-Function needs to be able to find it. To help
MATLAB/Simulink find the S-Function, you need to add the location of the S-Function to the list of
paths that MATLAB/Simulink uses in order to search for libraries.

The S-Function libraries for co-simulation with MotionSolve are called either:
mscosim for Shared Memory (SMP) communication. Please see the tutorial MV-7002 for details
on how to use SMP communication for co-simulation.
mscosimipc for Inter Process Communication (IPC) using TCP/IP sockets for communication.
Changing the name of this library in the S-Function block in Simulink changes the communication
behavior of the co-simulation.
These files are installed under <altair>\hwsolvers\motionsolve\bin\<platform>.
The location of these files needs to be added to the search path of MATLAB for the S-Function to use
mscosimipc.
This can be done in one of the following ways:
1. Use the menu options.
a. From the Matlab menu, select File > Set Path This is shown in Figure 7 below.
Figure 7: Add path through the MATLAB GUI
b. From the dialog box, add the directory where the mscosimipc libraries reside.
(for example, <altair>\hwsolvers\motionsolve\bin\win64).
c. Select Save and Close. This procedure permanently adds this directory to the MATLAB/
Simulink search path.

2. Use MATLAB commands.
At the MATLAB command line, type:

addpath(<altair>\hwsolvers\motionsolve\bin\<platform>)
to add the directory where mscosimipc library resides into the MATLAB search path. It remains
valid until you exit MATLAB. You can also create a .m script to make this process more easily
repeatable.
For example, you can set the MATLAB Path and the necessary environment variables using
MATLAB commands in a MATLAB (.m) script:
addpath('<altair>\hwsolvers\motionsolve\bin\win64')
setenv('NUSOL_DLL_DIR','<altair>\hwsolvers\motionsolve\bin\win64')
setenv('RADFLEX_PATH',['<altair>\hwsolvers\common\bin\win64')
setenv('PATH',['<altair >\hwsolvers\common\bin\win64;' getenv('PATH')])
setenv(MS_SERVER_IP_ADDRRESS,192.168.1.123)
For a Linux machine, additionally:

setenv(LD_LIBRARY_PATH, '<altair>\hwsolvers\motionsolve\bin\linux64:<altair>
\hwsolvers\common\bin\linux64\')

Step 5: View the controller modeled in Simulink
1. On Machine A, start up MATLAB. In the MATLAB window, select File > Open.
The Open file dialog is displayed.
2. Select the InvertedPendulum_ControlSystem.mdl file from your <Working Directory>.
3. Click Open.
You will see the control system that will be used in the co-simulation.
Figure 8: The control system in MATLAB
4. The model contains an S-function block. Double click on the S-Function named mscosim. In the
dialog box that is displayed, change the name of the S-function to mscosimipc.
The S-function (system-function) is one of the blocks provided by Simulink and represents the
MotionSolve model. It can be found in the Simulink User-Defined Functions block library. An S-
Function allows you to model any general system of equations with inputs, outputs, states, and
so on, and is somewhat analogous to a Control_StateEqn in MotionSolve. See the MATLAB/
Simulink documentation for more details.
5. Double-click the S-function with name mscosimipc. In the dialog box that is displayed, under
the S Function Parameters, enter the following using single quotes:
' InvertedPendulum_Cosimulation.xml', ' InvertedPendulum_Cosimulation.mrf', ''
The three parameters are the following:
1. MotionSolve XML model name

2. Output MRF name
3. MotionSolve user DLL name (optional); enter empty single quotes ('') if not used.
Note The first argument i.e. the MotionSolve XML model name must be exactly the same as
the XML file that will be run on Machine B during the co-simulation.

1. On Machine B, in a shell prompt, run the command msdaemon. To run this command
correctly, you will need to setup a few environment variables on Machine B. Please see
MotionSolve Environment Variables for more information on these environment variables. The
command msdaemon must be issued from the same working directory where the MotionSolve
XML resides. After issuing this command, you have setup MotionSolve in a listening mode. The
co-simulation will start whenever the simulation is started from Simulink.
On Machine A, click Simulation > Start to start the co-simulation. Simulink uses ODE45 to
solve the Simulink model. From this, the co-simulation should begin and Simulink will wait to
connect to the MotionSolve model.
After starting the simulation in Simulink, MotionSolve will connect with the Simulink model and the
subsequent co-simulation will result in an output .mrf file for post-processing. Set the Scopes in
the Simulink model to display the results. Also, check the .log file to make sure no errors or
warnings were issued by MotionSolve.
Figure 9: Running the co-simulation from Simulink
Step 7: Compare the MotionSolve-only results to the co-simulation results.

1. From the Start menu, select All Programs > Altair HyperWorks 14.0 > HyperGraph.
2. Click the Build Plots icon, .

3. Click the file browser icon, , and load the InvertedPendulum_NoCosimulation.mrf file. This
was the baseline results created by running MotionSolve by itself.
4. In the Page Controls toolbar, create two vertical plot windows.
Figure 10: C reate two plot windows
(on Slider cart) for Y Request, and DX for Y Component to plot the carts translational
displacement:
Figure 11: Plot the carts displacement
6. Select the window on the left and click Apply.
for Y Request, and FX for Y Component to plot the X component of the control force:
Figure 12: Plot the control force on the cart
8. Click the file browser icon, , and load the InvertedPendulum_Cosimulation.mrf file. This
was the co-simulation results run with Simulink.

(on Slider cart) for Y Request, and DX for Y Component to overlay the plot in the left window.
Select Marker Force for Y-Type, then REQ/70000002 Output control force- (on Slider cart)
for Y Request, and FX for Y Component to overlay the plot in the right window.
You will notice that both the signals match as shown below.
Figure 13: C omparison of the cart displacement and cart control force between the two models
The blue curves represent results from the MotionSolve-only model and the red curves represent
results from the co-simulation.


Perform Static+Linear analysis on a MotionView model using ADAMS/Linear

View the Static+Linear analysis results from ADAMS/Linear analysis using MotionView
Theory
This chapter deals with modal analysis of Multi-Body Dynamic (MBD) systems. This kind of analysis
gives insight about system stability. Vehicle dynamics engineers often use the planar half-car model to
analyze the ride quality of vehicles. You will use the ADAMS/Linear simulation to do a modal analysis of
this type of model.
Process
Using the MotionView interface, you can obtain modal results in two ways: using MotionSolve and
ADAMS/Linear. These two ways are illustrated in the flowcharts below:
Obtaining modal results with MotionSolve or ADAMS/Linear

Step 1: Obtaining Modal Results with ADAMS/Linear.

OR
From the File menu select Open > Model.
3. From the Open Model dialog, locate and select the halfcar_lin.mdl file located in
mbd_modeling\externalcodes folder.
4. Click the Open button to load the model.
5. From the SolverMode menu, select ADAMS.
6. Click the Forms icon, , on the Model-General toolbar and select the Solution Options form.
7. Verify that the Solution type is set to Linear/Eig.
This ensures the ADAMS solver will first do a static analysis and then a linear modal analysis on
your model.
Complete the following steps only if you have connected the ADAMS solver
! to the Run button in the MotionView interface through the preferences file.
If ADAMS solver is not linked to MotionView, for the purpose of this tutorial,
go to Step 2: Viewing ADAMS/Linear Modal Results.
9. From the Script combo box, change the script to Altair Executable.
10. Click Run to start the simulation.
Step 2: Viewing ADAMS/Linear Modal Results.

1. Copy the files halfcar_lin_adams.gra and halfcar_lin_adams.res, located in the
mbd_modeling\externalcodes folder, to your <Working directory>.
3. Select HyperView from the Select Application list.
4. Click the Load Results icon, , from the Standard toolbar.
The Load model and results panel is displayed.
5. Click the Load model file browser and select the file halfcar_lin_adams.gra, located in
<Working directory>.

6. Click the Load results file browser and select the file halfcar_lin_adams.res, located in
<Working directory>.
7. Click Apply.
8. From the Results Browser, click on the arrow next to Time History Animation and use the
Change load case drop-down menu to set the load case to Mode Animation @ Time =
0.000000.
9. The modes will automatically load and be displayed in the Simulation drop-down menu (located
directly under the Change load case drop-down menu).
While an ADAMS Linear analysis may be performed multiple times through a transient simulation, in
this example, the linear analysis was performed only at time step = 0.0.
10. Use the Simulation drop-down menu to select Mode 3.
11. Switch the view to Top .
12. Click the Start/Pause Animation icon, , to start transient animation.
The model cycles through its mode shapes/frequencies.
13. Click the Start/Pause Animation icon again, , to stop transient animation.

14. Switch to Modal animation, .
Note To visualize a single mode while using the ADAMS/Solver, the Modal icon is used, .
For MotionSolve the Start/Stop Animation icon is used, .
15. Click the Page Layout icon on the Page Controls toolbar and select a four-window layout
Note that the current window becomes one of the four windows.
16. Click one of the remaining windows to make it active.
17. From the Load model panel, click Apply.
18. Repeat steps 16 and 17 for the remaining windows (Note - the Edit menu can also be used to
copy and paste windows into the four-window layout), and then load Simulation Modes 4, 5,
and 6.
Notice that the animations signify the pitch and bounce modes of car
! vibrations. The "wheel hop" resonance can also be seen in this example.
Analyzing the above occurrences can help isolate vibrations by
appropriately designing car suspensions.
Linear modal animation ADAMS/Linear results

Step 3: Plotting ADAMS/Linear Results for Eigenvalues in the Complex Plane.
A file named halfcar_lin_adams.eig_inf is generated in the directory <working directory> where
the gra and res files are located following an ADAMS/Linear run. The extension eig_inf denotes
eigenvalue information.
In this exercise, you will use this file to plot the model eigenvalues in the complex plane.
Eigenvalues in the complex plane

MotionView-MotionSolve-ADAMS process flow
MotionView-MotionSolve can work very closely with ADAMS.

Existing ADAMS users can switch to MotionView or MotionSolve in their workflow keeping the
rest of the flow as it is.
Following are the different ways one can use MotionView or MotionSolve with ADAMS.
Import a model built in ADAMS preprocessor into MotionView preprocessor; solve it with
MotionSolve and post process the results using MotionView.
Submit a model built in ADAMS directly to MotionSolve and post process the results in
MotionView.
Build a model in MotionView, submit it to ADAMS solver and post process the results using
MotionView.
Post process the ADAMS solver results in MotionView.
Exercise
Step1: Loading an .adm File into MotionViews MBD Model Window.

1. Copy the file quick_return.adm file, located in the mbd_modeling\externalcodes folder, to your
current <working directory>.
2. Start a new MotionView session by selecting New > Session from the File menu.

3. Make sure the application is MBD model.
4. From the File menu, select Import > Solver Deck.
OR
Click the Import Solver Deck button on the Standard toolbar.
Note If the Import Solver Deck button is not visible, click on the Import drop-down menu
(the down arrow next to the icon) and select the Import Solver Deck option.
5. From the Import Solver Deck dialog, use the Select file browser to locate and select the .adm
file.
6. Click Import.
The MotionView message log generates warning messages for all unsupported ADAMS statements
in your model. Unsupported ADAMS statements are stored in the Unsupported Statements
template. This template and its contents can be viewed from the Templates panel on the
MotionView toolbar.
Unsupported ADAMS statements template
7. Use the Project Browser to examine the model tree.
Note adm is an input file for the solver. Due to this the model comes out flat and there is no
hierarchy. In addition, you would see many markers involved.
Now the model is in the MotionView domain. You can modify the model the way you want and
then run MotionSolve from the MotionView interface.

Step2: Running an ADAMS File with MotionSolve.
In step 1, we learned how to import an ADAMS (.adm) file into MotionView. This allows the user to
modify the model once it is in the MotionView environment. Step 2, shows how a user can run an
ADAMS model directly in MotionSolve.
Copy the ADAMS input files quick_return.adm and quick_return.acf, located in the
externalcodes folder, to your current <working directory>.
1. Invoke MotionSolve.
2. Browse for the quick_return.acf file in your <working directory>.
3. Click on Run.
This would start a MotionSolve run in a command prompt. MotionSolve would run in a batch
mode. MotionSolve would read the information from the ADAMS command file (*.acf) and ADAMS
model data file (*.adm) , generate the solver input file (*.xml) then run it.
4. You may view the results in HyperView/HyperGraph.
Note MotionSolve generates *.log file which holds information for the solver run. It is always a
good idea to go through the log file for detailed information.
Step 3: Running an MotionView MBD model with ADAMS solver.

In Step 1 and Step 2 we learned how to run an ADAMS model with MotionSolve. Step 3 focuses on
running a model built in MotionView with the ADAMS solver. If you want to run the ADAMS solver from
the MotionView interface, please refer to Tip Trick #213 available on Altairs website.
1. Copy the file V_Engine.mdl, located in the externalcodes folder, to your current <working
directory>.
2. Invoke MotionView.
3. Load the model in MotionView.
4. From the menu bar select SolverMode as ADAMS.

5. From the Project Browser, locate the Datasets folder and select Solution Options as the
dataset.
These datasets are used to control the solver run.
6. Change the end time to 3 seconds.
7. Right-click on ADAMS Model in the Project Browser and select Model > Add General MDL
Entity > Template, or click on Templates icon on the Model-General toolbar, to add a
template.
Note This is a very important feature when it comes to solver neutral modeling. The
statements written in this section are directly written to the solver input deck. You can
pass modeling entities to these templates. Please refer to the template "Solution Option-
ACF file" to understand how values from datasets are passed to an acf file.
8. Add the following statement in the template: !The idstring for center of mass maker for
body 0 is {Model.b_0.cm.idstring}.
Note This is a comment and will not change the model. One needs to be familiar with solver
input file formats to use this feature.
9. From the File menu, select Export > Solver Deck. This saves the ADAMS input files (*.adm/
*.acf). You can then run the ADAMS solver using these files.
10. If the ADAMS solver is hooked to MotionView, click on the Run icon .
11. Check the model.
12. If there are no errors, run the model directly.

MotionView provides a solver-neutral pre- and post- processing environment to facilitate working with
other MBD solvers.
MotionView has the following solver interfaces:
MotionSolve
ADAMS
ABAQUS
MDL models can be exported to any of these solvers for analysis:
User can change the solver mode and then export the model to the particular solver.
User can register a script to run a solver from within MotionView. Refer to the Tip and Trick,
"Start an ADAMS run from within MotionView" available on Altairs website.
If the user needs to add any statement specific to the solver, Templex template can be used
in the model. Refer to tutorial MV-4010 for some more details about the Templex template.
The results from these solvers can be post processed in MotionView.
Copy the folder named solver_neutral, located in the mbd_modeling\externalcodes folder, to
Exercise
Step 1: Loading a Solver-Neutral Model and Running Different Solvers.

2. Copy the folder named solver_neutral, located in the mbd_modeling\externalcodes folder, to

3. Load the file model.mdl.
4. From the SolverMode menu, confirm that MotionSolve is selected.
5. Click the RUN icon, , on the Model-Main toolbar.
6. From the Main tab, specify your output filename as <working directory>\ms.xml.
7. Select the Simulation type: Transient.

8. Click Run.
MotionSolve is launched and completes the run.
9. From the SolverMode menu, select ADAMS.
10. From the Project Browser, under the Data Sets folder select Solution Options.
11. Review the Solution Options dataset.
12. You can enter the simulation parameters for the ADAMS solver into this table.
13. Click the RUN icon, , on the toolbar.
14. Specify the output filename as <working directory>\adams.adm.
Do not complete the following steps without connecting the ADAMS solver to
the RUN button.
! For this tutorial, you can assume the ADAMS run is complete and go to
Step 2: Comparing Solver Animations.
15. From the Script combo box, select the script ADAMS Executable.
16. Click the RUN button to start the simulation.
The ADAMS solver is launched and completes the run.
Step 2: Comparing Solver Animations.
1. Click the Add Page icon, , on the Page Controls toolbar to add a new page to your session.
2. Select HyperView from the Select Application drop-down menu.
3. Click the Page Layout, , icon on the toolbar and select the three horizontal windows
layout, .

4. Load the following model and results files into the three windows:
Window 1 Window 2
Model ms.h3d adams.gra
Results ms.h3d adams.gra
5. Click the Start/Pause Animation icon, , on the Animation toolbar to animate the model.
Notice that if the same solver parameters are chosen, the results from different solvers are in-
sync.
6. Click the Start/Pause Animation icon again, , to stop/pause the animation.

MotionView can write input decks for the Abaqus solver. Users can:
Export Abaqus solver input deck (*.inp) for the rigid body model
Replace a rigid body in the model with a ABAQUS substructure (flexible body) and export
ABAQUS solver input deck (*.inp)
Replace a rigid body with ABAQUS inp (nodal FE component) file and export ABAQUS solver
input deck (*.inp)
The results of the Abaqus solver can be post processed in HyperView.
Here is the flow of flexible body creation and integration:
Integrating Abaqus substructure or FE model in MotionView
Exercise
In the first step of the exercise, you will be creating an Abaqus substructure. The second step
involves the replacement of the rigid lower control arm with the Abaqus substructure. In the third step
you will run the solver, and in last step you will post process the results.
Copy the folder abaqus, located in the mbd_modeling\externalcodes folder, to your <working
directory>.

Step 1: Creating the Flexible Body Substructure.
First, you will need to create the flexible body. This stage must be completed in Abaqus, independent
of MotionView.
It is assumed that you are familiar with flexible multi-body dynamics in Abaqus. Here is a brief
overview of the steps you would need to do in Abaqus to generate a substructure:
Use standard elements to define the structure

Assign material and geometric properties to the elements
Define the retained degrees of freedom. The retained nodes will connect the substructure to
the rest of the model
Substructures must be created in one analysis and used in a subsequent analysis
The Abaqus *.inp deck of a substructure generation analysis should look something like this:
*NODE...
*ELEMENT...
*MATERIAL...
*STEP
*FREQUENCY, EIGENSOL=LANCZOS
20
*BOUNDARY
RETAINED_NODES, 1, 6
*END STEP
*STEP
*SUBSTRUCTURE GENERATE
TYPE=z2, LIBRAYR=carm_right, MASS MATRIX=YES, OVERWRITE, RECOVERY MATRIX=YES
*RETAINED NODAL DOFS, SORTED=NO
RETAINED_NODESET,1,6
*RETAINED EIGENMODES, GENERATE
1,20,1
*END STEP
This is just a sample deck. For detailed syntax you may have to look up Abaqus documentation.

Note You have been provided with two inp files: carm_left.inp and carm_right.inp. Use these
files to generate the two substructure files (*.sup) for the left and right lower control arms
using Abaqus. These substructure files should be named as carm_left.sup and
carm_right.sup respectively.
The intermediate files (*.stt, *.mdl, *.prt) created by Abaqus during the substructure
generation analysis are required for reference during the MBD system analysis. You will need to
generate these files in Abaqus. The result files (*.mrf, *.odb) which are needed for the post-
processing step of this tutorial are provided.
Once the substructure is generated you should be ready to integrate it in your MBD model.
Step 2: Integrating a Flexible Body into the MBD System.

Once you complete the substructure generation step in Abaqus, you should have the <substructure-
name>.sup file. This .sup along with the original <substructure-name>.inp file will be used to
integrate your flexible body into MotionView.
1. Start a new MotionView session and load the file sla_abaqus.mdl, located in <working
directory>.
2. Make sure that the SolverMode is ABAQUS.
3. From the Project Browser, under the Bodies folder select the Lwr control arm.
4. On the Properties tab for the LCA-Left, activate the Deformable check-box.
5. Click Yes in the question dialog.
Notice that the graphics of the rigid body lower control arm vanishes.
Now you would need to specify a particular INP file that was used to create the flexible body.
6. For Functional source, select the Use nodal FEA body option from the drop-down menu.

7. Using the Graphic file browser, select carm_left.h3d from your working directory.
Properties tab
Notice that the Inp file field is automatically populated by MotionView.
Note The file carm_left.h3d is the graphic file for the lower control arm-left body. This
file is for display and assists in allowing faster pre-processing. The flexbody (or the INP
file in this case) is used to provide data to the solver. The graphic H3D file can be
generate from the input (INP) file (or CAD file) using the Import CAD or FE option
located in the Tools menu in MotionView. In this exercise the graphic H3D files are
provided.
If the INP file is located in the same directory as the H3D graphic file, the Inp file field
would be populated automatically. Otherwise, one also has the option of selecting the
INP file from its respective location.
8. Click Nodes .
9. Click the Find ALL button on the Nodes dialog to find nodes on the flexible body that are located
closest to the interface points on the vehicle model. The vehicle model is attached to the flexible
body at these interface nodes.
Nodes dialog

Note In this case there is no offset between the flexible-body interface nodes and their
corresponding interface points on the vehicle model. But if there is an offset you can
use the Align button. When you click the Align button, MotionView moves the
connection point in the model to the node location on the flexible body. If the offset is
more than the tolerance value, MotionView inserts a dummy body between the flexible
body and the nearest connection point. This affects any other entities that reference
this point.
You can attach joints to the flexible body only at the interface nodes. These
attachment nodes are created during your substructure generation analysis in Abaqus.
Creating more attachment points increases the actual number of modes calculated, and
may increase the CPU time.
10. Close the Nodes dialog.
11. Repeat steps 6 through 9 to integrate the right side flexible body carm_right.inp in your model.
Your model should look like the image below:
13. From the Tools menu, select Check Model to check your complete MBD model for errors.

Step 3: Running MBD Systems in ABAQUS.
The flexible bodies are now fully integrated in your model. Now you will set up the ABAQUS solver run.
MotionView writes out the INP file for the whole MBD system. It is important that this INP deck should
contain the substructure path references for the model to run successfully in Abaqus. The way to
include these is via Templates in MotionView. Templex templates can be used to export syntax
directly to the solver input deck, including parametric substitution if required.
1. From the Project Browser, under the Templates folder select the Abaqus output template.
2. Click the expansion button, , on the panel and read through the template.

Note For the ABAQUS solver, the location of statements within the solver input deck is
important. The four keywords used in this template allow you to position the extra text.
These keywords must be the first line of the Templex template. For additional
assistance and information on these keywords see the Exporting MDL models to ABAQUS
topic in the online help.
The remaining text of the template is written according to the position specified. In this
case there are two substructure paths included for the two flexible bodies. You will need
to add or delete such paths depending on the number of flexible bodies integrated in your
model.
{MODEL.sys_frnt_susp.b_lca.l.idstring} is the parameterized path to grab the

element ID number assigned to the left arm substructure.
Now your model is complete and ready to run in ABAQUS solver.
3. Close the Abaqus output template.
4. From the Project Browser, under the Data Sets folder select ABAQUS Solution Options.
5. From the File menu, select Export > Solver Deck.
6. Save your model as an MDL file named sla_flex.mdl in the working directory.
7. Save your model as sla_flex.inp file in your working directory.
Note You can run your model in ABAQUS at this stage. Select ABAQUS from the SolverMode
menu and click on the Run icon on the toolbar to display the Run panel. Specify a file
name for the inp file using the Save and run current model option and check the
Export MDL animation file check box. Click on the Run button. MotionView will write
the inp file and the maf file (which will be used for animation). If the ABAQUS solver
script is linked to MotionView, the job will be submitted to ABAQUS.
Step 4: Post-processing Abaqus Results.

You will now load the results of the Abaqus run in the Animation window.
Note MotionView has FIL2MRF translator residing in Tool..Custom wizards. Using this will allow you
to translate an Abaqus fil file to an mrf file. In this exercise the mrf file is provided to you.
The carm_left.odb and carm_right.odb files needed in this step will be generated once the
model successfully runs in Abaqus.
1. Click the Add Page icon, , on the toolbar to add a new page to your session.
2. Select HyperView from the Select window mode drop-down menu.
3. Load the sla_flex.maf and sla_flex.mrf as model and results files, respectively.
4. In the same window, again click the Load model file browser and select the carm_left.odb file
from your working directory.
5. Activate the Overlay checkbox and click Apply.
6. Repeat the steps 4 and 5 to also overlay carm_right.odb file on the same model.
Notice that the substructures are overlayed on your model.

7. Use the Entity Attributes panel, , to turn off the graphics of the rigid control arm.
8. Click the Start/Pause Animation icon, , on the Animation toolbar to animate the model.
9. Click the Start/Pause Animation icon again, , to stop/pause the animation.

Vehicle Simulation using Altair Advance
Driver

Assemble the vehicle for full vehicle simulations using Assembly Wizard
Attach the driver using Task Wizard
What is Altair Advanced Driver?
The Altair Driver is a set of MotionView models and libraries that allows MotionView users to control
and script vehicle events. Example events include:
Constant Radius Cornering
Single Lane Change

Double Lane Change
User Defined Path Following
Fish Hook Event, etc.
This is achieved by creating an interface to the five vehicle inputs:
Steering
Throttle
Gear
Brake
Clutch
Using Altair Driver you can simulate any number of full vehicle events using these features:
Scripting break up the simulation into different maneuvers; select the controllers for vehicle
inputs and define conditions that end each maneuver.
Open-loop, closed-loop, and user-defined controllers to control.
Longitudinal speed or acceleration.
Vehicle path or lateral acceleration.

Switching controllers during a simulation.
Defining path and speed profiles parametrically, in a table, or by referencing a data file.
Exercise
Step 1: Assembling the vehicle.


2. Make sure that the MBD-Vehicle Dynamics Tools preference file loaded is for all of the
MotionView functionality of the Advanced Driver to work properly.

3. Use the Assembly Wizard to assemble the vehicle model. In the first example, a linear torque map
powertrain will be used to avoid the complexity of adding controllers for gear and clutch.
4. Choose Full vehicle with advanced driver option. This takes care of all the dependencies of the
advanced driver. Click Next.
5. Choose the default selections in the following Assembly Wizard pages.
Page Label Selection Default

(Yes/No)
1 Model type Full vehicle with advanced driver No

(Yes/No)
2 Driveline configuration Front wheel drive Yes
3 Vehicle body Body Yes
3 Front suspension Frnt macpherson susp (1 pc. LCA) Yes
3 Steering linkages Rackpin steering Yes
3 Rear subframe None Yes
3 Rear suspension Rear quadlink susp Yes
3 Powertrain Linear torque map powertrain Yes
3 Signal generator Driver signal generator Yes
3 Tires FIALA/HTIRE Yes
4 Steering column Steering column 1 (not for abaqus) Yes
4 Steering boost None Yes
5 Front struts Frnt strut (with inline jts) Yes
5 Front stabilizer bars None Yes
5 Rear struts Rear strut (with inline jts) Yes
5 Rear stabilizer bars None Yes
6 Front jounce bumpers None Yes
6 Front rebound bumpers None Yes
6 Rear jounce bumpers None Yes
6 Rear rebound bumpers None Yes
7 Disk brakes Disk brakes Yes
7 Front driveline Independent fwd Yes
8 Next No
9 Finish No

Step 2: Adding driver analysis.
Use the Task Wizard to load the driver analysis.
1. From the Analysis menu, select Task Wizard.
2. Select Altair Advanced Driver Analysis from the Full vehicle Driver task drop-down menu.
The Altair Advanced Driver with icon is added to the browser tree. Selecting the driver icon
will open up the Altair Driver panel. This automatically resolves all of the vehicle attachments for
the Advanced Driver.

Step 3: Writing an Altair Driver File (ADF) driving event .
Driver requires an event script or the Altair driver file (ADF) to run any driving event. ADF can be
edited using any text editor or by clicking the Edit Driver File button on the driver panel.
Example #1 Open Loop Acceleration Event
The objective of the example is to script an event with 50% throttle, 0% brake and 0 steering angle.
An event can be broken down into smaller sub-events or maneuvers. For the sake of simplicity we will
model this as a single maneuver event.
1. Open any text editor and copy and paste the following text into it. Be sure to read through the
comments for a better understanding on what is written in the ADF.
$-----------------------------------------------------------------ALTAIR_HEADER
$ This block is required for version control

[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
FILE_FORMAT = 'ASCII'
$--------------------------------------------------------------------------UNITS
$In this block we specify the units in which this file should be read
[UNITS]
(BASE)
{length force angle mass time}
'meter' 'newton' 'radians' 'kg' 'sec'
$--------------------------------------------------------------------VEHICLE_IC
$In this block we specify the initial conditions specifically initial speed of the
$vehicle with respect to the vehicle IC marker in the driver attachments
[VEHICLE_INITIAL_CONDITIONS]
VX0 = -20.0
VY0 = 0.0
VZ0 = 0.0
$--------------------------------------------------------------STEERING_STANDARD
$This block specifies the saturation and cutoff frequency for the low pass filter for
$steering output signal. These signals are global and are active for the entire event
[STEER_STANDARD]
MAX_VALUE = 3.141593
MIN_VALUE = -3.141593
SMOOTHING_FREQUENCY = 10.0
INITIAL_VALUE = 0.0
$--------------------------------------------------------------THROTTLE_STANDARD
$throttle output signal

[THROTTLE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.00
INITIAL_VALUE = 0.5
$---------------------------------------------------------------BRAKING_STANDARD
$brake output signal
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0
INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST
$This block provides the list of all the maneuvers, simulation time for each maneuver
$maximum solver step size (hmax) and print interval
[MANEUVERS_LIST]
{ name simulation_time h_max print_interval}
'MANEUVER_1' 5.0 0.01 0.01
$---------------------------------------------------------------------MANEUVER_1
[MANEUVER_1]
$This block provides the ties controllers to each driver output
TASK = 'STANDARD'
(CONTROLLERS)
{DRIVER_SIGNAL PRIMARY_CONTROLLER ADDITIONAL_CONTROLLER}
STEER OL_STEER_0 NONE
THROTTLE OL_0.5 NONE
BRAKE OL_0 NONE

$---------------------------------------------------------OL_STEER
$This is controller block containing all the information required by
$the driver to construct the controller. Different controllers have
$different requirements. Here we are using open loop constant type
$of controller.
[OL_STEER_0]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0.0
$---------------------------------------------------------OL_BRAKE
[OL_0]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0.0
$---------------------------------------------------------OL_THROTTLE
[OL_0.5]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0.5
2. Save the file.
3. Source the file in the Altair Driver File browser.
4. The Edit driver file button can be used for editing the file.
5. Run the simulation .

6. After the simulation run is over and the solver creates h3d and plt files, click View Reports for
standard plots.
7. Select the recent run in the View Reports dialog and click OK.

8. The noise in the steering is numerical error of negligible magnitude 0 for all practical purposes.
Throttle is constant at 0.5 (driver throttle, brake and clutch outputs are normalized so, 50%) and
brake is constant at 0.
9. Next let's try slightly different initial conditions. We will start the throttle at 0 and brake at 100%
. Click the Edit Driver File button to open up the file editor.
10. Change the INITIAL_VALUE attribute in the THROTTLE_STANDARD block in the ADF, from 0.5 to
0.
[THROTTLE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.00
INITIAL_VALUE = 0.5 0
11. Similarly, change the INITIAL_VALUE attribute in the BRAKE_STANDARD block in the ADF, from
0.0 to 1.0.
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0
INITIAL_VALUE = 0.0 1.0
12. Save the ADF.
13. Run the simulation and study the results.

14. Now, we see that throttle and brake start from respective initial values and step up to the
controller outputs. The time taken to step up is roughly (5x1/SMOOTHING_FREQUENCY).
Example #2 Open Loop Sinusoidal Steering Event
In this example we will model a simple event with constant 20% throttle, constant 0% throttle and
1. Open any text editor and copy/paste the following text into it.
$-----------------------------------------------------------------ALTAIR_HEADER
[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
$--------------------------------------------------------------------------UNITS
[UNITS]
(BASE)
$--------------------------------------------------------------------VEHICLE_IC

VX0 = -20.0
VY0 = 0.0
VZ0 = 0.0
[STEER_STANDARD]
MIN_VALUE = -3.141593
INITIAL_VALUE = 0.0
[THROTTLE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.00
INITIAL_VALUE = 0.2
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0
INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST
[MANEUVERS_LIST]
'MANEUVER_1' 10.0 0.01 0.01
$---------------------------------------------------------------------MANEUVER_1
[MANEUVER_1]

TASK = 'STANDARD'
(CONTROLLERS)
STEER OL_STEER NONE
THROTTLE OL_THROTTLE NONE
BRAKE OL_BRAKE NONE
$---------------------------------------------------------OL_STEER.
$SIGNAL_CHANNEL tells the driver which solver variable in Signal Generator to over-ride
$with the EXPRESSION value. The EXPRESSION should be consistent with MOTIONSOLVE.
[OL_STEER]
TAG = 'OPENLOOP'
TYPE = 'EXPRESSION'
SIGNAL_CHANNEL =0
EXPRESSION = 'DTOR(60)*SIN(2*PI*0.5*TIME)'
$---------------------------------------------------------OL_THROTTLE
[OL_THROTTLE]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0.2
$---------------------------------------------------------OL_BRAKE
[OL_BRAKE]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0.0

Example #3 Open Loop Curve Driven Braking Event
In this example we will model a simple event with braking signal as a curve.
1. Open text editor and copy/paste the following text into it.
$-----------------------------------------------------------------ALTAIR_HEADER
[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
$--------------------------------------------------------------------------UNITS

[UNITS]
(BASE)
$--------------------------------------------------------------------VEHICLE_IC
VX0 = -20.0
VY0 = 0.0
VZ0 = 0.0
[STEER_STANDARD]
MIN_VALUE = -3.141593
INITIAL_VALUE = 0.0
[THROTTLE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.00
INITIAL_VALUE = 0.0
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0
INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST

[MANEUVERS_LIST]
'MANEUVER_1' 10.0 0.001 0.01
$---------------------------------------------------------------------MANEUVER_1
[MANEUVER_1]
TASK = 'STANDARD'
(CONTROLLERS)
STEER OL_STEER NONE
THROTTLE OL_THROTTLE NONE
BRAKE OL_BRAKE NONE
$---------------------------------------------------------OL_STEER.
$SIGNAL_CHANNEL tells the driver which solver variable in Signal Generator to over-ride
$with the EXPRESSION value. The EXPRESSION should be consistent with MOTIONSOLVE.
[OL_STEER]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0.0
$---------------------------------------------------------OL_THROTTLE
[OL_THROTTLE]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0.0
$---------------------------------------------------------OL_BRAKE
[OL_BRAKE]
TAG = 'OPENLOOP'

TYPE = 'CURVE'
BLOCK = 'BRAKE_CRV'
$---------------------------------------------------------CURVE_DATA
[BRAKE_CRV]
INDEPENDENT_VARIABLE = 'TIME'
DEPENDENT_VARIABLE = 'BRAKE_SIGNAL'
INTERPOLATION = 'LINEAR'
{TIME BRAKE_SIGNAL}
0 0
1 0
2 0.2
3 0.5
4 0.8
5 1.0
6 1.0
7 0
10 0

Define a path and velocity or acceleration profile

Set up a feedforward steering controller to follow a path
Set up a feedforward traction controller to follow a velocity or acceleration profile
Feedforward Controllers
In a feed-forward system, the control variable adjustment is not error-based. Instead it is

based on knowledge about the process in the form of a mathematical model of the process and
knowledge about or measurements of the process disturbances.
In simpler words, controller that uses the knowledge about the vehicle, to compute the signals
Assume, a driver who knows that the vehicle weighs 1000 Kg and 30% throttle produces 1000
N of force in forward direction. If asked to produce 1 m/s2 of acceleration would simply give
30% throttle.
Defining a path for the driver
Multiple methods can be used to provide the desired path:
Table of centerline points: Path is provided as a table of equally spaced cartesian

coordinates of centerline points. These points are provided in a separate file, DDF or Driver
Demand File.
$Example DDF
[ALTAIR_HEADER]
FILE_TYPE = 'DDF'
FILE_VERSION = 1.0
$---------------------------------------------------UNITS
[UNITS]
(BASE)
'm' 'newton' 'degrees' 'kg' 'sec'

$---------------------------------DEMAND_VECTORS
[DEMAND_VECTORS]
{X Y Z}
0 0 0
-4 0 0
-1 0 0
-2 0 0
-5 0 0
-3 0 0
Sequence of straights and arcs: Path is provided as a table of straights and circular section.
KEY PAR0 PAR1
ST Length of the straight section Unused

KEY PAR0 PAR1
ARC Radius of curvature Angle of the arc
Positive angle means anti-clockwise arc
Negative angle means clockwise arc
[PATH]
{KEY PAR0 PAR1}
'ST' 100.0 0
'ARC' 50.0 1.57079
'ST' 100.0 0
'ARC' 50.0 3.14159
'ST' 200.0 0
'ARC' 50.0 -2.35619
Predefined path: Path is one of the predefined paths visualization (Constant Radius, Single
lane change, Double lane change, and Slalom).
$Example block for constant radius path

[PATH]
TYPE = 'CONSTANT_RADIUS'
RADIUS = 30
INITIAL_STRAIGHT = 45
TURN = 'LEFT
Defining a velocity or acceleration profile for the driver
Demand velocity or acceleration profile is similar to open loop signal explained in tutorial 1. All
methods constant, expression and curve are valid for demand signal definition as well.
Exercise

1. Follow the instructions in Step #1 of MV-8000 to create the vehicle with the topology as provided
below.

(Yes/No)

(Yes/No)
5 Front stabilizer bars None Yes
5 Rear stabilizer bars None Yes
8 Next No
9 Finish No

1. Use the Task Wizard to load the driver analysis.
Step 3: Specifying vehicle parameters

1. We are going to use feedforward controllers for path and velocity profile following. Feedforward
controllers model the vehicle and therefore, require vehicle parameters. Vehicle parameters need
not be precise for controllers to work. Most of the vehicle parameters required by the driver can
be automatically calculated from the vehicle model.

Example #1 Constant Radius with Constant Velocity Event
$-----------------------------------------------------------------ALTAIR_HEADER
$ This block is required for version control
[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
$--------------------------------------------------------------------------UNITS
$In this block we specify the units in which this file should be read
[UNITS]
(BASE)
$--------------------------------------------------------------------VEHICLE_IC
$In this block we specify the initial conditions specifically initial speed of the

$vehicle with respect to the vehicle IC marker in the driver attachments
VX0 = -15.0
VY0 = 0.0
VZ0 = 0.0
$steering output signal. These signals are global and are active for the entire event
[STEER_STANDARD]
MIN_VALUE = -3.141593
INITIAL_VALUE = 0.0
$throttle output signal
[THROTTLE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.00
INITIAL_VALUE = 0.5
$brake output signal
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0

INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST
$This block provides the list of all the maneuvers, simulation time for each maneuver
$maximum solver step size (hmax) and print interval
[MANEUVERS_LIST]
'MANEUVER_1' 15.0 0.005 0.01
$---------------------------------------------------------------------MANEUVER_1
[MANEUVER_1]
TASK = 'STANDARD'
(CONTROLLERS)
STEER FEEDFORWARD_STEER NONE
THROTTLE FEEDFORWARD_TRACTION NONE
BRAKE FEEDFORWARD_TRACTION NONE
$---------------------------------------------------------STEER
$different requirements. Here we are using feedforward steering
$controller.
[FEEDFORWARD_STEER]
TAG = 'FEEDFORWARD'
LOOK_AHEAD_TIME = 0.5
PATH = 'PREDEFINED'
BLOCK = 'PATH'
$---------------------------------------------------------PATH
$Block containing the information about the path to be followed

[PATH]
RADIUS = 40
TURN = 'LEFT'
$--------------------------------------------------THROTTLE & BRAKE
[FEEDFORWARD_TRACTION]
TAG = 'FEEDFORWARD'
TYPE = 'FOLLOW_VELOCITY'
DEMAND_SIGNAL = 'DEMAND_SPEED'
$---------------------------------------------------------DEMAND_SPEED
$Block containing all the information about the velocity profile to be followed
[DEMAND_SPEED]
TYPE = 'CONSTANT'
VALUE = 15.0
2. Save the ADF.
4. Observe the results.
5. Next let's try the same path using another method - Sequence of straight and arcs.
6. Change the PATH attribute in the FEEDFORWARD_STEER block in the ADF to

SEQUENCE_OF_ST_CRV.
[FEEDFORWARD_STEER]
TAG = 'FEEDFORWARD'
PATH = 'PREDEFINED SEQUENCE_OF_ST_CRV '
BLOCK = 'PATH'
7. Replace the path block in the ADF with the following text.
[PATH]
{KEY PAR0 PAR1}
'ST' 20 0
'ARC' 40 6.28318

8. Rerun the simulation. This is simply a change in the method of providing the same path and
therefore, should make any difference in the results.
Example #2 Straight Line Acceleration Event
In this example we will create an event to follow a straight line while accelerating the vehicle
constantly with 2 m/s2.
1. Open any text editor and copy/paste the following text into it.
$-----------------------------------------------------------------ALTAIR_HEADER
[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
$--------------------------------------------------------------------------UNITS
[UNITS]
(BASE)
$--------------------------------------------------------------------VEHICLE_IC
VX0 = -20.0
VY0 = 0.0
VZ0 = 0.0
[STEER_STANDARD]
MIN_VALUE = -3.141593
INITIAL_VALUE = 0.0
[THROTTLE_STANDARD]
MAX_VALUE = 1.0

MIN_VALUE = 0.00
INITIAL_VALUE = 0.2
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0
INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST
[MANEUVERS_LIST]
'MANEUVER_1' 10.0 0.01 0.01
$---------------------------------------------------------------------MANEUVER_1
[MANEUVER_1]
TASK = 'STANDARD'
(CONTROLLERS)
$---------------------------------------------------------STEER
$different requirements. Here we are using feedforward steering
$controller.
[FEEDFORWARD_STEER]

TAG = 'FEEDFORWARD'
PATH = 'PREDEFINED'
BLOCK = 'PATH'
$---------------------------------------------------------PATH
$Block containing the information about the path to be followed
[PATH]
RADIUS = 40
TURN = 'LEFT'
$--------------------------------------------------THROTTLE & BRAKE
TAG = 'FEEDFORWARD'
TYPE = 'FOLLOW_VELOCITY FOLLOW_ACCELERATION'
DEMAND_SIGNAL = 'DEMAND_SPEEDDEMAND_ACC'
$---------------------------------------------------------DEMAND_ACC
$Block containing all the information about the acceleration profile to be followed
[DEMAND_SPEED]
TYPE = 'CONSTANT'
VALUE = 2.0
Example #3 Path as a Table of Cartesian Coordinates of Centerline Points Event
In this example well give path as a table of Cartesian coordinated of centerline points. Well define the
velocity profile as well along the path.
1. Open text editor and copy/paste the following text into it.
$-----------------------------------------------------------------ALTAIR_HEADER
[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
$--------------------------------------------------------------------------UNITS
[UNITS]
(BASE)

$--------------------------------------------------------------------VEHICLE_IC
VX0 = -20.0
VY0 = 0.0
VZ0 = 0.0
[STEER_STANDARD]
MIN_VALUE = -3.141593
INITIAL_VALUE = 0.0
[THROTTLE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.00
INITIAL_VALUE = 0.2
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0
INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST
[MANEUVERS_LIST]
'MANEUVER_1' 10.0 0.01 0.01
$---------------------------------------------------------------------MANEUVER_1
[MANEUVER_1]
TASK = 'STANDARD'
(CONTROLLERS)
$---------------------------------------------------------STEER
[FEEDFORWARD_STEER]
TAG = 'FEEDFORWARD'
$Instruction to the driver that the path is of type DDF
PATH = 'DDF'
$Path of the ddf file, data lies in same folder in file named snet.ddf
FILE = 'snet.ddf'
$--------------------------------------------------THROTTLE & BRAKE
TAG = 'FEEDFORWARD'

$---------------------------------------------------------DEMAND_SPEED
[DEMAND_SPEED]
TYPE = 'CURVE'
$Velocity profile information is in the file snet.ddf in the same folder
$Velocity profile is defined under the column name DV in the DDF
${X Y Z DV}
FILE = 'snet.ddf'
DEMAND_VECTOR = 'DV'
2. Place snet.adf in the same folder as the ADF.
4. Alternatively, edit the DEMAND_SPEED block to be a curve as a function of distance traveled

along the centerline. Replace the DEMAND_SPEED block in the ADF with the following text.
[DEMAND_SPEED]
TYPE = 'CURVE'
BLOCK = 'DEMAND_CURVE'
$-------------------------DEMAND_CURVE
[DEMAND_CURVE]
INDEPENDENT_VARIABLE = 'PATH_S'
DEPENDENT_VARIABLE = SIGNAL
INTERPOLATION = 'LINEAR'
{PATH_S SIGNAL}
0 30
250 35
400 10
584 10
680 25
780 10
942 10
1300 40
1695 10
1868 10
1958 10
2040 15
2109 15
2173 15
2300 20
2409 15
2524 15
2647 10
2811 10
3500 50

Define end conditions for a maneuver or a sub-event

Write parametric expressions
Define events as multiple sub-events executed sequentially
End conditions
Conditions to end a particular maneuver before given simulation end time
Examples of the end conditions can be End maneuver when longitudinal velocity is greater
than 10 m/s or when roll angle reaches steady state
End conditions can be logically coupled (OR-ed or AND-ed) by splitting them into groups
Multi-maneuver events
Events consisting for more than one maneuver these maneuvers are executed sequentially
Controllers can only be changed while switching the maneuvers
Hence, rule of thumb whenever need to change the controller, change the maneuver
Driver does following while switching the maneuvers
o Halts previous maneuver
o Saves the signals value that acts as initial value for next maneuver in case of parametric
expressions , there is a list of signals that driver monitors. Please refer to the
documentation for more details.
o Executes the change of/in controller
o Starts new maneuver
Examples: Fishhook, J-turn, Throttle off cornering analysis

Parametric Expressions
When in a multi-maneuver event, expressions need to be re-evaluated before the start of the
maneuver in order to maintain the continuity of the signals.
{ Expression in Curly Braces } - Instruction to driver to evaluate the expression before
giving it to MotionSolve
{SIGNAL} is evaluated as VARVAL(signal solver variable id)
{SIGNAL_0} is evaluated as Signal Value at the end of last maneuver
{%SIGNAL} is evaluated as {SIGNAL} {SIGNAL_0}
Driver evaluates the expressions for the maneuver before the start of the maneuver
Example:
Throttle off cornering event

Maneuver 1 Constant radius cornering, constant radius path with constant velocity - until roll
angle reaches its maximum and stabilizes.
Maneuver 2 Step down the throttle while following the same path

In this event, Maneuver 1 would typically consist of closed loop steering and throttle
controllers. In Maneuver 2, the steering controller still remains the same, however the throttle
controller is open loop, type expression STEP(TIME end time of maneuver 1 , 0, throttle
value at the end of maneuver 1, 0.5, 0).
Exercise

below.

(Yes/No)

(Yes/No)
5 Front stabilizer bars Frnt stabar with links No
5 Rear stabilizer bars Rear stabar with links No
8 Next No
9 Finish No


1. We are going to use feedforward controllers for velocity profile following. Feedforward controllers
model the vehicle and hence, require vehicle parameters. Vehicle parameters need not be precise
for controllers to work. Most of the vehicle parameters required by the driver can be automatically
calculated from the vehicle model.

Example #1 Fish Hook Event
We will model this event in three maneuvers.
$-----------------------------------------------------------------ALTAIR_HEADER
[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
$--------------------------------------------------------------------------UNITS
[UNITS]
(BASE)
$--------------------------------------------------------------VEHICLE_IC
VX0 = -17.5
VY0 = 0.0
VZ0 = 0.0
[STEER_STANDARD]
$Upper and lower bounds are kept to match the event requirement of saturating at
$270 deg and -540 deg respectively
MAX_VALUE = 4.712
MIN_VALUE = -9.425
SMOOTHING_FREQUENCY = 5
INITIAL_VALUE = 0.0
[THROTTLE_STANDARD]
MAX_VALUE =1
MIN_VALUE =0
INITIAL_VALUE = 0.0
[BRAKE_STANDARD]
MAX_VALUE =1
MIN_VALUE =0
INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST
[MANEUVERS_LIST]
{name simulation_time h_max print_interval}
'GO_STRAIGHT' 2.0 0.01 0.1
'LEFT_TURN' 12.0 0.001 0.1
'RIGHT_TURN' 10.0 0.001 0.1

[GO_STRAIGHT]
TASK = 'STANDARD'
(CONTROLLERS)
STEER OL_CONSTANT_STEER NONE
THROTTLE FEED_FORWARD_TRACTION NONE
BRAKE FEED_FORWARD_TRACTION NONE
$---------------------------------------------------------------------MANEUVER_2
[LEFT_TURN]
TASK = 'STANDARD'
(CONTROLLERS)
STEER OL_LEFT_STEER NONE
$We want to end the maneuver if the roll rate reaches steady state i.e. d(Roll rate)/dt = 0
$(tolerance = 0.005) for 0.5 seconds
(END_CONDITIONS)
{SIGNAL GROUP ABS OPERATOR VALUE TOLERANCE WATCH_TIME}
ROLL_RATE 0 Y SS 0 0.005 0.5
$---------------------------------------------------------------------MANEUVER_3
[RIGHT_TURN]
TASK = 'STANDARD'
(CONTROLLERS)
STEER OL_RIGHT_STEER NONE
$--------------------------------------STEER for Maneuver 1
[OL_CONSTANT_STEER]
TAG = 'OPENLOOP'
TYPE = 'CONSTANT'
VALUE = 0
$Ramp up the steering wheel @ 360 deg per send
[OL_LEFT_STEER]
TAG = 'OPENLOOP'
TYPE = 'EXPRESSION'
SIGNAL_CHANNEL = 0
EXPRESSION = '{STEER_0} + {%TIME}*PI*2'
[OL_RIGHT_STEER]
TAG = 'OPENLOOP'
TYPE = 'EXPRESSION'
SIGNAL_CHANNEL = 0
EXPRESSION = '{STEER_0} - {%TIME}*PI*2'
$--------------------------------------THROTTLE and BRAKE controller for entire event
[FEED_FORWARD_TRACTION]
TAG = 'FEEDFORWARD'

DEMAND_SIGNAL = 'DEMAND_VEL'
$----------------Demand Velocity
[DEMAND_VEL]
TYPE = 'CONSTANT'
VALUE = 17.5
Maneuver 2 stops when roll rate is consistently 0 (with mentioned tolerance) for 0.5 seconds.

Interfacing gear clutch control for vehicles with manual transmission

Gear clutch controller
The Engine speed based shift controller upshifts whenever engine speed goes above the upshift RPM,
and it downshifts when the engine speed goes below the downshift RPM. The Gear shift controller
also controls the throttle and clutch signal as shown in the figure below.

Exercise

below.

(Yes/No)
3 Powertrain IC engine friction clutch (manual) Yes
5 Front stabilizer bars Frnt stabar with links No
5 Rear stabilizer bars Rear stabar with links No

(Yes/No)
8 Next No
9 Finish No


1. We are going to use feedforward controllers for velocity profile following. Feedforward controllers
model the vehicle and hence, require vehicle parameters. Vehicle parameters need not be precise
for controllers to work. Most of the vehicle parameters required by the driver can be automatically
calculated from the vehicle model.

Example #1 Velocity profile following with gear and clutch controller
We will modify the ADF which was written for MV-8001 (example 3) and incorporate a gear and clutch
controller.
$-----------------------------------------------------------------ALTAIR_HEADER
[ALTAIR_HEADER]
FILE_TYPE = 'ADF'
FILE_VERSION = 1.0
$--------------------------------------------------------------------------UNITS
[UNITS]
(BASE)

$--------------------------------------------------------------------VEHICLE_IC
VX0 = -20.0
VY0 = 0.0
VZ0 = 0.0
[STEER_STANDARD]
MIN_VALUE = -3.141593
INITIAL_VALUE = 0.0
[THROTTLE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.00
INITIAL_VALUE = 0.2
[BRAKE_STANDARD]
MAX_VALUE = 1.0
MIN_VALUE = 0.0
INITIAL_VALUE = 0.0
$---------------------------------------------------------------GEAR_STANDARD
[GEAR_STANDARD]
MAX_VALUE =6
MIN_VALUE =1
INITIAL_VALUE =1
$---------------------------------------------------------------CLUTCH_STANDARD
[CLUTCH_STANDARD]
MAX_VALUE =1
MIN_VALUE =0
SCALING_FACTOR =1
INITIAL_VALUE = 0.0
$-----------------------------------------------------------------MANEUVERS_LIST
[MANEUVERS_LIST]
'MANEUVER_1' 10.0 0.01 0.01
$---------------------------------------------------------------------MANEUVER_1
[MANEUVER_1]
TASK = 'STANDARD'
(CONTROLLERS)
GEAR GEAR_CLUTCH_CONTROL NONE
CLUTCH GEAR_CLUTCH_CONTROL NONE

$---------------------------------------------------------STEER
[FEEDFORWARD_STEER]
TAG = 'FEEDFORWARD'
$Instruction to the driver that the path is of type DDF
PATH = 'DDF'
$Path of the ddf file, data lies in same folder in file named snet.ddf
FILE = 'snet.ddf'
$--------------------------------------------------THROTTLE & BRAKE
TAG = 'FEEDFORWARD'
$---------------------------------------------------------DEMAND_SPEED
[DEMAND_SPEED]
TYPE = 'CURVE'
$Velocity profile information is in the file snet.ddf in the same folder
$Velocity profile is defined under the column name DV in the DDF
${X Y Z DV}
FILE = 'snet.ddf'
DEMAND_VECTOR = 'DV'
$Gear clutch controller
[GEAR_CLUTCH_CONTROL]
TAG = 'ENGINE_SPEED'
(GEAR_SHIFT_MAP)
{G US DS CT CRT TFD TFT CFT TRD TRT}
1 650 285 0.45 0.05 0.1 0.1 0.05 0.05 0.05
2 650 285 0.45 0.05 0.1 0.1 0.05 0.05 0.05
3 650 285 0.45 0.05 0.1 0.1 0.05 0.05 0.05
4 650 285 0.45 0.05 0.1 0.1 0.05 0.05 0.05
5 650 285 0.45 0.05 0.1 0.1 0.05 0.05 0.05

MotionView 2017 Tutorials PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

MotionView 2017 Tutorials PDF

Transféré par

Droits d'auteur :

Formats disponibles

HyperWorks 2017

Learn more at altairhyperworks.com

HyperWorks 2017 Products

Additional Altair Products:

Altair Packaged Solution Offerings (PSOs) Copyright 2008-2016

Altair Simulation Cloud Suite:

Altair PBS Works:

Software products of solidThinking, Inc., a wholly owned subsidiary of Altair Engineering:

ALTAIR ENGINEERING INC. Proprietary and Confidential. Contains Trade Secret

Third party software licenses

Software Security Measures:

Altair Support on the World Wide Web

Altair Training Classes

Telephone and e-mail

Location Telephone e-mail

Australia 64.9.413.7981 anzsupport@altair.com

Brazil 55.11.3884.0414 br_support@altair.com

Canada 416.447.6463 support@altairengineering.ca

China 86.400.619.6186 support@altair.com.cn

France 33.1.4133.0992 francesupport@altair.com

Germany 49.7031.6208.22 hwsupport@altair.de

India 91.80.6629.4500 support@india.altair.com

Italy 39.800.905.595 support@altairengineering.it

Japan 81.3.5396.2881 support@altairjp.co.jp

Korea 82.70.4050.9200 support@altair.co.kr

Mexico 55.56.58.68.08 mx-support@altair.com

North America 248.614.2425 hwsupport@altair.com

Scandinavia 46.46.460.2828 support@altair.se

Spain 34.910.810.080 support-spain@altair.com

South Africa 27.21.8311500 support@altair.co.za

United Kingdom 01926.468.600 support@uk.altair.com

Access the Model Files

MV-100: Introduction to the MotionView Environment

MV-1000: Interactive Model Building and Simulation

MV-1035: Importing CAD or FE into MotionView

MV-5000: Rigid body Animation - Basic

MV-5010: Rigid body Animation - Advanced

MV-6000: Plotting Basics

Model Definition Language

MV-1060: Introduction to MDL

MV-1070: Creating a Simple Pendulum System using MDL

MV-1080: Creating an Analysis using MDL

MV-1090: Creating a Dataset using MDL

MV-1030: Creating a System Definition Using the MotionView GUI

MV-1010: 3D Mesh to Mesh Contact Simulation

MV-1012: Analytical Contact Simulation using MotionView and MotionSolve

MV-1020 Modeling 2D Rigid to Rigid Contact Simulation

Flexible Body Modeling and Simulation using MotionView and

Altair Engineering MotionView 2017 Tutorials i

MV-2010: Flexbody Generation using Flex Prep and Optistruct

MV-2020: Use of Flexbody in MBD Models

MV-2021: Simulating an Automotive Door Closure Event

MV-2035: Solving Flexbody ADM/ACF in MotionSolve

MV-1032: Model Building and Simulation using Wizards

MV-1040: Model Building using Tcl

MV-1050: Automation Using TCL

MV-1051: Understanding Sequential Simulation

MV-3000: DOE using MotionView - HyperStudy

MV-3010: Optimization using MotionView - HyperStudy

MV-3030: Load Export

MV-3040: Durability and Fatigue Tools

Non-Linear Finite Elements

MV-2100: Introduction to Non-Linear Finite Element (NLFE) Analysis in MotionSolve