PDF file - Institut fÃ¼r Technische und Numerische Mechanik

Neweul-M 2 

Symbolic multibody simulation 

in Matlab 

Wiki of the ITM, University of Stuttgart 

Dipl.-Ing. T. Kurz 

University of Stuttgart 

Institute of Engineering and Computational Mechanics 

Prof. Dr.–Ing. Prof. E.h. P. Eberhard 

11. November 2011

Introduction 

This document is an export of the documentation to the multibody system simulation 

environment Neweul-M 2 . The program is a research software developed at 

the Institute of Engineering and Computational Mechanics, University of Stuttgart. 

The main source of documentation is kept in a Wiki, which allows all users 

at the institute to add information or edit existing articles. To make this documentation 

available for users not connected to the ITM computer network, all 

pages have been exported and collected in this file. 

For further information about the program you can contact the institute: 

Institute for Engineering and Computational Mechanics 

Prof. Dr.-Ing. Prof. E.h. P. Eberhard 

Pfaffenwaldring 9 

70569 Stuttgart 

Germany 

Tel +49 711 685-66388 

Fax +49 711 685-66400 

http://www.itm.uni-stuttgart.de/ 

Or the current supervisor of this software program 

Dipl.-Ing. Thomas Kurz 

+49 711 / 685 66394 

kurz@itm.uni-stuttgart.de 

2

Contents 

This document has the same structure as our Wiki. 

General information Information on how the program can be started, overview 

over the files, ... 

Getting started A short introduction, where three simple examples are explained 

step by step. 

List of files An alphabetical list of all files in the main folder. 

System definition Commands necessary for the definition of the system. 

Equations of motion Function calls to set up the equations of motion. 

Simulation and animation Available functions to be applied to the equatios 

of motion. This includes possibilities for the simulation and analysis of the 

system, as well as optimization. Displaying the results in a convenient way 

also belongs to this part. 

Exporting the system If you want to use your equations for a specific purpose 

outside of Neweul-M 2 , this might be an interesting part for you. 

Programming tips Some programming tips on how to achieve a well structured, 

readable program code. 

FAQs Very short collection of frequently asked questions. 

Release notes Short overview of the major changes. 

3

Neweulm2 - IT M Wiki 

Neweulm2 

From ITM Wiki 

Contents 

1 Simulation of Multibody Systems using Neweul-M² 

2 Getting started 

2.1 Getting Started: Step-by-Step 

2.1.1 Getting Started in German 

2.1.2 Graphical Getting started 

2.2 Cheat sheet 

3 General information 

3.1 Compatible Matlab versions 

4 Symbolic - Numeric - What? 

5 Using Neweul-M² at the ITM 

5.1 Ways to use Neweul-M² 

5.2 Server version 

5.3 Local version 

5.4 Starting Matlab 

6 Neweul-M² - neweulm2 - SYMBS - NEWEUL 

7 Release notes 

8 Available Models 

9 Structure of the Software 

9.1 Graphical User Interface 

10 Help 

11 Function reference 

11.1 Structure of the documentation 

11.1.1 Contents of this wiki 

11.1.2 Contents of the function help header 

11.2 Overview over the wiki documentation 

12 Notes for programers 

13 See also 

13.1 ITM Wiki 

13.1.1 Explanation of the functions 

13.1.2 Other topics 

13.2 ITM Server 

13.3 Literature 

1 von 16 30.08.2011 17:24


Simulation of Multibody Systems using Neweul-M² 

When analyzing, simulating and optimizing multibody systems, it is often 

advantegeous to have the equations of motion in symbolic form. While for small 

systems, the derivation of the equations of motion can be done easily by hand, it 

can get very hard to do so for more sophisticated systems with several degrees 

of freedom. Therefore, the software Neweul-M² is developed at the Institute of 

Engineering and Computational Mechanics. It is based on Matlab's Symbolic 

Toolbox which allows symbolic algebraic computations within Matlab. 

Neweul-M² is able to derive the symbolic equations of motion of tree-structured 

holonomic multibody systems automatically, and further, a symbolic 

linearization of the equations of motion with respect to an arbitrary symbolic 

reference motion is provided, which can be helpful for the analysis and 

optimization of vibration problems. For the Matlab-based simulation of 

multibody systems, various functions for the numerical evaluation of the 

nonlinear and linearised equations of motions and kinematic properties are 

provided. In the subsequent sections, the structure and usage of the software is 

explained. Further, a small section about multibody system theory is included, 

mainly in order to explain the various naming conventions. A comprehensive 

explanation of multibody system theory can be found in the textbook W. 

Schiehlen, P. Eberhard: Technische Dynamik. Wiesbaden: Teubner, 2004., which 

is also listed in #Literature. 

Getting started 

Getting Started: Step-by-Step 

To provide an entry into Neweul-M² as easy as possible, there are several 

step-by-step examples, so no previous knowledge is necessary. We recommend to 

follow the given order, as the examples are sorted in the order of complexity and 

number of features used. 

General Preparations: These preparations are necessary, before you can 

start with any one of the examples. 

Single Pendulum: The most basic example of a single pendulum. 

Double Pendulum: Set up a double pendulum with the graphical user 

interface to see more options. 

Slider Crank: A slider-crank-mechanism is set up to demonstrate algebraic 

constraint equations. 

Elastic Double Pendulum: Elastic bodies are defined and used to set up this 

mechanical system. 

Getting Started in German 

2 von 16 30.08.2011 17:24


Allgemeine Vorbereitungen: Vorbereitungen, die vor den Beispielen 

notwendig sind. 

Einfachpendel: Einfaches Einstiegsbeispiel 

Doppelpendel: Doppelpendel, an dem mehr Optionen gezeigt werden. 

Schubkurbeltrieb: Ein Schubkurbeltrieb, um algebraische 

Nebenbedingungen zu erklären. 

Elastisches Doppelpendel: Definition von elastischen Körpern und 

Einbindung davon in ein Mehrkörpersystem. 

Graphical Getting started 

After the General Preparations mentioned above, you can also type 

gettingStarted 

to open a window, which gives you a list of available models in the current 

examples directory. 

When you click Start, the selected model will be set up and all simulations 

provided in the respective directory will run subsequently. The nice thing about 

this is that the commands called by the GUI are presented, and the contents of 

all files to be adjusted to the individual problem are shown as they are evaluated. 

Like this you can follow this process, read it later or exit at any given step. 

3 von 16 30.08.2011 17:24


Cheat sheet 

If you already know something about the possibilities of Neweul-M² and just 

need a very short summary of the main commands and there option, you may 

want to look at our cheat sheet (http://www.itm.uni-stuttgart.de/itmwiki/wikidata 

/cheatSheet.pdf) . 

General information 

Compatible Matlab versions 

The software is currently being developed under Matlab R2007b and R2010b. 

The software has been tested under matlabR2006a, but there is one important 

issue. When using Neweul-M² outside of the institute, the files have been 

precompiled and are thus unreadable. This precompilation is not 

down-compatible. So when you want to use e.g. Matlab version R2006a, please 

ask your contact person at the ITM for a suitable version of the software. 

If you are using a Matlab of Version R2007b+ and newer, the Symbolic Math 

Toolbox is no longer using a Maple kernel. Instead MuPad is used for symbolic 

calculations. For such commands, wrapper functions have been introduced, 

called mapleSimplify and mapleSubs. Usually it is faster and provides more 

options when Maple is called directly instead of using the built-in Matlab 

functions. In a recent update, these wrapper functions should be able to 

determine the symbolic engine and use the correct commands. Before this it 

was necessary to adjust both of these wrapper functions to use the appropriate 

code. It is not so easy to determine, which way of calling is faster, because the 

speed depends strongly on the size and type of expressions. Therefore the user 

could try to use one of the other provided algorithms for special cases. These 

functions should be excluded from the precompilation and you can therefore 

read and adjust them to your needs. 

MuPad reserved some parameter names like beta or I for internal functions. 

Please be careful when moving models from one symbolic engine to another. For 

more information see Restrictions for Names 

Symbolic - Numeric - What? 

Neweul-M² calculates the equations of motion symbolically. This means it uses 

names like m1 for the parameters and not numbers 5 [kg] to set up the 

equations. This has several advantages, allowing the user to read and understand 

the expressions and allowing an explicit formulation. Also you can change values 

without recalculating the equations of motion. As not everything can be done 

4 von 16 30.08.2011 17:24


symbolically, the numbers come in at some point in the simulation. But always 

when you have two uses (symbolic and numeric) of the same things, there are 

some problems. To keep these as small as possible the complete data is stored in 

two ways simultaneously: 

the symbolic expressions are stored in the structure sys, available in the 

workspace. 

files containing source code, which will evaluate numerical values. 

Even if you only want the files to calculate numerical values, it might be good to 

save the system after modeling. When doing so in the menu of the GUI, it will 

save the figure and the data structure containing the symbolic expressions. The 

advantage is that you can load the data structure, change something and 

recreate the files. If you forgot to save before closing or the program crashed, 

you can still hope for the autosave. Every few minutes, your system is saved 

automatically to examples/sandbox/autosave.mat. In this case you should make a 

copy of the autosave files, otherwise they might be overwritten, the next time 

you do anything in Neweul-M². 

Using Neweul-M² at the ITM 

The following part is dedicated to using the software package at the ITM, 

University of Stuttgart. Probably they are of no importance when using the 

software somewhere else, but these explanations are available internally as a 

wiki and externally as a pdf export of the very same text. 

Ways to use Neweul-M² 

There are two versions available, one running on the server and stored locally. 

Who should use which version? 

With both versions, you can model a system, run simulations and analysis. Please 

answer the following questions: 

Do I want to write a new feature? 

Do I want to improve the current program? 

Do I want to work on a computer without connection to the ITM-Network? 

If you answered at least one question with 'yes', then please get a local version 

with SVN. Otherwise please use the server-version. 

Do NOT copy the files manually to get a local version!!! 

This will cause you to miss all updates from this day on. And if you changed 

something it is a hell of a job to insert these changes in the current version. 

5 von 16 30.08.2011 17:24


Server version 

For most users located at the ITM, the best way to call Neweul-M² is to use the 

server version. If you already have a model or just don't need the examples all 

you have to do is type 

addpathNeweulm2 

This is a file available in your search path, which will make sure all necessary 

files are available. This basically is an abbreviation of the command 

addpath(genpath('/home/itm/itmsw/neweulm2/currentVersion/neweulm2/')); 

This makes all functions available for you. If you don't want to have to remember 

this, you can add this line to the file ~/matlab/startup.m which executes at 

each start of Matlab. 

If you are using the Matlab command restoredefaultpath, you will need to 

specify the path again explicitly. 

When using the server version you can store the model folders with your input or 

simulation data and all the routines can stay on the server. Like this you will not 

be able to change anything at the code, but can edit and create models in your 

local folder. You can find this version at /home/itm/itmsw/neweulm2 

/currentVersion/ (Before renaming /home/itm/itmsw/symbs/symbsServer/). This 

folder contains a complete set of all files. The best way to start is to copy the 

examples folder to your account or a scratch partition on your PC. Then you can 

have a look at prepared examples and adjust them to your needs. You can do this 

by opening a shell, changing to the desired folder in your account and enter the 

following command: 

cp -r /home/itm/itmsw/neweulm2/currentVersion/examples/ . 

By this you will get a few examples, both for input files and for the graphic user 

interface (GUI). In the folder sandbox/ you will find a file called Readme.txt 

giving you an explanation on how to get started. To start the GUI, please call the 

file link_neweulm2.m in Matlab, which you find in the sandbox/ folder. 

Local version 

If you want to change the routines of Neweul-M² or extend the functionality, e.g. 

for your research paper, you need a local copy. For this please follow the 

following steps: 

1.) Please contact your system administrator in order to get the necessary 

6 von 16 30.08.2011 17:24


permissions. 

2.) Open a shell (also called Console) and change to the folder, where you want 

Neweul-M² in and type the following command. This will create a new folder 

called "neweulm2_local" containing all files. Then you are ready to go. In this 

newly created folder you will find a file called "Readme.txt" containing 

information on how to start Neweul-M² from Matlab. 

git clone itmgit@itmserver1.itm.uni-stuttgart.de:neweulm2.git 

If you are asked for a password of itmgit, probably something went wrong with 

step one. 

At the beginning of each modeling with commands it has to be ensured that the 

routines of Neweul-M² are available by adding the necessary path. If you 

received a copy of Neweul-M² and did not change too much in the directory 

structure, you can also use the file 


This is usually located at examples/addpathNeweulm2 and should cover most 

cases of where your neweulm2/ directory is located. Otherwise, please type help 

addpathNeweulm2 for information on how to specify the path manually. 

An explanation on how to use GIT can be found here: Git - Distributed Version 

Control. To use a GIT-command, open a shell and change to the directory, where 

your local copy is located. The most important command, which should be called 

from time to time is 

git pull 

which will update your local copy with the files from the server. If you changed 

some files, which were changed on the server as well, GIT will tell you that and 

ask you to resolve these conflicts. 

If you programmed some new functions or made other improvements you want 

to share with the other users please contact Thomas Kurz. 

Starting Matlab 

Neweul-M² is running under Matlab. At the institute there are several versions of 

Matlab available, which can be seen, when opening a Command Shell, typing 

'matlab' and hitting the [Tab] Key twice. The program should run without 

problems in all versions starting with 'matlabR20', while there are some known 

problems in lower versions up to '7.2'. If unsure which version to use, just call 

7 von 16 30.08.2011 17:24


matlab which usually opens the newest version. 

Neweul-M² - neweulm2 - SYMBS - 

NEWEUL 

The multibody program described here, started under the name SYMBS. After 

it appeared to be quite promissing it has been renamed to Neweul-M². This 

name is meant to underline that this program is successor of the FORTRAN 

Code called NEWEUL. Because of this, some misleading names may occur. The 

M² is a tribute to its two used math programs MATLAB and Maple. As the 

name Neweul-M² contains non-standard characters its function call is 

neweulm2, which is also used for the wiki pages here. 

For HTML pages: The sign ² has the ASCII-Code &# 178; without the space. 

For LaTeX documents: it is most convenient to add this line to the Master 

document 

\newcommand{\neweulm}{\mbox{Neweul-M$^2$}} 

Then the correct name is achieved by typing \neweulm{} in the document, 

where the brackets {} are necessary to ensure the correct spacing. 

Release notes 

Some information on important new features can be found here: neweulm2 - 

Release notes 

At each version you will find a file, which is called VersionLogfile.txt or 

previously symbs_CVS_Logfile.txt, which contains a more detailed decription of 

the changes. 

Available Models 

To get started with the program there are some easy models available: 

Double Pendulum (directory: double_pendulum) 

Slider Crank (directory: slider_crank) 

Elastic Pendulum (directory: elasticPendulum) 

Half-car model (directory: car_half) 

An inverse modeled slider crank (directory: slider_crank_inverse) 

8 von 16 30.08.2011 17:24


An example to demonstrate different force elements (directory: 

testForceElements) 

The first three models are very good to get to know the software. You can 

observe which files are in use, how to define different modeling elements, how 

to set up equations and how to start simulations. The other three models have a 

slightly different aim and are not as clearly documented as the first three. The 

half-car is a fairly realistic model especially containing state dependent 

parameters to model nonlinear springs. The inverse modeled slider crank has 

the main goal to investigate different modeling techniques for systems with 

constraint equations on a model with distinct singular configurations. The last 

model-directory offers different models to investigate the behavior of force 

elements. All of these models are also used for automated testing, which should 

help to detect errors in the software. 

When during a student research paper or some other non-confidential project a 

model is created it will be put in the following folder 

/home/itm/itmsw/neweulm2/models/ 

The goal of this is to make more complex models available for the rest of the 

users. Also this is meant as a kind of knowledge base, e.g. if you want to know 

how to use flexible bodies, gradients or some other feature, you find some 

examples there. 

To upload a model into this folder, you should make sure that it is running 

under the current version. There is no guarantee that they are up to date, so 

some adjustments may be necessary before they run properly. Please insert a 

README.txt in each model folder with a short description of the model, which 

also contains the name of the printed research paper. Depending on the size and 

mode of creation this folder should contain: 

sysDef.m 

setUserVar.m (if numeric values were not set in sysDef.m) 

defineGraphics.m 

The folder userFunctions/ with all necessary functions for time- and statedependent 

parameters. 

Any file to run a simulation tested by you, e.g. runTimeInt.m 

Optionally a .mat and .fig file of the saved system. Please check the size of 

it before copying it there and maybe remove all results from the structure. 

It should not contain 

Badly commented files 

Files which produce errors even under the then current version. 

9 von 16 30.08.2011 17:24


Analysis results 

Structure of the Software 

The software consists of two main parts, one for the definition of the system and 

the derivation of the equations of motion, the other one provides functions for 

the numerical analysis, simulation and optimization of multibody systems. All 

files building the software are stored in a directory called neweulm2, the modelspecific 

data is stored to a separate model directory. It contains all files being 

necessary for the system's definition and performing simulations. The user is 

welcome to edit these files to his needs. In detail, these are 

File / Directory 

Contents of each model folder 

Directory containing functions for numerical evaluation 

of the equations of motion and kinematic values. The 

sysFunctions/ 

contents of this folder are written and removed 

automatically as necessary. 

Directory containing functions for numerical evaluation 

of userdefined variables. The files in this folder are 

userFunctions/ created automatically and adjusted if necessary. 

However, they are not deleted and the user is asked to 

adjust those files to his needs. 

Definition of graphical representation of bodies, see 

defineGraphics.m 

Neweulm2_-_Simulation_and_Animation#Animation 

Script for initializing parameter optimizations, see 

initOpt.m 

Neweulm2 - Simulation and Animation 

Reference solution used for automated testing, of no 

referenceSolution.mat 

interest to common user and not necessary 

Script to run a kinematic analysis, where you prescribe 

a function for all independent generalized coordinates, 

runKian.m 

see Neweulm2_- 

_Simulation_and_Animation#kinematicAnalysis 

Script to perform a modal analysis of the linearized 

system, if available the symbolic linearization is used, 

runModalAnalysis.m 

otherwise a numerical linearization is attempted, see 

Neweulm2_-_Simulation_and_Animation#modalAnalysis 

Script to set options and run a time integration, see 

runTimeInt.m 

Neweulm2_-_Simulation_and_Animation#timeInt 

setUserVar.m 

(optional) 

Definition of values of constant user-defined variables, 

can be done in sysDef.m instead 

10 von 16 30.08.2011 17:24


startSysDef.m 

sys.fig (optional) 

sys.mat (optional) 

sysDef.m 

Script for system definition, derivation of equations of 

motion and initialization of the animation window. 

This is the file to start with as a new user 

Graphical representation of system for animation 

Stored system data structure 

Complete system definition, see Neweulm2 - System 

Definition 

Before running simulations, the system has to be defined and the equations of 

motion have to be derived. All necessary steps for this are summarized in the 

script startSysDef. In older versions, these tasks had been split up in two files. 

But the functionality of the file initSys.m has been included in startSysDef.m. In 

detail, these are 

Call 

Action 

addpathNeweulm2 Initialization of software environment 

Definition of multibody system, see neweulm2_- 

sysDef 

_System_Definition 

Derivation of nonlinear equations of motion, see 

calcEqMotNonLin 


Calculation of reaction forces, optional, see 

calcForcesReaction Neweulm2_- 

_Equations_of_Motion#calcForcesReaction 

Generation of matlab-functions for numerical 

writeMbsNonLin evaluation of nonlinear equations of motion (stored in 

sysFunctions/), see writeMbsNonLin 

Linearisation of equations of motion, optional, see 

calcEqMotLin 

calcEqMotLin 

Generation of matlab-functions for numerical 

writeMbsLin 

evaluation of linearised equations of motion, optional, 

see writeMbsLin 

Assignment of numerical values to constant 

setUserVar 

parameters, if not done directly in sysDef.m 

createAnimationWindow Initialize or recreate the animation window 

Specify graphic representations for modeling 

defineGraphics 

elements like bodies or force elements 

Storing model data structure in sys.mat 

11 von 16 30.08.2011 17:24


After these steps the system will be fully defined and ready for simulations. 

Neweul-M² offers many possibilities to perform simulations and analysis of the 

system, see neweulm2 - Simulation and Animation. 

Graphical User Interface 

A graphic user interface (GUI) can be found in neweulm2/gui/ and has been 

created with the Matlab GUI layout editor guide. It is created not independently 

but as a front-end to the existing version, which is controlled by input files. 

Therefore, it calls the same functions for the actual modeling and simulation. 

There are different ways to start it. If you've just started Matlab the best is to 

move to the folder examples/sandbox/ and run the file link_neweulm2.m. 

This will then set up the Matlab path so the file neweulm2.m and 

startneweulm2.m in the folder neweulm2/gui/ are found. There is a small 

difference between these two files. 

When you call startneweulm2.m, the workspace is cleared, figures are closed 

and the gui is started. This means you are ready to go, but your workspace is 

empty. When running link_neweulm2.m also this startneweulm2 is called. If 

still this is not convenient for you, you can call the function 

writeneweulm2link.m after starting the GUI. This will create a file also called 

link_neweulm2.m, but this time with the absolute path stored inside, therefore 

making it possible to start the GUI from any given folder. Many of the input files 

can be created from the GUI under the menu entry Export System to ensure 

compatibility in both ways. 

When you call neweulm2 directly the workspace as well as all figures are kept 

and only the GUI is started. Therefore, this presents the easiest way to switch 

from input files to the GUI. You simply run the input files, type neweulm2 and 

then you can work on the current model. Also, you can type Neweul-M² 

commands or close the GUI at any time and continue working solely with 

commands. With the only exception that, if you select Exit from the File menu, 

then the workspace will be cleared. In order to keep the model you should select 

Close Menu or click on the little cross in the upper right corner. 

Another way of switching the way to control Neweul-M² is to save your model as 

a .mat file and load it in the other mode. Sometimes it happens that strange 

errors occur when some elements like bodies are deleted in the GUI. If that is 

the case, simply open Export System from the File menu and create the Input 

files. This will create one file containing all definitions which can be used to 

easily rebuild your model from scratch. 

Help 

There are a few possibilities on how to get help on neweulm2, before asking 

12 von 16 30.08.2011 17:24


someone, see #See also. 

ZB-149: This was the first documentation of Symbs and marks the first 

appearance. 

Readme.txt: In each version of Symbs contains a Readme.txt which 

explains the most important things. 

VersionLogfile.txt or formerly symbs_CVS_Logfile.txt: This is a log-file of 

all files that changed during the evolution of Symbs/Neweul-M². If you're 

not sure which version you run, check this file. 

Online help in the GUI: In each window of the GUI you will find a button 

labeled [?] which will display a help if there is one available. These help 

messages are stored in the folder neweulm2/gui/Definition/ in a file called 

neweulm2HelpMsgs.m. 

This wiki: This is the most extensive ressource on Neweul-M². From time to 

time I export the contents of this wiki to a pdf-file, which can be found 

under 

/home/itm/itmsw/neweulm2/currentVersion/NeweulM2_Manual.pdf 

If you already know something about the possibilities of Neweul-M² and just 

need a very short summary of the main commands and the their options, 

you may want to look at our cheat sheet (http://www.itm.uni-stuttgart.de 

/itmwiki/wikidata/cheatSheet.pdf) . 

If you think there are some important things missing or could be explained 

better in any of the still updated help channels, please help! Edit the entries in 

this wiki, edit/change/create any help you think you can improve and send it to 

the current supervisor of Neweul-M²! 

There will be other users after you and probably they will encounter the 

same problems if you don't fix them! 

Function reference 

Structure of the documentation 

Experience showed that a wiki is a great vehicle to keep the documentation of a 

software project up to date. This bases on the fact that many people can update 

and extend it. Still every single file, function and subfunction is to receive a 

header containing information which can be accessed via Matlab's help 

command or the F1 key. It is not helpful for anyone to store documentation 

redundantly, because then usually one source will be out of date. 

13 von 16 30.08.2011 17:24


Contents of this wiki 

A wiki provides an easy overview over available functions, the structure of the 

software and comments on how to start. This makes it the place e.g. for the 

step-by-step tutorials. In a wiki, pictures, formated text and formulae can be 

easily displayed, which is very useful, e.g. for the detailed explanation of applied 

forces. So the wiki shall provide the following contents: 

overview over the software and implemented features 

step-by-step introduction 

current changes and new features 

references to how the theory works or where you can get further 

information 

detailed explanations of topics too long or too complicated for the help 

section in a function 

Contents of the function help header 

As it is contained right inside the actual function, a short description of its 

purpose and functionality have to be contained. This is also the easiest location 

to keep information about in- and output arguments up to date. Therefore, these 

things together with all possible options are to be documented there. Each 

function's help message shall provide the following contents: 

Syntax of the function call 

what are available options and how to choose them 

what are the data types going in and coming out of the function 

standard values if you don't specify options 

contained subfunctions and links to related functions 

general information like the system data structure, file creation, ... 

Overview over the wiki documentation 

A more detailed description of the different functions can be found here: 

neweulm2 - System Definition 

neweulm2 - Equations of Motion 

neweulm2 - Simulation and Animation 

neweulm2 - Exporting 

Or a neweulm2 - List of files is available to search in the other direction, by file 

name. 

There is a list of Frequently Asked Questions neweulm2 - FAQ. However, they 

are not intended to get into the software but to help when you started 

14 von 16 30.08.2011 17:24


successfully and are now facing some problems. 

Notes for programers 

If you want to contribute to Neweul-M², please feel free to do so. On the 

following page you can find a few hints on how you can make your program fit 

to all the rest. neweulm2 - Programming tips 

See also 

ITM Wiki 

Explanation of the functions 

Function reference: Search by topic 





neweulm2 - List of files: Search by filename 

Other topics 

Neweulm2 - Getting Started: Step by step explanations for simple examples. 

neweulm2 - FAQ: Frequently asked questions and some tips that just don't 

fit in other categories. 

Neweulm2 - Release notes: Short summary of every change. 

ITM Server 

PDF Export of these Wiki pages: 

/home/itm/itmsw/neweulm2/currentVersion/info/Neweulm2_Manual.pdf 

STUD-344: Untersuchungen zur Auslegung und Realisierung eines 

Parallelkinematik-Prüfstands, 2010. 

/home/itm/institut/studdipl/STUD/STUD_344_FelixGeibel/stud_344.pdf 

STUD-338: Erweiterung von Neweul-M² um die Berechnung von 

Reaktionskräften, 2010. 

/home/itm/institut/studdipl/STUD/STUD_338_BernhardFeistle/stud_338.pdf 

STUD-323: Programmvergleich für die Simulation elastischer 

15 von 16 30.08.2011 17:24


Mehrkörpersysteme, 2010. 

/home/itm/institut/studdipl/STUD/STUD_323_BernhardZeumer/stud_323.pdf 

STUD-309: Kosimulation von Tankfahrzeugen mit Neweul-M² und Pasimodo, 

2009. 

/home/itm/institut/studdipl/STUD/STUD_309_FrankSandner/stud_309.pdf 

STUD-292: Implementierung flexibler Mehrkörpersysteme in 

MATLAB/SIMULINK auf Basis von Neweul-M², 2008. 

/home/itm/institut/studdipl/STUD/STUD_292_MarkusBurkhardt 

/stud_292.pdf 

DIPL-122: Entwicklung eines Optimierungsmoduls mit Sensitivitätsanalyse 

für die symbolische Mehrkörpersimulationsumgebung SYMBS, 2007. 

/home/itm/institut/studdipl/DIPL/DIPL_122_ThomasKurz/dipl_122.pdf 

STUD-263: Erstellung einer symbolischen 

Mehrkörpersimulationsumgebung in MATLAB mit graphischer 

Benutzeroberfläche und verschiedenen Schnittstellen, 2007. 

/home/itm/institut/studdipl/STUD/STUD_263_MarkusLutz/stud_263.pdf 

ZB-149: SYMBS eine Matlab-Umgebung zur Simulation von 

Mehrkörpersystemen, 2007. 

/home/itm/institut/studdipl/ZB/ZB_149_Henninger/symbs_doku.pdf 

Literature 

W. Schiehlen, P. Eberhard: Technische Dynamik. Wiesbaden: Teubner, 

2004. 

Retrieved from "http://www.itm.uni-stuttgart.de/itmwiki/index.php/Neweulm2" 

This page was last modified 11:15, 26 August 2011. 

16 von 16 30.08.2011 17:24

Neweulm2 - Getting Started Preparations - IT M Wiki 

Neweulm2 - Getting Started 

Preparations 

From ITM Wiki 

If you are using the server version at the ITM, please enter the following 

commands in the console: 

cp -r /home/itm/itmsw/neweulm2/currentVersion/examples/ $HOME/ 

cd $HOME/examples/ 

matlab & 

This will copy the examples folder from the server to your home directory, 

change to this folder and start matlab. If you are using Neweul-M² outside of the 

ITM or a local version, please start matlab and move to the directory where your 

copy of the software is stored and go into the directory called examples. From 

now on, all commands should be entered directly in the Matlab command 

window. 

An initialization of the search path is necessary by typing: 


This command usually finds all necessary files by itself. You will only get a 

response if there has been any problem. When setting up a model and 

performing some simulations, the software has to store some files. Therefore it 

is very convenient to create separate folders for each model you want to keep. If 

you only want to try some things, e.g. like the getting started examples, you 

could use the sandbox folder instead. So if you want to continue with the 

Getting-Started, we recommend to change to the sandbox folder. 

cd sandbox 

The next time you want to use Neweul-M², you just have to change to the correct 

folder (e.g. cd $HOME/examples/sandbox) again and start Matlab by yourself 

and call addpathNeweulm2. 

Here is a link to a list of all Getting Started Examples. 

Retrieved from "http://www.itm.uni-stuttgart.de/itmwiki/index.php/Neweulm2_- 

_Getting_Started_Preparations" 

1 von 2 01.09.2011 15:24

Neweulm2 - Getting Started Preparations - IT M Wiki 


2 von 2 01.09.2011 15:24

Neweulm2 - Getting Started SinglePendulum - IT M Wiki 


SinglePendulum 

From ITM Wiki 

Contents 

1 Single pendulum 

1.1 System definition 

1.2 Setting up the equations of motion 

1.3 Time integration 

1.4 Display and interpretation of results 

1.5 Additional information and help 

1.6 Commands learned in this example 

1.7 Links 

Single pendulum 

Please make sure that you performed the General Preparations before starting 

with this example. 

In the first example we will show you how to use the Matlab command window to 

generate a pendulum model with a minimum number of parameters in 

Neweul-M². The commands can be typed directly within the command window of 

matlab so that we can get the desired results. 

System definition 

With the command 'newSys' you define a new multibody system. 

newSys 

The system, which shall be set up is shown in the following sketch 

1 von 7 01.09.2011 15:25


Figure 1 Sketch Single Pendulum 

The following command 'newUserVarKonst' defines constants used in the 

system such as the length of the pendulum 'L' and the mass of the pendulum 

body 'm1'. These constants get numerical values assigned at this point, 0.5 for 

'L' and 0.6 for 'm1', even though these numerical values will be used in later 

steps. The symbolic parameters can be accessed in the equations of motion. 

newUserVarKonst('L',0.5,'m1',0.6) 

As the software cannot associate the variable names to a physical meaning like a 

length or mass, the numbers are without units. Therefore the user should decide 

on a set of units, e.g. SI-Units like m, kg, s, which then should be used 

consistently to avoid problems. To create a new generalized coordinate we use 

the command 'newGenCoord'. In this example this would be the pendulum 

angle 'alp'. 

newGenCoord('alp') 

After these preparatory steps the system can be specified. This starts by 

defining a body, which can be adjusted by many parameters. In this example, we 

only need three parameters for this body: 

2 von 7 01.09.2011 15:25


1. 

2. 

3. 

the rotation around the y-axis relative to the inertial reference frame with 

the generalized coordinate 'alp': 'RelRot','[0;alp;0]' 

the relative position of the center of gravity: 'CgPos','[0;0;-L]' 

the mass of the body: 'Mass','m1'. 

newBody('RelRot','[0;alp;0]', 'CgPos','[0;0;-L]','Mass','m1') 

Setting up the equations of motion 

Now, as the single pendulum has already been defined completely, we can 

generate the nonlinear equations of motion using the command 

'calcEqMotNonLin'. The data is then stored in the global structure 'sys' and 

can be accessed there. 


To write files for the numerical evaluation of these nonlinear equations of 

motion, the function 'writeMbsNonLin' is called. 

writeMbsNonLin 

To perform the simulation, numerical values are necessary. To show how this 

can be done at the current state, we change the pendulum length 'L' to 0.8 by 

the command 

sys.userVar.data.L = 0.8; 

The last command was only used to demonstrate how to change a parameter 

value. Of course, the value could be set correctly right at the definition of the 

variable. 

Time integration 

Now we can perform the time integration. Therefore the initial condition 'y0 = 

0.5' has to be set. Now we can start the time integration with the command 

'timeInt(y0)'. All optional parameters are kept to their default values. 

y0 = 0.5; 

result1 = timeInt(y0) 

The results are stored in the data structure 'result1'. We can then start another 

time integration with other initial conditions such as 'y0_2 = 3.05'. The new 

3 von 7 01.09.2011 15:25


results are saved in the data structure 'result2'. 

y0_2 = 3.05; 

result2 = timeInt(y0_2) 

Display and interpretation of results 

The results can be displayed using the following command: 

plot(result1.x,result1.y(1,:),'b',result2.x,result2.y(1,:),'r') 

Fig. 1 time diagram pendulum angle 

We can see in the spartan illustration above (Fig. 1) the system states with two 

different lines, which correspond to the two different initial conditions. 

We can see different frequencies and realize an increasing nonlinearity for large 

values of the initial angle of the pendulum. 

Additional information and help 

Neweul-M² offers several other possibilities and options. For example we can call 

the help function related to 'newSys' using the command 'help newSys'. Then 

information about this function and possible parameters is displayed. 

4 von 7 01.09.2011 15:25


help newSys 

By typing the command 'sys.eqm.qa' we can display the elements of the applied 

forces. This is a cell array, referenced by curly braces {}, which contains one 

vector for each body. In our case, we have only one entry, which consists of the 

three elements for the translation and three elements for the rotation, resulting 

in a 6x1 vector. 

sys.eqm.qa{1} 

If we were to start a time integration without specifying where to store the 

results 

timeInt(y0) 

They are stored at the default location sys.results.timeInt. This is very useful, as 

we could plot the generalized coordinate by typing 

plotStandardResults 

The advantage of this is that we don't have to worry about storage location or 

dimensions, as this is done automatically. If you stored the results at the default 

location, and you want to see an animation, you only need to type 

createAnimationWindow 

which will create an animation window and start the animation with the 

command 

animTimeInt 

In order to store this model, you only need to save the system data structure 

save pendulum.mat sys 

You can easily load the model, e.g. after a restart, by typing 

load pendulum.mat 

We are now at the end of the first demonstrative example. The following system 

5 von 7 01.09.2011 15:25


will be more complicated and we will use the graphical user interface (GUI). The 

purpose of the first example was to introduce you to how to use the command 

window to build and simulate a simple model. 

Commands learned in this example 

The following commands were used and shortly explained in this example: 

Command Type Purpose 

addpathNeweulm2 Neweul-M² Adjust the search path of Matlab 

animTimeInt 

Neweul-M² Animate a result 


Set up symbolic nonlinear equations of 

Neweul-M² 

motion 

createAnimationWindow Neweul-M² Create a new animation window 

newBody 

Neweul-M² Define rigid or elastic body 

newGenCoord 

Neweul-M² Define generalized coordinate 

newSys 

Define a new multibody system, clears the 

Neweul-M² 

data structure sys 

newUserVarKonst Neweul-M² Define a constant symbolic parameter 


Provide plots of interesting curves from 

Neweul-M² 

results 

timeInt 

Perform numerical time integration of the 

Neweul-M² 

system 


Write files of the nonlinear equations of 

Neweul-M² 

motion for numerical evaluation 

help Matlab Show help information 

load Matlab Load data from a .mat file 

plot Matlab Manually plot given data 

save Matlab Save variables to a .mat file 

Links 

Restart this example 

Next example: Double Pendulum 

Back to the Neweul-M² Page 

List of all examples. 


_Getting_Started_SinglePendulum" 

6 von 7 01.09.2011 15:25



7 von 7 01.09.2011 15:25

Neweulm2 - Getting Started DoublePendulum - IT M Wiki 


DoublePendulum 

From ITM Wiki 

Contents 

1 Double pendulum 

1.1 System definition (GUI) 

1.2 Setting up the equations of motion (GUI) 

1.3 Time integration and plot of states 

1.4 Graphic objects for the animation 

1.5 Linearization of the equations of motion 

1.6 Saving 


1.8 Links 

Double pendulum 

In this second example we will build a more complicated model of a double pendulum. The 

graphical user interface (GUI) of Neweul-M² will be used. If you skipped the first example, 

you might want to have a look at the Preparation section first. This mainly consists of moving 

to a suitable folder and setting the path variable as explained above. The path is usually set 

by calling 


To discard all existing data and close all figures, type 

clear all 

close all 

To start the GUI we have to type the command 

neweulm2 

System definition (GUI) 

To build a new system, please click in the menu 'File' on 'New System', see Fig. 1. A new 

window will be displayed, where we can input several options such as the name of the 

system, its identification and the gravity vector. A new data structure will be generated to 

store the model variables. 

1 von 15 01.09.2011 15:25


Fig. 1 Modeling a new system with Neweul-M² 

You will be asked to generate a new directory to store the model, click on 'Create New'. 

Now we can see in the GUI additional menus like, 'Model', 'Equations of Motion', 'Post 

Processing' and the help '?'. The animation window in Fig. 2 will be displayed and we can 

see the inertial frame of reference 'ISYS'. 

Fig. 2 Main menu and animation window 

The system, which shall be set up is shown in the following sketch 

2 von 15 01.09.2011 15:25


Fig. 3 Sketch Double Pendulum 

Now we want to model the bodies of the double pendulum. For this purpose we open the 

menu 'Model', select 'Bodies' and click on 'Create New'. A new body will be generated and 

we can input its properties. For most of the parameters we will keep the default values. The 

first pendulum body rotates with the angle 'alp' around the y-axis relative to the inertial 

frame of reference. It has the mass 'm1' and the moment of inertia 'I22' around the y-axis. 

The pendulum center of gravity of this body is translated by '-L1' in the z-axis direction 

relative to the body fixed reference frame 'mass1', see Fig. 4. 

3 von 15 01.09.2011 15:25


Fig. 4 Body model 

By clicking on the button 'Parameters' you will have the possibility to define new symbolic 

parameters like the first body mass 'm1' with the value 0.6. However, it is more comfortable 

to simply click the OK button and accept the warning window. Then automatically the 

Parameters window will open, then showing a list of all parameters to be defined, see Fig. 5. 

Please define all variables now. The length of the pendulum 'L1' has the value 0.5 and the 

moment of inertia 'I22' has the value 1. The angle 'alp' is defined as a generalized coordinate. 

The generalized coordinate 'bet' for the second body can be defined now or when creating 

the second body. 

4 von 15 01.09.2011 15:25


Fig. 5 Definition of new parameters 

Parameter Value Type 

m1 0.6 constant 

L1 0.5 constant 

L2 0.8 constant 

I22 1 constant 

alp - generalized coordinate 

bet - generalized coordinate 

Now all constants and generalized coordinates are defined and we can close both windows by 

clicking the 'OK' button, which finishes the definition of mass1. 

Now we want to add a second pendulum body using the same inertial properties like the first 

body. A new generalized coordinate 'bet' has to be defined for the second degree of freedom. 

The second body rotates with the angle 'bet' around the y-axis relative to the body fixed 

frame of reference 'mass1_cg', see Fig. 6. This refers to the selection of the Reference 

System at the top right of this window. 

5 von 15 01.09.2011 15:25


Fig. 6 Second pendulum body 

Let us have a short look at the naming of the coordinate systems. In Fig. 7, we can see the 

first pendulum called mass1, being a rigid body. Each rigid body consists of at least two 

coordinate systems. The so called primary system, having the same ID as the body itself, 

here mass1 is located at the top and in our model can only rotate with respect to the inertial 

frame ISYS. The primary system is usually one of the support points of the body as shown 

here. For each rigid body, the center of gravity has to be specified, which is denoted by 

having an ID like the body with a trailing _cg. Its position and orientation can be 

conveniently defined in the primary system. If necessary, additional coordinate systems can 

be defined, e.g. to attach force elements or other bodies. 

6 von 15 01.09.2011 15:25


Fig. 7 Sketch of a rigid body with coordinate systems 

Setting up the equations of motion (GUI) 

At this point we have already built our model and we can close the window by clicking on 

'OK'. The model is now ready and we can generate the nonlinear equations of motion. For 

this purpose we should select 'Nonlinear Equations of Motion' in the menu 'Equations of 

Motion', see Fig. 8. In the Matlab window we can see some information about the 

progressing calculation. 

Fig. 8 Calculation of the nonlinear equations of motion 

7 von 15 01.09.2011 15:25


Time integration and plot of states 

The Simulation can now be performed by selecting 'Time Integration' in the menu 

'Simulation'. We have to define the initial conditions. The first generalized coordinate 'alp' 

has the value 0.3 and the second one 'bet' is set to 0.5. There are several options such as 

error tolerances and integration algorithms. In this example all options are set to their 

default settings, see Fig. 9. We can now start the time integration by clicking 'OK'. 

Fig. 9 Time Integration window 

Figure 10 displays the animation window, where we can see moving frames of reference. 

However we can not see graphical objects, which will be added in the following steps. 

8 von 15 01.09.2011 15:25


Fig. 10 Animation window 

We can display the trajectories within the menu 'Post Processing', selecting the item 

Simulation Results. There is also the possibility to display the system states by selecting 

States and clicking on the button 'Plot'. We can see in Fig. 11 the time characteristic with 

four different lines, which represent both degrees of freedom and their derivatives. In the 

following steps, we are going to perform other analyses. 

9 von 15 01.09.2011 15:25


Fig. 11 Time Diagram States 

Graphic objects for the animation 

Now we can add some graphical objects. For this purpose we should open the menu 'Model' 

and select 'Graphic Objects'. A window will be displayed, where we can see different types 

of graphical objects. At each center of gravity one sphere shall be attached and each 

pendulum shall be represented by a line connecting the two coordinate systems of each 

body. 

In the 'Properties' frame, select the 'Type' as Sphere. To assign a graphical object to a body 

we should select a frame of reference, in the current example 'mass1_cg'. Set the Radius to 

0.05 and click on the Apply button, see Fig. 12. We can repeat the same procedure for the 

second pendulum body by selecting the body fixed frame 'mass2_cg'. The added objects are 

immediately displayed in the animation window. 

10 von 15 01.09.2011 15:25


Fig. 12 Create a sphere 

We also have the possibility to add dynamic lines, which can represent for example springs 

or dampers, or in this case the connection of the two coordinate systems of each body. Please 

select the 'Type' to be Line and then click the radio button labeled Dynamic/Spline. As you 

can see this user interface changes the labels of the fields according to the graphic object to 

be created. As this line shall connect the coordinate systems mass1 and mass1_cg, both ids 

have to be written in the field List of coordinate systems. You can select them in the 

drop-down-box and click 'Add frame' or write them in manually. When entering them it 

doesn't matter if you insert a comma, semicolon or simply spaces. After clicking Apply you 

can repeat this for the second body as well, see Fig. 13. 

11 von 15 01.09.2011 15:25


Fig. 13 Create a sphere 

The whole assembly is displayed in Fig. 14. 

12 von 15 01.09.2011 15:25


Fig. 14 Double Pendulum 

Linearization of the equations of motion 

To linearize the system we should select 'Linear Equations of Motion' in the menu 

'Equations of Motion'. Consequently the linear equations of motion are generated. We 

would like to perform a modal analysis. For this purpose we click on 'Modal Analysis' in the 

menu 'Simulation'. A new window will appears, where we can input several settings such as 

scale factor and transparency of mode shapes. To confirm the settings please click on 'OK'. 

Two windows are displayed, where we can recognize the first mode shape with a frequency 

of 0.25 Hz, the antisymmetrical mode has a higher frequency of 0.34 Hz, see Fig. 15. 

13 von 15 01.09.2011 15:25


Fig. 15 Mode shapes 

We can have a look at the elements of the equations of motion, which are all stored under 

'sys.eqm', but depending on what options have been chosen, these entries may be different. 

These options can be accessed via 'Post Processing', 'System Information', 'Parameter 

Settings'. The symbolic expressions for the linearized equations of motion can be found 

under sys.lin.eqm. However, in order to find, e.g. the stiffness matrix Q there, you would 

have to use the just described graphical user interface to set the parameter formulation to 

minimal before setting up the linear equations of motion. 

Saving 

In the next example kinematic loops and force elements are going to be added. The model 

should be stored under the name 'Doppelpendel' by selecting 'Save System' in the menu 

'File'. 




addGraphics 

Attach a graphical representation to a coordinate 

Neweul-M² 

system 


14 von 15 01.09.2011 15:25


animTimeInt 


calcEqMotLin 

Symbolically linearize the previously calculated 

Neweul-M² 

nonlinear equations of motion 

calcEqMotNonLin Neweul-M² Set up symbolic nonlinear equations of motion 


drawLine 

Draw a line, connecting two coordinate systems in the 

Neweul-M² 

animation window 

drawSphere 

Neweul-M² Draw a sphere in the animation window 

newBody 


newGenCoord 


newSys 

Define a new multibody system, clears the data 

Neweul-M² 

structure sys 


plotStandardResults Neweul-M² Provide plots of interesting curves from results 

timeInt 

Neweul-M² Perform numerical time integration of the system 

writeMbsLin 

Write files of the linear equations of motion for 

Neweul-M² 

numerical evaluation 


Write files of the nonlinear equations of motion for 

Neweul-M² 

numerical evaluation 



Links 


Next example: Slider Crank 




_Getting_Started_DoublePendulum" 


15 von 15 01.09.2011 15:25

Neweulm2 - Getting Started SliderCrank - IT M Wiki 


SliderCrank 

From ITM Wiki 

Contents 

1 Slider crank 

1.1 Load system 

1.2 System definition: force element, loop 

1.3 Time integration with kinematic loop 

1.4 Static Equilibrium 


1.6 Links 

Slider crank 

In this third example we are going to add a kinematic loop to the double pendulum 

above. This means that the ordinary differential equations of motion will be 

changed to algebraic differential equations. We will show you also how to add a 

force element and how to calculate the static equilibrium. If you skipped the 

previous example, you might want to have a look at the Preparation section first. 

This mainly consists of moving to a suitable folder and setting the path variable as 

explained above. 

Load system 

For this purpose let’s call the GUI and from the menu 'File' select 'Load System'. 

The previous example (double pendulum) should be opened. 

System definition: force element, loop 

To add a force element we should select from the menu 'Model' the entry 'Force 

Elements', see Fig. 1. 

1 von 9 01.09.2011 15:26


Fig. 1 Force Element 

By clicking on the button 'Create New' a new window is opened where force 

elements can be defined, see Fig. 2. We can see here several types of elements. In 

this example we will use a componentwise spring-damper-combination. For this 

purpose click on 'SpringDampCmp' The torsional spring acts in the second axis 

and has the stiffness 'k1' with the value 4, the damping constant 'd1' with the 

value 0 and the nominal length 'alpha0' equal to 1. These parameters have to be 

defined as shown before. Now we should select the coordinate systems where this 

force element acts. In this example it’s 'mass1_cg' and 'mass2'. Click on 'OK' to 

end the procedure. 

2 von 9 01.09.2011 15:26


Fig. 2 Definition of Force Element 

The second modification is to add a kinematic loop. The mass 'm2' should move 

along a straight line. Let’s go to the menu 'Model' and select 'Kinematic Loops'. 

We can see several options. By selecting 'New Loop' we can generate a constraint 

between the coordinate systems 'ISYS' and 'masse2_cg', see Fig. 3. The 

constrained degree of freedom is the z-component. 

3 von 9 01.09.2011 15:26


Fig. 3 Kinematic Loop 

To calculate the equations of motion, click on 'Nonlinear Equations of Motion' 

in the menu 'Equations of Motion'. 

Time integration with kinematic loop 

Now we can start the simulation by selecting 'Time Integration' in the menu 

'Simulation'. We have to select the dependent degree of freedom, since after 

adding a kinematic loop the degrees of freedom are no more independent. In this 

case let’s select 'alp' as independent degree of freedom, see Fig. 4. By clicking on 

'OK' we confirm the selection. 

4 von 9 01.09.2011 15:26


Fig. 4 Dependent generalized coordinates 

To perform the time integration we should select an integrator, which is 

appropriate for differential algebraic equations. Let’s select 'ode15 s', see Fig. 5. 

Now we have to define the initial conditions. The first degree of freedom 'alp' is 

set to 0.8, the second 'bet' is set to -0.8. The provided initial conditions are 

automatically used to numerically calculate consistent initial conditions. This is 

necessary so the initial conditions fulfill all constraint equations. We can start the 

simulation by clicking on 'OK'. The animation is displayed and we can observe that 

the coordinate system 'mass2_cg' is moving along a straight line with the 

condition: z = 0. 

5 von 9 01.09.2011 15:26


Fig. 5 Integration with kinematic loop 

At this point we can change some model parameters such as the spring stiffness 

'k1' and integrate again. We can see an oscillation with a higher frequency. 

Static Equilibrium 

To calculate the static equilibrium we should select 'Static Equilibrium' in the 

menu 'Simulation', see Fig. 6. 

6 von 9 01.09.2011 15:26


Fig. 6 Static Equilibrium 

To perform the calculation we have to define a start value for the degree of 

freedom 'alp', see Fig. 7. The initial value should be near to the static equilibrium, 

so that the calculation does not require a high numerical expense. 

Fig. 7 Start value for static equilibrium 

By clicking on 'Static Equilibrium' the static equilibrium is calculated. The 

graphics is updated automatically or when changing a value. 

7 von 9 01.09.2011 15:26


This example demonstrated how to create force elements, kinematic loops, 

calculate and display the static equilibrium. 


The following commands were used and shortly explained in this example, even 

though they were called via the graphic user interface: 



animTimeInt 



Set up symbolic nonlinear equations of 

Neweul-M² 

motion 


declareDependent 

Declare one or more generalized coordinates 

Neweul-M² 

to be considered dependent 

newBody 


newForceElem 

Define an applied force, e.g. a springdamper 

combination 

Neweul-M² 

newGenCoord 


newLoop 

Define a new algebraic constraint, e.g. a 

Neweul-M² 

kinematic loop 

newSys 

Define a new multibody system, clears the 

Neweul-M² 

data structure sys 


staticEquilibrium 

Calculate a static equilibrium position 

Neweul-M² 

numerically 

timeInt 

Perform numerical time integration of the 

Neweul-M² 

system 


Write files of the nonlinear equations of 

Neweul-M² 

motion for numerical evaluation 



Links 


Next example: Elastic Pendulum 



8 von 9 01.09.2011 15:26



_Getting_Started_SliderCrank" 


9 von 9 01.09.2011 15:26

Neweulm2 - Getting Started ElasticDoublePendulum - IT M Wiki 

Neweulm2 - Getting Started ElasticDoublePendulum 

From ITM Wiki 

Contents 

1 Double pendulum with flexible bodies 

1.1 System definition (GUI) 

1.2 Setting up the equations of motion (GUI) 

1.3 Time integration and plot of states 

1.4 Analyzing the results 

1.4.1 Commands learned in this example 

1.5 Links 

Double pendulum with flexible bodies 

In this example we build a double pendulum made up of two flexible beams, which will be animated by a shock. Therefore we use the 

graphical user interface (GUI) of Neweul-M² again. The first step is to start Matlab again. If you skipped the first example, set the path 

variable as explained in the General Preparations, as a default: 


To start the GUI we have to type the command 

neweulm2 

System definition (GUI) 

At first a new system will be defined, now called 'beam pendulum'. Therefore you should take the same steps that have already been 

explained in the second example (Double Pendulum). Be aware that the gravity vector keeps its standard entries (0,0,-g). Because we 

build two bodies, we have to create two generalized coordinates. So, we select the menu item 'Model', then 'Parameters'. 

Fig. 1 Defining parameters 

In the following window please name the first generalized coordinate 'alpha1', then select 'Generalized Coordinate'. After creating 

this parameter by clicking Apply, please create another generalized coordinate called beta1. Please note that we selected the names 

on purpose, as a variable named beta would cause errors in MuPad, as this is a preoccupied function name. 

1 von 10 01.09.2011 15:26


Fig. 2 Generalized coordinates 

In the next step we are going to define the two bodies of our pendulum. For this, select in the menu item 'Model' the entry called 

'Bodies' and there 'Create New', like it's done in the second example (#Double pendulum). For using flexible Bodies we first select 

'Flexible' in the 'Body type' properties. Besides, the identifier is defined as 'P_1' and named 'Pendulum 1'. Moreover, you should 

keep the reference system 'ISYS'. Now press 'Create' to define a flexible body. 

Fig. 3 Picking the flexible body 

A new window will pop up, in which the flexible body will be created. We use a 'Beam (Bernoulli)' as body. Then we divide it into 15 

elements with 'Number of elements'. In the window on the right hand, you can see the longitudinal axis of the beam. As expected, 

the body is separated into 15 parts. Now we have to implement some values concerning the geometry. Use for 'Width (y)' a value of 

0.04 and for 'Height (z)' a value of 0.02 (dimensions in meter). In the menu 'Set DOFs for elastic deformation' select only z and 

rot y. Furthermore, we have to select, which nodal coordinate systems shall be available in the multibody system. We need the node on 

the right end of the beam in order to be able to use it as an interface, e.g. to attach another body or evaluate its trajectory. These nodes 

will be written to the elastic body description, e.g. the SID file, at the end. So, scroll down in the 'Node number' list, select the last 

entry (number 16) and click on 'add'. The added node will become bold in the overview window on the right. Alternatively, you can 

select the appropriate nodes by simply clicking on them in the overview window. Here we additionally select the nodes 4, 7, 10 and 13. 

However, they are not meant to attach anything to them, but just to have them for the animation. Please keep in mind that the 

orientation of the body's length will always point in direction of the positive x-axis, as you can see in the overview window. Therefore, we 

will have to rotate the body later, because it should be hanging down in direction of the negative z-axis by initial condition. Finally, 

click 'Next' to continue. 

2 von 10 01.09.2011 15:26


Parameter Value 

Number of Elements 15 

Beam Length 1 

Width (y) 0.04 

Height (z) 0.02 

Young's Modulus 70e9 

Possion's ratio 0.3 

Density 2750 

Fig. 4 Creating the flexible body 

In the following, we calculate the eigenmodes in the 'Model_Reduction' window. Therefore you should keep the method 'Modal 

Reduction' and simply start the calculation by clicking on 'Calculate modes'. As a result, you will see the eigenfrequencies listed 

below the 'Calculate modes' button. By selecting the different eigenfrequencies the appropriate eigenform will show up in the 

window on the left. Now, select the first and second eigenfrequency and click on 'keep' to store them for our model. The modal 

reduction is finished. To save the properties of our flexible body, insert 'pendulum' in the box 'Save SID to'. To apply the settings 

click on 'Create & Exit'. 

3 von 10 01.09.2011 15:26


Fig. 5 Calculating the eigenfrequencies and eigenforms 

Now we define the orientation of our beam by rotating it about the y-axis by 'pi/2+alpha1', in order that it hangs down as indicated in 

a previous passage. We apply our changes with 'OK'. 

4 von 10 01.09.2011 15:26


Fig. 6 Creating the flexible body 

The next step is to create the second body for our double pendulum. Therefore, we have to click again on 'Model', then 'Bodies' and 

finally 'Create New'. Please select once more the 'Flexible' option and name the second body 'P_2' and 'Pendulum 2'. As 'Reference 

System' it is important to use the node with the highest index of body P1 'P_1_6'. As rotation about the y-axis we use the generalized 

coordinate 'beta1'. Because we are using two identical bodies for our pendulum, we can simply use the same model we created before. 

Thus, please type in terms of the 'Flexible body properties' either pendulum.SID_FEM or use 'Search' to select the appropriate 

file. To apply your entries click on 'OK'. 

5 von 10 01.09.2011 15:26


Fig. 7 Setting up the second body 

The elastic beams have been created in the GUI and thus contain information for their graphical representation. The next job is to 

animate our newly created system. We shock the lower end of the second body figuratively with a hammer. Thus, we need to insert the 

appropriate force element. Under 'Model' choose the entry 'Force Elements' and open the window shown in Figure 8 with 'Create 

New'. We identify our force element with 'Shock'. By using 'General' as type, we have the possibility to set up our own individual 

animation in the box 'Force Law', in this example: 

1/(0.001*sqrt(2*pi))*exp(-(t-0.005)^2/(2*0.001^2)) 

In addition, we click on 'x' for the direction of our hammer animation. Now set up 'P_2_6' as 'CoordinateSystem 2' to realize the lower 

end as point of impact. Apply with 'OK'. 

6 von 10 01.09.2011 15:26


Fig. 8 Insert the force element 

Setting up the equations of motion (GUI) 

Now we have to calculate the equations of motion for the simulation. Therefore, choose in terms of 'Equations of Motion' the menu 

item 'Nonlinear Equations of Motion'. Matlab will begin to calculate the necessary equations. 

Fig. 10 Calculation of the equations of motion 

Time integration and plot of states 

Finally, to simulate our model, we click on 'Simulation' and then the option 'Time Integration'. All values are kept as standard 

except the 'Final Time' which will be changed to 3 seconds to save some calculation time. Our initial conditions alpha and beta stay 

zero in order that the motion will only be caused by the force element. After clicking on 'OK' it takes some seconds for the time 

7 von 10 01.09.2011 15:26


integration (red bar) to be finished. We accept the question if we want to start the simulation. Now we should see an animation window 

that is comparable to figure 34. 

Fig. 11 Time integration 

Fig. 12 Simulation 

Analyzing the results 

Finally, we interpret our results of the simulation. Thus, we go to 'Post Processing' and click on 'Simulation Results'. Now the 

window of figure 35 will show up and by clicking on 'Play' we can see our simulation in real time again. In order to do a more precise 

analysis, we keep the check box 'All Trajectories' under 'Create plots from the result' selected. Now we can get an output of all of 

our paths of motion by simply clicking on 'Plot'. 

8 von 10 01.09.2011 15:26


Fig. 13 Analysis of our results 

With the created plots you can get a broad overview of the behavior of our double pendulum and its motions in x-,y- and z-direction. It 

makes e.g. sense that our y-coordinate is always zero, because we only got a motion in the xz-level. A great part of the action is of 

course happening in the x-direction, where the shock is placed. To understand the plot of the x-coordinate it is important to know, that 

you can only see 3 of 6 trajectories that are listed in the legend. The reason is that we got different named points which are actually 

located at the same place. E.g. P_1 and P_1_1 are located on the same spot as well as P_1_2, P_2 and P_2_1. By zooming in the 

trajectories you can easily observe the typical oscillation of the structure which is the result of the specific force law we used. 

Fig. 14 Trajectories 

This example demonstrated how to use the knowledge provided by the previous examples on flexible bodies. We are at the end of this 

introduction. 'Neweul-M2' has other options and tools. The help menu and the user guide are available for further information. Have 

fun! 



9 von 10 01.09.2011 15:26




animTimeInt 


calcEqMotNonLin Neweul-M² Set up symbolic nonlinear equations of motion 


drawLine 

Neweul-M² Draw a line, connecting two coordinate systems in the animation window 

newBody 


newGenCoord 


newSys 

Neweul-M² Define a new multibody system, clears the data structure sys 

plotStandardResults Neweul-M² Provide plots of interesting curves from results 

timeInt 

Neweul-M² Perform numerical time integration of the system 

writeMbsNonLin Neweul-M² Write files of the nonlinear equations of motion for numerical evaluation 



Links 



List of all examples 

Retrieved from "http://www.itm.uni-stuttgart.de/itmwiki/index.php/Neweulm2_-_Getting_Started_ElasticDoublePendulum" 

This page was last modified 12:06, 1 September 2011. 

10 von 10 01.09.2011 15:26

Neweulm2 - List of files - IT M Wiki 

Neweulm2 - List of files 

From ITM Wiki 

Here a complete list of files from the top folder neweulm2 is given. 

Contents 

1 Folder neweulm2/ 

2 Folder neweulm2/algorithms/ 

3 Folder neweulm2/animation/ 

4 Folder neweulm2/cRoutines/ 

5 Folder neweulm2/gui/ 

6 Folder neweulm2/modules/ 

7 Folder neweulm2/routines/ 

Folder neweulm2/ 

The files in this folder are those usually called by the user, except the animation 

part, which has its own subfolder. 

calcEqMotLin.m 

Filename Field of use Description 

calcEqMotNonLin.m 

calcMov.m 

calcNomLength.m 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Simulation 

and 

Animation 

Calculate the linearized 

equations of motion 

Calculate the nonlinear 


Set up functions for kinematic 

analysis 

Calculate nominal lengths of all 

force elements from given 

positions 

1 von 14 30.08.2011 17:46


neweulm2 - 

calcNumericalLinearization.m Equations of 

Motion 

neweulm2 - 

declareDependent.m 

System 

Definition 

exportEqMot.m 

freqResponse.m 

kinematicAnalysis.m 

modalAnalysis.m 

modifyBody.m 

newBody.m 

newForceElem.m 

newGenCoord.m 

newKsys.m 

newLoop.m 

neweulm2 - 

Exporting 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

Calculate matrices of the 

linearized system numerically 

Declare which generalized 

coordinates are dependent from 

kinematic loops 

Export e.g. the equations of 

motion after replacing all 

parameters by numerical values 

to an m-file. 

Calculate the frequency 

response 

Perform kinematic analysis, 

prescribing functions for 

generalized coordinates 

Perform modal analysis 

Modifies certain settings at an 

existing body 

Create a new body 

Create a new force element 

Define one or more new 


Create a new coordinate system 

Create a new kinematic loop 

2 von 14 30.08.2011 17:46


newSys.m 

newSysIn.m 

newSysOut.m 

newTimeData.m 

newUserVarKonst.m 

newUserVarTvar.m 

newUserVarYvar.m 

newVolume.m 

optiEvalFreqRes.m 

printSystemInformation.m 

runSensAn.m 

runSysOpt.m 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

System 

Definition 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Simulation 

and 

Animation 

Create new multibody system 

Create a new system input 

Create a new system output 

Use a lookup table for a time 

dependent parameter 

Define one or more new constant 

parameters 

Define one or more new time 

dependent parameters 

Define one or more new state 

dependent parameters 

Defines a volume element for 

pressure forces 

Perform a parameter 

optimization, based on the 

frequency response 

Print some system information, 

very useful for debugging or 

understanding a system 

Perform a sensitivity analysis 

Perform a parameter 

optimization 

3 von 14 30.08.2011 17:46


scriptCalcEqMotNonLin.m 

scriptWriteMbsNonLin.m 

setfun.m 

staticEquilibrium.m 

writeMbsLin.m 

writeMbsNonLin.m 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Simulation 

and 

Animation 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

This file can be edited by the 

user to adjust the software to 

individual needs. Is called from 

calcEqMotNonLin.m 

This file can be edited by the 

user to adjust the software to 

individual needs. Is called from 

writeMbsNonLin.m 

Define functions for kinematic 

analysis 

Numerically calculate the static 

equilibrium 

Write files for the linearized 


Write files for the nonlinear 


Folder neweulm2/algorithms/ 

These functions are independent of the functionality of Neweul-M² and could be 

used as stand-alone functions. 


any2str.m 

cell2sym.m 

convertString.m 

csgn.m 

Auxiliary 

function 

Auxiliary 

function 

Auxiliary 

function 

Auxiliary 

function 

Returns a string, no matter which input 

format. Is also widely used in the GUI 

Create a symbolic vector of a given cell 

array containing parameter names 

Very useful function to append strings to 

every entry of e.g. a cell array 

Complex sign function, is introduced for 

compatibility with Maple 

4 von 14 30.08.2011 17:46


deval_wrap.m 

expandTimeVars.m 

fastinterp1.m 

findSyms.m 

finiteDifferences.m 

getTxtContent.m 

iszero.m 

jacobianMatrix.m 

kardan2rotmat.m 

mapleSimplify.m 

mapleSubs.m 

rotmat2kardan.m 

neweulm2 - 

Extension of deval to accept different 

Simulation and 

integration algorithms 

Animation 

neweulm2 - 

Equations of 

Motion 

Do a taylor series for time dependent 

parameters 

neweulm2 - 

Function to interpolate between set points, 


e.g. for newTimeData.m 

Animation 

neweulm2 - 

Equations of 

Motion 

Find symbolic expressions, return them as 

cell array not in one string as the built-in 

function 

neweulm2 - 

Calculate the gradient with the finite 


differences method 

Animation 

Auxiliary 

function 

Auxiliary 

function 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

Get string of a text field, convert it to 

correct type and if impossible insert 

default value 

As the Symbolic Math Toolbox behaves 

different using Maple or Mupad handling 

elements equal to zero, this function 

unifies the search for zero entries. Handles 

numeric and symbolic zeros. 

Calculate jacobian matrix 

Calculate rotation matrix from given 

kardan angles 

Simplify an expression. Is a wrapper 

function to simplify or maple to improve 

available options, performance and 

compatibility 

Substitute parameters in a symbolic 

expression, wrapper function to improve 

available options, performance and 

compatibility 

Calculate kardan angles from a given 

rotation matrix 

5 von 14 30.08.2011 17:46


signum.m 

sym2mcode.m 

vec2skew.m 

writeStructure.m 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

neweulm2 - 

Equations of 

Motion 

Maple name of the sign function, for 

compatibility 

Create m-file code from a symbolic 

expression 

Create a skew symmetric matrix from a 

vector, representing the cross product 

Print a complete structure to the standard 

out or a file including all substructures 

Folder neweulm2/animation/ 

Commands for the animation of results. 

addGraphics.m 


animFreqResponse.m 

animModeShape.m 

animTimeInt.m 

cad2mat.m 

colorStr2RGB.m 

createAnimationWindow.m 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

Auxiliary 

function 

Auxiliary 

function 

neweulm2 - 


Animation 

Attach a geometric shape to 

frame 

Animate a frequency response 

Animate one mode shape 

Perform and animation, can 

create .avi-files 

Read CAD data and convert it to a 

matrix for the animation 

Convert between the string and 

numeric representations of 

Matlab standard colors 

Initialize graphics and recreate 

any previously created graphic 

objects 

6 von 14 30.08.2011 17:46


drawArrow3d.m 

drawCube.m 

drawElasticBeam.m 

drawLine.m 

drawMesh.m 

drawRotBody.m 

drawSphere.m 

drawSpring.m 

drawSTL.m 

drawSys.m 

fitCanvas.m 

freqResPlot.m 

initGraphics.m 

Auxiliary 

function 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

Draw an arrow shaped object 

Draw a cuboid 

This function uses a crosssection 

along a line element as a 

representation for elastic bodies 

Draw a line connecting two 

coordinate systems 

When mesh information of an 

elastic body exists, draw it or 

update its settings 

Draw a rotational body, this is 

rotational symmetric with respect 

to the z-axis 

Draw a sphere 

Draw an elastic spring between 

two coordinate systems 

Read an .STL file from a CAD 

software and create a 

corresponding object in the 


Draw coordinate systems of the 

system 

Adjust the visible area of the 


Plot the frequency response curve 

Create animation figure 

7 von 14 30.08.2011 17:46


ksysplot 

plotStandardResults.m 

plotTimeSteps.m 

plotTrajectories.m 

setVisibility 

showModeShape.m 

transformGraphics.m 

updateGeo.m 

writeAnimGeo.m 

writeGeo2NFF.m 

writeStrFile.m 

Auxiliary 

function 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 

Exporting 

neweulm2 - 

Exporting 

neweulm2 - 

Exporting 

Plot representations for all 


Create plots of the most common 

results 

Plot configurations at different 

time steps into one figure 

Plot the trajectory of one or more 


Set the visibility of groups of 

objects 

Display a mode shape 

Perform static transformations 

like translations or rotations of 

graphic objects 

Update the positions in the 


Export the objects in the 

animation window so the software 

anim can read it 

Write .nff files describing the 

objects in the animation window, 

can be used e.g. for Pasimodo 

Create .str file for an animation 

with anim from simulation result 

Folder neweulm2/cRoutines/ 

Routines for the export to C-language. 


mcode2c.m 

neweulm2 - 

Exporting 

Convert m-file code to executable 

C-Syntax 

8 von 14 30.08.2011 17:46


writeSfunction.m neweulm2 - 

Exporting 

Export system to Simulink S-function 

Folder neweulm2/gui/ 

This folder contains all files providing the graphical user interface (GUI). 

Therefore these files are called by clicking on the respective buttons instead of 

typing their names. Therefore they provide help buttons, labeled with a question 

mark ?. However, there are some very few files, which are to be called by the 

user: 

Filename 

routines/neweulm2HelpMsgs.m GUI 

startneweulm2.m 

figures/general/neweulm2.m 

routines/writeNeweullink.m 

Field 

of use 

GUI 

GUI 

GUI 

Description 

File containing the help messages, 

can be extended by the user 

Initialize and start the graphic user 

interface, clearing the workspace 

Initialize and start the graphic user 

interface, keeping the current model 

Create a file which can be moved to 

any location which will start the 

Neweul-M² GUI 

Folder neweulm2/modules/ 

This folder contains optional parts of Neweul-M². They usually have their own 

documentation coming along with them. 

Folder neweulm2/routines/ 

This folder contains files, which are essential to the software but usually called 

from other functions. Therefore they are stored in this folder not to confuse the 

user. 


absoluteKinematics.m 

neweulm2 - 

Equations of Motion 

calculate absolute 

kinematic values from 

precalculated relative 

9 von 14 30.08.2011 17:46


calcCon.m 

calcFlexForces.m 

calcForcesFelem.m 

calcForcesReaction.m 

calcInitConditions.m 

calcKin.m 

calcKinAbs.m 

check4GenCoord.m 

computeHomega.m 

coriolisSum.m 

createInertia.m 

elastMassMatrix.m 

neweulm2 - 


neweulm2 - 


neweulm2 - System 

Definition 


Definition 

neweulm2 - 


Animation 

neweulm2 - 


neweulm2 - 



Definition 

neweulm2 - 


neweulm2 - 


neweulm2 - 


neweulm2 - 


ones 

Calculate constraint 

equations 

Calculate the forces in 

and caused by elastic 

bodies 

Calculate the applied 

forces of force elements 

Calculate the reaction 

forces and torques 

between bodies 

Calculate consistent 

initial conditions for 

systems with kinematic 

loops 

Call the correct function 

for the kinematics 

calculation 

Calculate the kinematics 

using absolute 

kinematics, which is 

much slower than 

relative kinematics 

Check if all generalized 

coordinates have been 

defined 

Evaluate the terms 

collected in the h_omega 

vector of elastic bodies 

using abbreviations 

Evaluate the generalized 

coriolis forces for elastic 

bodies using 

abbreviations 

Evaluate the inertia 

tensor for elastic bodies 

using abbreviations 

Evaluate the mass matrix 

for elastic bodies using 

abbreviations 

10 von 14 30.08.2011 17:46


findFramePath.m 

getAbsoluteKinematics.m 

getKinematics.m 

getNumOfCell.m 

getVersionNeweulm2.m 

Ksys2Ksys.m 

leftSideDivide.m 

load_neweulm2_System.m 

Matrices_grad.m 

NE2minimal.m 

newAbbreviation 

neweulm2 - 


neweulm2 - 


neweulm2 - 


neweulm2 - 


Auxiliary function 

neweulm2 - 




Definition 

neweulm2 - 


Animation 

neweulm2 - 


Animation 


Definition 

Determine shortest 

connection between two 

coordinate systems, for 

getKinematics 

When the user needs 

absolute kinematic 

values, e.g. for system 

outputs, but they haven't 

been calculated yet in 

calcKin.m, this function 

provides them 

Determine other 

kinematic values, not 

provided by 

getAbsoluteKinematics, 

e.g. because they're 

relative values for 

calcCon.m 

Determine sizes of cell 

arrays and its elements 

File in which the version 

information of 

Neweul-M² is stored 

Calculate all relative 

kinematic values 

between two coordinate 

systems 

File to solve a system of 

equations consisting of a 

matrix and a tensor 

Load a saved system and 

do all adjustments 

Calculate matrices for 

semianalytical gradient 

calculation 

Calculate the equations 

in minimal form from the 

Newton-Euler-equations 

Define a new 

abbreviation for an 

11 von 14 30.08.2011 17:46


OptiCalcInitCon.m 

OptiEval_adj_sep.m 

OptiEval_dir_tog.m 

relativeKinematics.m 

recursiveKinematics.m 

save_neweulm2_System.m 

setVersionNeweulm2.m 

SID2matlab.m 

symStruct2num.m 

tensorMultiplication.m 

tensorTranspose.m 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


neweulm2 - 



Definition 


Extension 

neweulm2 - 

Exporting 



elastic body 

Calculate initial 

conditions for 

optimization 

Evaluate function 

criterion and gradient 

with adjoint variable 

method and separate 

integration. 

Evaluate function 

criterion and gradient 

with direct method and 

integration of bothe 

ODEs together. 

calculate relative 

kinematic values 

calculate relative 

kinematic values for the 

recursive algorithm 

Save a modeled system 

File which is used to 

update 

getVersionNeweulm2.m, 

only works at the ITM 

Read SIDfile with flexible 

data 

Replace all symbolic 

expressions by their 

numerical values, if 

possible, list of 

exceptions can be 

specified. 

Multiply a third order 

tensor with a first order 

tensor, necessary for 

elastic bodies 

Transpose a third order 

tensor, necessary for 

elastic bodies 

12 von 14 30.08.2011 17:46


timeInt.m 

twoSideDivide.m 

updateN2DataStructure.m 

updateYVarTemplate.m 

writeFinalCond.m 

writeGenCoordDef.m 

writeHelpvarDef.m 

writeMbsNonLinRecur 

neweulm2 - 


Animation 

Perform a time 

integration 

For a transformation of a 

Auxiliary function tensor with a matrix 

from two sides 

Called from 

calcEqMotNonLin.m, 

this function ensures 

all settings are up to 

date, even when 

running older models 

Adjusts files to calculate 

state dependent 

Auxiliary function parameters to changes in 

the order of generalized 

coordinates 

neweulm2 - 


Animation 

neweulm2 - 


neweulm2 - 


neweulm2 - 


writeMbsNonLinRecurMinimal neweulm2 - 


writeMultiplication 

neweulm2 - 


Write files for final 

conditions in a time 

integration or some 

display during 

integration 

Initialize generalized 

coordinates in 

automatically created 

functions 

Initialize parameters in 

automatically created 

functions 

Write files for the 


Write files for the 


using minimal 

formulation 

Create the code to 

evaluate the 

multiplication of vectors 

and matrices 

13 von 14 30.08.2011 17:46


writeOptiAdjoint.m 

writeOptiDirect.m 

writeSetValDef.m 

writeSysDef.m 

write_psi.m 

neweulm2 - 


Animation 

neweulm2 - 


Animation 

neweulm2 - 


neweulm2 - 

Exporting 

neweulm2 - 


Animation 

Write files for a 

sensitivity analysis with 

the adjoint variable 

method 

Write files for a 

sensitivity analysis with 

the direct method 

Initialize set values of 


in automatically created 

functions for linear 

equations 

Export the currently 

loaded model to an input 

file for the command line 

version 

Write file for the 

evaluation of the function 

criterion for optimization 

or sensitivity analysis 


_List_of_files" 


14 von 14 30.08.2011 17:46

Neweulm2 - System Definition - IT M Wiki 

Neweulm2 - System Definition 

From ITM Wiki 

Contents 

1 System Definition 

2 Restrictions for Names 

3 Available functions for System Definition 

3.1 newSys 

3.2 newGenCoord 

3.3 newUserVarKonst 

3.4 newUserVarTvar 

3.5 newUserVarYvar 

3.6 newBody 

3.7 newKsys 

3.8 newForceElem 

3.8.1 ATTENTION! Possible Source of Errors! 

3.9 newLoop 

3.10 modifyBody 

3.11 declareDependent 

3.12 newSysIn 

3.13 newSysOut 

3.14 newTimeData 

3.15 newVolume 

4 Loading and Saving 

4.1 load_neweulm2_System 

4.2 save_neweulm2_System 

5 See also 

5.1 ITM Wiki 

System Definition 

In the following, the functions used to define a multibody system in Neweul-M² 

are explained. The system is defined in the file sysDef.m. The following 

commands for the system definition are available: 

1 von 25 30.08.2011 17:46


Command 

Description 

newSys 

generate data structure for system 

newUserVarKonst declare constant userdefined variable 

newUserVarTvar declare time-variant userdefined variable 

newUserVarYvar declare state-dependent userdefined variable 

newBody define body 

newKsys 

define coordinate system 

newForceElem define force element 

newLoop 

define a kinematic loop 

kinematic loops create dependencies between coordinates, 


with this function you can declare which are dependent 

newSysIn define system input 

newSysOut define system output 

newTimeData use time dependent data as lookup table 

newVolume create volume element for pressure forces 

In the subsequent sections, these commands and their options are described in 

detail. In general, all options are optionally, i.e. they must not be passed 

necessarily. In case an option is not passed, a default value is used instead. 

Further, all options except numerical values have to be passed as strings. 

Restrictions for Names 

Basically you can use all names Matlab considers valid for your system 

parameters, e.g. no leading numbers. There are restrictions to variable names, 

as some names are assigned a special meaning. Also parameters with these 

names or extensions are created automatically assuming that they do not collide 

with names given by the user. 

The Parameter 'g' is reserved for the gravitational constant. 

Names ending on '_s' are reserved for set values for the generalized 

coordinates in case of a linearization of the equations of motion. 

Time derivatives of set values and of time dependent parameters are 

denoted with a leading 'D' or 'D2' respectively. 

Internally used parameters as loop parameters or state vectors are denoted 

with a trailing underscore '_'. 

The well loved parameters 'i' and 'j' are used by Matlab to denote the 

complex unit. Their use could therefore cause strange errors or results. 

From the version R2007b+ on the Symbolic Math Toolbox uses MuPad instead of 

2 von 25 30.08.2011 17:46


the Maple kernel used before. This new symbolic engine has some reserved 

names of its own, which may cause strange errors if used in the definitions: 

E, I, D, O 

beta, zeta, theta, psi, gamma 

Ci, Si, Ei 

If your variable names match none of the above there should be no problems. 

The routines to create new parameters issue warnings if one of these naming 

conventions is violated, but they create the parameter anyway. Ignoring these 

conventions may cause strange errors or strange results, which is even worse. 

When creating modeling elements like bodies or force elements you can usually 

enter an ID and a Name for this object. As all data is stored in the structure sys 

the data concerning this element is stored under a substructure named as the 

ID. Therefore each ID has to fulfill the criteria Matlab requires for valid field 

names. This includes e.g. no leading numbers, no spaces. To be able to store a 

readable name or a short description, the Name field was introduced. This is 

stored as a string and therefore offers a wide range of available characters. 

Available functions for System 

Definition 

newSys 

Initialize new multibody system. 

Syntax 

newSys('option1','value1') 

Selection of some options 

Option Description Default Value 

Id Identifier of system 'MBS' 

Name Name of system 'Multibody System' 

Gravity Gravity vector '[0; 0; -g]' 

Description 

Execution of the command newSys generates a data structure sys which 

contains all data concerning the multibody system. Further the inertial system 

ISYS is generated which serves as reference system for further coordinate 

systems. The constant user-defined variable g is defined which serves as 

3 von 25 30.08.2011 17:46


gravitational constant. 

Data Structure 

The data structure sys has the following entries: 

Entry 

id 

name 

numUserVar 

userVar 

abbreviations 

gravity 

dof 

genCoords 

vectors 

numksys 

ksys 

numbodies 

Meaning 

Identifier of system 

Name of system 

number of user-defined variables 

substructure with user-defined variables and their values 

substructure for automatically created abbreviations 

gravity vector 

degrees of freedom 

list of generalized coordinates 

substructure with vectors of different things, e.g. elastic 

generalized coordinates, input, output, ... 

number of coordinate systems 

substructure with data of coordinate systems 

number of bodies 

numelastbodies number of elastic bodies 

body 

substructure with body data 

numfelem number of force elements 

felem 

substructure with data of force elements 

in 

substructure with three categories of system input channels 

out 

substructure with two categories of system output channels 

numloops number of kinematic loops 

loop 

substructure with kinematic loops 

numelements number of other modeling elements 

element 

substructure with other modeling elements, e.g. pressure 

volumes 

eqc 

substructure containing the constraint equations for 

kinematic loops 

eqm 

nonlinear equations of motion 

lin 

linearized equations of motion 

par 

substructure with parameters for this system's simulation and 

animation 

graphics substructure with graphical visualization 

results simulation results 

4 von 25 30.08.2011 17:46


tmp 

userData 

temporal data 

user data 

Example 

newSys; 

newSys('Id','mySystem','Name','This is my favourite system'); 

newGenCoord 

Declaration of a new generalized coordinate. 

Syntax 

newGenCoord('VarName1','VarName2'); 


All generalized coordinates are stored under sys.genCoords. Their classification 

is visible under sys.vectors.genCoords. 

Example 

newGenCoord('alpha1','x3','y5'); 

newUserVarKonst 

Declaration of constant user-defined variables. 

Syntax 

newUserVarKonst('VarName1',Value1,'VarName2',Value2,...); 

newUserVarKonst('VarName1','VarName2',...); 

newUserVarKonst('VarName1',Value1,'VarName2','VarName3',...); 

Description 

In the equations of motion of a multibody system, different types of variables 

occur. Basically we distinguish between the so-called generalized coordinates 

which describe the motion of the system, and the user-defined variables which 

represent the system parameters like geometry, masses etc. Within the 

user-defined variables, we further distinguish between constant, time-varying 

and state dependent variables. The command newUserVarKonst is used for the 

declaration of constant user-defined variables. For available parameter names 

see #Restrictions for Names. Each valid expression 'VarName1' is considered as 

a new parameter and initialized as such. If such a parameter is followed by a 

numerical value, Value1, this value is assigned to the previous parameter, here 

5 von 25 30.08.2011 17:46


'VarName1'. Also a mixture is possible, where only for some of the given new 

parameters numerical values are given. If nothing is specified, the values are 

initialized to zero. 

The numerical values can be specified at this point in the simulation. Initially, 

the numerical values have been defined in the file setUserVar.m. The point and 

time of specification does not affect the setting up of equations. The time of 

assignment only has to fulfill two criteria: The parameter must have been 

defined before, and it has to be done, before some tasks require numerical 

values. Usually the first task to require values is either the creation of an 

animation window or a time integration. 


The IDs of all constant user-defined variables are stored in sys.userVar.konst. 

The numerical values which are necessary for simulations are assigned to 

sys.userVar.data.(VarNamei). 

Example 

newUserVarKonst('m1','L2','omega'); 

newUserVarKonst('m1',6,'L2','omega',5); 

newUserVarTvar 

Declaration of time-dependent user-defined variables. 

Syntax 

newUserVarTvar('VarName1','Expression1', 'VarName2','Expression2'...); 

Description 

newUserVarTvar('VAR','EXP') introduces the time-dependent variable VAR 

and its first and second time-derivative DVAR and D2VAR to the system. For 

running simulations, the numerical value of the variable and the first and second 

derivative w.r.t. time have to be defined as function of time in the m-file 

functions f_VAR.m, f_DVAR.m and f_D2VAR.m which are located in the 

directory userFunctions/ in the model directory. EXP can be a symbolic 

expression, which is necessary for the calculation of gradients. When calling 

newUserVarTvar with an EXP being an empty string, template functions are 

generated which have to be edited by the user. Already defined functions are 

not overwritten. If EXP contains a symbolic expression it is used to calculate the 

derivatives and is stored in the created functions. If EXP is a symbolic 

expression, existing files in userFunctions/ are overwritten during creation of 

the parameter. The symbolic expression in the structure sys is used solely for 

the calculation of gradients and the creation of the files in userFunctions/. In 

all other symbolic expressions and functions for numerical evaluation the 

parameter VAR and the corresponding files are used. 

6 von 25 30.08.2011 17:46



The variable and its first and second time-derivative are added to the list 

sys.userVar.tvar. The corresponding function handles or symbolic expressions 

are stored in sys.userVar.data 

Example 

newUserVarTvar('u1',); 

newUserVarTvar('u1','sin(3*t)'); 

newUserVarYvar 

Syntax 

newUserVarYvar(VarName1,Expression1,Varname2,Expression2); 

Description 

With this command, for each Varname* a new variable is created, which may 

depend on the current state and the time t. As these parameters may depend on 

the time t, the first and second time derivatives called DVarname* and 

D2Varname* are created as well. For each of them, a template function for the 

numerical evaluation is created. If a cooresponding symbolic expression 

Expression* is given, this is entered in the template functions. 

ATTENTION! These parameters offer many possibilities, but the 

program cannot check whether all necessary information has been 

specified in the files. Therefore if the user forgets to provide 

information, they also offer many possibilities to create mistakes! 

This parameter type serves two main purposes. First it allows the user to define 

nonlinear force laws. For this instead of a constant stiffness or damping 

parameter, such a state dependent parameter is used. In the template function 

the user usually has to call the functions providing positions and velocities of 

coordinate systems. From these, relative position and velocity vectors may be 

calculated, necessary for the evaluation of the stiffness or damping for a given 

state. 

The second main use is to define state dependent excitations, like a street-bump 

for a car model, which will be used as an example in the following explanations. 

For a constant speed of the car such a bump could be modeled with time 

dependent parameters. But if the car may have varying velocity and the bump 

shall be at a given position in space, state dependent parameters are necessary. 

The problem here is that for every coordinate system, the jacobian matrices of 

rotation and translation are calculated. As right now this feature is only fully 

supported in the use as translational excitations, I will focus now on the jacobian 

of the translation. The jacobian matrix of the translation is the derivative of the 

position vector r with respect to the generalized coordinates y. If then a state 

7 von 25 30.08.2011 17:46


dependent parameter is used to define such a position vector, the derivatives 

with respect to all generalized coordinates are necessary. As the number of 

generalized coordinates may change after the definition of such a parameter, 

the user cannot define all these derivatives. Therefore an intermediate step is 

introduced. The position of each coordinate system except ISYS is defined in its 

reference system. And usually the derivatives with respect to the local 

coordinate directions of the reference system are quite easy to provide. 

Therefore these derivatives have to be given by the user, and they are used with 

the chain rule of derivatives to calculate the derivatives with respect to all 

generalized coordinates. These derivatives with respect to the coordinate 

directions are denoted as Varname_D*_, where * is a placeholder for a number 

from 1 to 3, denoting the index of the axis. For their evaluation the function of 

Varname is automaticlly called with a flag, denoting to return the derivative. 


The entries in the data structure are similar to those from time-dependent 

parameters. 

Example 

newUserVarYvar('u2','abs(x)'); 

newBody 

Definition of a new body. 

Syntax 

newBody('parameter1','value1','parameter2','value2',...); 

Option 

Description 

Default 

Value 

Id Identifier of body 'BODY_XX' 

Name Name of body 

'Body 

Number XX' 

Type Type of body, 'rigid' or 'flex' 'rigid' 

RefSys 

reference coordinate system, from which the body 

is defined 

'ISYS' 

RelPos 

relative position vector to primary system, 

described in refSys, from refSys 

[0 0 0]' 

RelRot 

relative rotation angles of primary system, 

described in refSys, from refSys 

[0 0 0]' 

8 von 25 30.08.2011 17:46


CgPos 

relative position of center of gravity, described in 

the primary system, only for rigid bodies 

[0 0 0]' 

CgRot 

rel. rotation of coordinate system in center of 

gravity, described in the primary system, only for [0 0 0]' 

rigid bodies 

Mass mass 1 

Inertia inertia tensor w.r.t. center of gravity eye(3) 

SIDfile 

specification of the .SID_FEM file containing 

information of the elastic body. Instead of this a 

.mat file or directly the resulting data structure can 

be passed. 

JointSys 

For elastic bodies with a floating frame of 

reference, the frame, which is connected to the 

previous (parent) body can be specfied 

Specifies which frame is used to describe the 

RelRotFrame orientations, either the Joint System 'JointSys', or 

the frame of reference 'JointRef' 

Description 

newBody adds a body to the multibody system. The body is represented by a 

coordinate system BODY_XX which is named like the body itself, and a 

coordinate system BODY_XX_cg describing the position of the center of gravity. 

The position and orientation of the system BODY_XX_cg is defined by the 

options CgPos and CgRot. All rotation angles are expected to be Kardan angles, 

i.e. rotation angles around the current x-, y- and z-axis. The degrees of freedom 

of the body are defined by the choice of the relative position and the relative 

rotation. If there are unknown variables used for the definition of the position 

and orientation of the body, i.e. variables which are not declared as user-defined 

by the commands newUserVarKonst or newUserVarTvar, the corresponding 

motions are expected to be a degree of freedom of the body, and the variables 

are treated as generalized coordinates. On the other hand, all directions of 

motion for which numeric values or user-defined variables are used are 

constrained. 


For each body a substructure named by the body ID is generated at sys.body 

with the following entries: 

Entry 

id 

Identifier of body 

Meaning 

9 von 25 30.08.2011 17:46


name Name of body 

idx Index of body 

type either a 'rigid' or 'elastic' body 

data containing additional information, e.g. elastic information 

refsys reference coordinate system 

r_rel relative position vector 

phi_rel relative rotation angles 

r_cg rel. position of center of gravity 

phi_cg rel. rotation of coordinate system in center of gravity 

m mass 

I 

inertia tensor w.r.t. center of gravity, described in the frame in the 

center of gravity! 

M body mass matrix, described in the frame in the center of gravity! 

ksys coordinate systems belonging to the body 

geo graphical representation 

logical, whether this elastic body has been reduced symmetrically or 

oblique 

not 

elastIdx index counting only elastic bodies 

Example 

newGenCoord('a1'); 

newBody('RelRot','[a1; 0; 0]', 'CgPos','[0; 0; -2]', 'Mass','3'); 

newKsys 

Definition of new coordinate system. 

Syntax 

newKsys('Parameter1','Value1','Parameter2','Value2',...); 


Id Identifier of coordinate system 'KSYS_XX' 

Name Name of coordinate system 

'Coordinate system 

Number XX' 

Type 

Type of coordinate system, empty means regular 

frame, other options are 'nodal', 'JointSys' or 

'JointRef' 

' ' 

10 von 25 30.08.2011 17:46


RefSys reference coordinate system 

RelPos relative position vector 

RelRot relative rotation angles 

'ISYS' 

[0 0 0]' 

[0 0 0]' 

Description 

newKsys adds a new coordinate system to the multibody system. This can be 

used either as reference system for other bodies or coordinate systems, for the 

definition of force application points or for kinematic output of specific points 

during simulation. The coordinate system belongs to the same body as its 

reference system. Generalized coordinates can be used for its definition, but 

should be handled carefully, as a coordinate system doesn't have a mass 

property. This could easily cause a singular mass matrix. 


Entry 

Meaning 

id Identifier of coordinate system 

name Name of coordinate system 

idx Index of coordinate system 

children coordinate systems which use this system as reference system 

body body to which the coordinate system belongs 

type specify type of coordinate system 

refsys reference system 

relkin relative symbolic kinematics 

absolute symbolic kinematics, corresponding values to functions in 

symkin numkin for more information see neweulm2 - Equations of 

Motion#calcKin 

numkin handles of functions for the numerical evaluation of kinematics 

calckin 

symbolic kinematics, used for the calculation, only necessary values 

exist 

geo graphical representation 

Example 

newKsys('RelPos',[0.1; 0.2; 0.3]'); 

newForceElem 

Definition of a new force element. 

11 von 25 30.08.2011 17:46


Syntax 

newForceElem('Parameter1','Value1','Parameter2','Value2',...); 


Id Identifier of force element 'FELEM_XX' 

Name Name of force element 

'Forceelement Number 

XX' 

Type Type of force element 'SpringDampCmp' 

Ksys1 Coordinate system 1 'ISYS' 


DirDef 

Coordinate system for the definition of 

force directions 

Ksys1 

FAP1 

force application point for side 1 of force 

element 

Ksys1 

FAP2 

force application point for side 2 of force 

element 

Ksys2 

ForceLaw Force Law for general force element [0 0 0 0 0 0]' 

Stiffness 

stiffness coefficients for SpringDampCmp 

element 

[0 0 0 0 0 0]' 

Damping 

damping coefficients for SpringDampCmp 

[0 0 0 0 0 0]' 

element 

NomLength Nominal length of Spring 

[0 0 0 0 0 0]' 

NomForce 

Force applied in the case of the nominal 

length of Spring 

[0 0 0 0 0 0]' 

Description 

newForceElem adds a force element to the multibody system which acts 

between the two points described by the coordinate systems Ksys1 and Ksys2. 

The reference system, i.e. the system which defines the directions of the force 

components, is defined by the DirDef option (default is Ksys1). 

SpingDampCmp* - types 

For a force element of type SpingDampCmp/SpingDampCmpRotmat 

/SpingDampCmp_Lin the stiffness- and damping coefficients can be passed as 

matrix or vector alternatively. When passing stiffness- and damping matrices, 

the force and moment is calculated by 

where and are the relative position and orientation between the two 

12 von 25 30.08.2011 17:46


coordinate systems. In case that the coefficients are passed as vectors, the force 

and moment is calculated as 

The direction of force and moment is defined to be positive for Ksys1 and 

negative for Ksys2. 

If the nominal length shall be used it is defined as follows. For each coordinate 

direction of the relative position and orientation vectors, displayed in the DirDef 

frame a nominal length and can be given. This 6x1 vector is then 

subtracted from the actual relative vectors before calculating the applied forces 

and torques. 

The nominal forces and torques and are those forces being applied when 

the relative vector is identical to the vector of nominal lengths. This is an 

important feature especially for state-dependent stiffness parameters. 

Rotations 

There is an almost infinite number of halfway reasonable formulations for the 

angular values corresponding to the torque vector. However, there is hardly any 

really correct version of this problem. The reason for this is that the generalized 

force law stated above uses a matrix vector notation, which itself is a linear 

description. Rotational effects, however, are nonlinear and would require a 

different formulation for large displacements. But then, for large relative 

rotation angles, the triplet of rotation angles does not have vector properties. 

Therefore there are currently three possibilities implemented: 

SpringDampCmp: This is the standard force element. Here the relative 

rotation angles between the two coordinate systems are calculated and used 

directly, which corresponds to being interpreted as small and having vector 

properties. 

SpringDampCmpRotMat: This once was the standard type. Here the 

relative rotation matrices between the respective two coordinate systems 

and the Dirdef system are set up. Therefore this type considers some 

nonlinearities and usually creates longer expressions. 

SpringDampCmp_Lin: This uses the rotational Jacobian matrices together 

with the rotation angles, which results in a formulation ranging between 

the other two. 

One rather simple workaround, which also makes the model easier to 

13 von 25 30.08.2011 17:46


understand is to split up rotational springs or dampers. In planar cases, the 

order of rotation does not have any influence. If you therefore create three 

different force elements, one for each direction, there are usually no problems. 

For a force element of type SpingDampPtp the stiffness- and damping 

coefficients are scalar values. This type of force element represents a springdamper 

combination acting only on behalf of the distance between the to 

application points, always in direction of their connection. A nominal length l 0 

and corresponding nominal force F 0 are available as well, being both scalar 

values. With being the relative position vector and its derivative w.r.t time 

the normalized position vector is 

Then the force is calculated as 

For this type no Moments are calculated, the DirDef option is unnecessary and 

therefore set to ISYS. The other options and directions are similar to 

SpringDampCmp. 

For the force element of type General, force and moment are defined by a 

general, arbitrary force law which is passed by the ForceLaw option. Decided 

by the given size of the vector, it is interpreted to be a six element vector 

containing forces and moments like a SpringDampCmp element. Or if a scalar 

value is given, it will act in the connection of the two frames like a 

SpringDampPtp element. This type of force element can be used to implement 

force excitations. To define a force excitation on coordinate system 'myKsys1' 

first a time dependent parameter, e.g. u1 has to be defined. Depending on the 

direction of the applied force the DirDef has to be entered correctly. Then the 

following command can be used: 

newForceElem('Id','myExcit', 'Name','my Excitation', ... 

'Type','General', 'Ksys1','ISYS', 'Ksys2','myKsys1', ... 

'DirDef','ISYS', 'FAP','myKsys1', 'ForceLaw','[u1;0;0;0;0;0]'); 

With this, the force is applied positive at coordinate system ksys1 and negative 

at coordinate system ksys2. Now the force vector is completely defined and then 

is applied at the force application point, which usually is one of the two involved 

coordinate systems. 

The force application point is defined by the FAP1 and FAP2 options. There 

was only one force application point, which is perfectly reasonable if the force 

acts in the direction of the relative position vector. In the case of a 

SpringDampPtp force element this is always the case, because it is made to be 

like that. For the other force elements this does not hold true and posed some 

problems if only one force application point is considered. To understand this, 

14 von 25 30.08.2011 17:46


let's have a look at what the force application point is actually used for. 

If a force is applied at a body in a way that its line of action does not pass 

through the center of gravity, it will cause a moment. Let's consider a 

SpringDampCmp force element which connects two bodies. If its two coordinate 

systems have a distance only in one coordinate direction, in which the force 

element will produce a force, everything works fine. If this displacement is, e.g. 

because of the choice of DirDef, to be separated in two coordinate directions 

with a stiffness parameter each, the trouble begins as soon as these two 

parameters are different. If the stiffness parameters are different, the force will 

no longer point into the direction of the relative position vector between the two 

coordinate systems. Then it makes a difference which of the two coordinate 

systems involved is used to calculate the moment, as they are no longer 

connected by the line of action of the force. But the two coordinate systems have 

to be on two different bodies for the force to appear in the equations of motion. 

Therefore for each of the involved bodies its respective coordinate system should 

be considered as the force application point. On the other hand, one should be 

aware that such a force element may result in an unwanted moment with 

respect to the center of gravity. But it is reasonable and in some case necessary 

to use two different force application points. This effect could be easily avoided 

by defining both force application points on the same coordinate system. 

ATTENTION! Possible Source of Errors! 

When using rotational springs there is a possibility of producing unchecked 

errors. As long as possible, relative rotation angles between two coordinate 

systems are set up using the relative angles of all coordinate systems in 

between. However, in some spatial cases this is not possible. Then the relative 

rotation angles will be extracted out of the relative rotation matrix. As soon as a 

rotation matrix is involved, expressions like asin(sin(alpha)) will appear by 

starting with the angle alpha, setting up the rotation matrix, causing a 

sin(alpha) and attempting the inverse function. However, sometimes the 

symbolic engine is unable to identify all of these expressions. The problem is, 

that basically asin(sin(alpha)) should be the same as alpha. However the range of 

possible values is different. The parameter alpha can take any real numbered 

value, asin(sin(alpha)) however is restricted to [-pi/2; pi/2]. This may cause some 

really strange errors as they are very difficult to spot. The best way to avoid 

them is to make sure that rotational springs and similar force elements always 

use angles inside the interval [-pi/2; pi/2], where there is no difference. 


For each force element an entry in sys.felem with the ID of the force element is 

created. The data structure of a force element has the following entries: 

15 von 25 30.08.2011 17:46


Entry 

Meaning 

id Identifier of force element 

name Name of force element 

idx Index 

type Type of force element 

ksys1 Coordinate system 1 

ksys2 coordinate system 2 

dirdef Coordinate system for the definition of force directions 

fap force application point 

flaw Force Law for general force element 

k 

stiffness coefficients for SpringDampCmp/SprinDampPtp element 

c 

damping coefficients for SpringDampCmp/SprinDampPtp element 

nomlength nominal length 

nomforce nominal force, applied at nominal length 

Example 

newForceElem('Type','SpringDampPtp', 'Ksys1','ISYS', 'Ksys2','KSYS_1', ... 

'Stiffness',5, 'Damping',0.2, 'NomLength',0.3); 

newLoop 

Syntax 

newLoop('Id','VAR1', 'Name','VAR2', 'Ksys1','VAR3', 'Ksys2','VAR4', 

'Constraints', VAR5); 

Description 

This command creates a new kinematic loop, which is closed between ksys1 and 

ksys2. The constrained directions are defined by Constraints, with respect to the 

coordinate system denoted as DirDef. As a kinematic loop creates a dependency 

between generalized coordinates this command should be followed by a call of 

declareDependent later. A simple check if the constraint equations are 

dependent is contained, but it cannot find all possible dependencies. Therefore 

the user has to provide the kinematic loops in a way which guarantees their 

independency. This is necessary because the jacobian matrix of the constraint 

equations is contained in the equations of motion. 


Id Identifier of the kinematic loop 'LOOP_1' 

16 von 25 30.08.2011 17:46


Name Name of this kinematic loop 

'Loop Number 

1' 



DirDef Coordinate system defining the directions Ksys1 

Vector (1x6) of which degrees of freedom are 

Constraints 

constrained 

[0 0 0 0 0 0] 


Entry 

Content 

id Loop id 

name Loop name 

ksys1 First coordinate system of this loop 

ksys2 Second coordinate system of this loop 

dirdef Coordinate system defining the directions 

con Vector of constraint directions 

c_3 Vector of constraint equations on position level 

Cell array which notes, at which position in the constraint vector 

numofeqc 

these constraints are located 

Example 

newLoop('Id','Loop1', 'Name','kinematic Loop 1', ... 

'Ksys1','ISYS', 'Ksys2','P1_cg', 'Constraints', [0 1 0 0 0 1]); 

modifyBody 

Syntax 

modifyBody(bodyID,varargin); 

Description 

Adjust properties of a body. For simple changes one could do without this 

function. However, it even allows to change the data of an elastic body and then 

only performs the necessary recalculations. 


Example 

17 von 25 30.08.2011 17:46


modifyBody('BODY1','SID',elbodyData); 


Syntax 

declareDependent('VAR1'); 

Description 

Kinematic loops are created by adding algebraic equations to the set of 

differential equations. By this the generalized coordinates are dependent. Use 

this function to declare which coordinates, here VAR1, are to be considered 

dependent. 


Example 

declareDependent('delta'); 

newSysIn 

Definition of system input channels. 

Syntax 

newSysIn('Parameter1','Value1','Parameter2','Value2',...); 

Option 

Description 

Default 

Value 

Id Identifier of input channel 'SYSIN_XX' 

Name Name of system input channel 

'Input Number 

XX' 

Var 

Time-dependent variable which serves as input 

channel 

-- 

Group 

Select in which of the three groups 'control', 

'disturbance' or 'addtional' this input belongs 

'control' 

Same as 'Group', except, that you can specify new 

newGroup 

input groups 

Description 

For the investigation of the transfer behavior of a linearized system it is 

necessary to define at least one input channel and one output channel. Every 

18 von 25 30.08.2011 17:46


time-dependent user-defined variable can serve as input channel. 

It is a priori not known from a given time dependent parameter u(t) if the 

parameter u itself or one of its first two time derivatives Du or D2u appears in 

the equations of motion. Therefore calcEqMotNonLin.m as a default checks for 

all occurences and includes all found derivatives in the input vector. You can 

check this vector in sys.vectors.in and if something went wrong, suppress this 

automatic selection in calcEqMotNonLin by an option. Please see 

'calcEqMotNonLin' for more information. Then all three values are kept, looking 

like 

[u; Du; D2u; v; Dv; D2v; ...] 

This would cause the input matrix, usually called B to be larger than some 

people would expect. 

Tip: You might want to have a look at the file eqm_lin_ssinout.m which 

automatically calculates the ABCD-matrices. 

The idea of the input groups is the following. When several inputs are defined, it 

may be useful to distinguish between them. Possible applications could be to 

distinguish between control inputs and disturbances in control design. Or when 

a controlled system shall be optimized with respect to the transfer function it 

would be easier to have this distinction. For each group a vector denoting the 

order exists under 'sys.vectors.in'. If all inputs should be collected in one big 

vector, this will always be in the order 'control', 'disturbance', 'additional'. 


For each system input channel an entry in the corresponding entry 'control', 

'disturbance', 'additional' under sys.in is generated. The substructure has the 

following entries: 

Entry 

Meaning 

id Identifier of input channel 

name Name of system input channel 

idx Index of input channel 

var Time-dependent variable which serves as input channel 

Example 

newUserVarTvar('u1','sin(3*t)'); 

newSysIn('Id','myInput','Name','This is just an example','Var','u1'); 

newSysOut 

19 von 25 30.08.2011 17:46


Definition of system out channels. 

Syntax 

newSysOut('Parameter1','Value1','Parameter2','Value2',...); 


Id Identifier of output channel 'SYSOUT_XX' 

Name Name of system output channel 

'Output Number 

XX' 

Var Variable which serves as output channel -- 

Type 

Specification of the type, if none given, the 

function tries to determine it 

being 

determined 

Group Which of the two groups 'control' or 'additional' 'control' 

Same as 'Group', except, that you can specify new 

newGroup 

output groups 

Description 

For the investigation of the transfer behavior of a linearized system it is 

necessary to define at least one input channel and one output channel. There are 

several different types of system outputs: 

kinematic values, e.g. the y-component of the absolute velocity vector of 

coordinate system 'ksys1' can be defined as system output by sysOut.var = 

'ksys1.v(2)'. Then type should be set to kinematic. 

generalized coordinates or their first time derivative, e.g. alpha, this is 

denoted by type genCoord. 

applied forces can be used as system outputs, described in the respective 

DirDef system. felem1(2) would denote the force in y-direction of force 

element felem1. The torque around the z-axis would be felem1(6), whereas 

felem1 denotes the norm of the force vector without torques. 

reaction forces are available as system outputs, also described in the local 

coordinate system of the parent coordinate 

volume elements can be used to return the calculated pressure p or change 

of pressure dp, e.g. element1.dp. 

the user can specify a symbolic expression directly with the type userDef. 

to get combinations of other system outputs, e.g. the difference between to 

kinematic values, the type combination can be used. Then a symbolic 

expression using the IDs of the other outputs is expected, e.g. outID1- 

outID2. 


For each system output channel an entry under the respective entry 'control' or 

20 von 25 30.08.2011 17:46


'additiona' in sys.out is generated. The substructure has the following entries: 

Entry 

Meaning 

id Identifier of output channel 

name Name of system output channel 

idx Index of output channel 

type 

Type of output, one of the following: 'kinematic', 'appliedForce', 

'reactionForce', 'genCoord', 'userDef' 

var 

generalized coordinate, kinematic variable, ... which serves as output 

channel 

sym symbolic expression, to be determined by the software 

data Additional information for this output, depending on its type 

Example 

newSysOut('Id','myExample','Name','This is my favorite output', ... 

'Var','BODY1_cg.r(1)', 'Type','kinematic'); 

newTimeData 

Use precalculated time dependent data as a lookup table and interpolate 

between these set values. 

Syntax 

newTimeData('Parameter1','Value1','Parameter2','Value2',...); 

Description 

Stores the data under sys.element and creates a function template for its 

evaluation. All of this can be adjusted by the user. This provides reproducible 

results, even when using stochastic excitations or allows the use of measured 

data. 


Data is stored under sys.element 

Example 

newTimeData('Id','mySine','x',linspace(0,20),'y',sin(linspace(0,20))); 

newVolume 

21 von 25 30.08.2011 17:46


Definition of a volume element for pressure forces. 

Syntax 

newVolume('Parameter1','Value1','Parameter2','Value2',...); 


Id Identifier of the volume element. 'ELEMENT_XX' 

Name Name of the element. 

'Element 

Number XX' 

Type Type of element. 'Volume' 

Coordinate systems marking the outer planes of the 

KsysSurf 

volume. 

' ' 

DirDef 

Coordinate systems which define the force 

directions, in contrast to the force element, each ' ' 

coordinate system can have its own DirDef system. 

RefArea Reference areas, belonging to neighboring masses. ' ' 

Vdamp Damping of volume element in x,y and z direction [0 0 0] 

Vinf Inverse volume of the complete element 0 

pin Static pressure difference 0 

p0 

Static nominal pressure to define the working point 

of the pressure change calculation in [Pa] 

101300 

Parameter for the gas law, called 'Heat capacity 

kappa ratio' or 'adiabatic index or ratio of specific heats' or 1.4 

'Isentropenexponent' (in german) 

Description 

newVolume adds a volume element to the multibody system. It is defined by the 

coordinate systems in KsysSurf, which are the outer planes of the volume 

element. The areas belonging to the neighboring masses are defined in 

RefArea, wherein a negative sign means a volume reduction when the 

corresponding mass moving in positive direction. The pressure force at each 

mass is calculated as 

with 


22 von 25 30.08.2011 17:46


Entry 

Meaning 

id Identifier of the volume element. 

name Name of the element. 

idx Index of the element. 

type Type of element. 

ksyssurf Coordinate systems marking the outer planes of the volume. 

Coordinate systems which define the force directions, in contrast to 

dirdef the force element, each coordinate system can have its own DirDef 

system. 

refarea Reference areas, belonging to neighboring masses. 

vdamp Damping of volume element in x,y and z direction 

vinf Inverse volume of the complete element 

pin Static pressure difference 

p0 

Static nominal pressure to define the working point of the pressure 

change calculation in [Pa] 

kappa 

Parameter for the gas law, called 'Heat capacity ratio' or 'adiabatic 

index or ratio of specific heats' or 'Isentropenexponent' (in german) 

dp Dynamic pressure change 

DV Dynamic volume change 

Example 

Loading and Saving 

You can simply save the system data structure sys to a .mat file. 

save myModel.mat sys 

This can then be loaded 

load myModel.mat 

and a corresponding animation window recreated by 


23 von 25 30.08.2011 17:46


load_neweulm2_System 

Syntax 

load_neweulm2_System(filename, filepath, CallMode_); 

Description 

As a difference to simply saving the system data structure, the figure and 

settings of the graphical user interface (if available) are stored. Then the 

animation window will look exactly the same and not just almost. 

All of these arguments are optional. A filename and its path (filepath) can be 

passed to the function. If they are ommitted the standard dialog to select a file 

for loading is opened. The parameter CallMode_ can be used if the function shall 

be called from the command line. As a default the structure gui and the 

user-interface neweulm2 are adjusted. For more information type help 

load_neweulm2_System. This function was created to be called from the GUI, but 

is also available for the batch mode. 

Example 

load_neweulm2_System; 

load_neweulm2_System('mysystem.mat'); 

save_neweulm2_System 

Syntax 

save_neweulm2_System(filename,filepath,IncludeResults_); 

Description 

All of these arguments are optional. This function allows the user to save a 

system and its corresponding figure if available. The file will be called filename 

and located in the folder filepath. With the boolean parameter IncludeResults_ 

the user can decide if simulation results shall be included in the saved file. If the 

filename is not specified, the standard dialog box to save files will be opened 

where the user can enter a filename. This function was created to be called from 

the GUI, but is also available for the batch mode. 

Example 

save_neweulm2_System; 

See also 

24 von 25 30.08.2011 17:46


ITM Wiki 

neweulm2 

neweulm2#Function reference 





_System_Definition" 


25 von 25 30.08.2011 17:46

Neweulm2 - Equations of Motion - IT M Wiki 

Neweulm2 - Equations of Motion 

From ITM Wiki 

Contents 

1 Options and general explanations 

1.1 Options stored under sys.par 

1.2 General explanations 

2 Setting up the Equations of Motion 

2.1 Nonlinear Equations of Motion 

2.1.1 calcEqMotNonLin 

2.2 Linearized Equations of Motion 

2.2.1 calcEqMotLin 

2.2.2 calcNumericalLinearization 

2.2.2.1 Syntax 

2.3 Functions for Numerical Evaluation 

2.3.1 writeMbsNonLin 

2.3.2 writeMbsLin 

2.4 Auxiliary functions 

2.4.1 scriptCalcEqMotNonLin 

2.4.2 scriptWriteMbsNonLin 

2.4.3 NE2minimal 

2.4.4 calcCon 

2.4.5 calcForcesFelem 

2.4.6 calcForcesReaction 

2.4.7 kardan2rotmat 

2.4.8 rotmat2kardan 

2.4.9 relativeKinematics 

2.4.10 absoluteKinematics 

2.4.11 getabsoluteKinematics 

2.4.12 mapleSimplify 

2.4.13 mapleSubs 

2.4.14 writeStructure 

3 See also 

3.1 ITM Wiki 

Options and general explanations 

Neweul-M² calculates the equations of motion symbolically depending on the 

1 von 19 30.08.2011 17:47


parameters defined by the user. This results in a readable form which can be 

checked by hand, although this is a very complex task for larger systems. Another 

advantage is that these expressions can be easily exported to other programs, 

programming languages and applications. 

Options stored under sys.par 

The behavior of the software is controlled with entries under sys.par. An up to date 

information about those options can be obtained by calling one of the following to 

commands: 

SystemParameters % GUI version 

printSystemInformation('par',true) % command line version 

Field 

Content 

sys.par.version Information about which version of Neweul-M² has been used 

General settings to control the behavior of the software, 

sys.par.codegen 

simplifications, ... 

sys.par.eqm Settings on how the equations of motion shall be set up 

sys.par.timeInt (Optional) Contains settings for the time integration 

sys.par.kian (Optional) Contains settings for the kinematic analysis 

sys.par.opt (Optional) Contains settings for the optimization 

Field 

Content 

Use code optimization or not. This 

optimization searches for expressions 

used several times and introduces 

sys.par.codegen.optimize 

abbreviations, which sometimes make's 

the code run faster and the files 

smaller. 

Values in the range from 0 to 10 

specify how often the 'simplify' 

command is used. Even numbers also 

use the 'combine' command, which is 

sys.par.codegen.simplify especially useful for trigonometric 

expressions. It is NOT recommended to 

set this value to zero, as then some 

functions don't work properly, if they 

require some simplification. 

Possibilities 

(Standard 

selection 

comes first) 

false / true 

6 / 0 - 10 

2 von 19 30.08.2011 17:47


Field 

Content 

Possibilities 

(Standard 

selection comes 

first) 

Select if the mass matrix shall 

be inverted numerically or 

sys.par.eqm.massMatrixInverse 

'num' / 'sym' 

symbolically. Symbolically works 

only for small systems 

Select whether constraint 

equations are used on position 

level (3), velocity level (2), 

sys.par.eqm.index 

acceleration level (1), or none at 

all (0). This specifies the 

maximum value in the system. If 

no constraints are present, the 

value doesn't matter 

1 / 2 / 3 / 0 

sys.par.eqm.equationType 

sys.par.eqm.formulation 

sys.par.eqm.angles 

If no constraint equations are 

present, the equations of motion 

are ordinary differential 

equations ('ode'). As soon as 

constraint equations are 

introduced, this parameter can 

be used to select an explicit or 

partial explicit formulation as 

well. The setting 'ode_automatic' 

uses coordinate partitioning as 

done with 'ode', but numerically 

selects a good linear 

combination of independent 

coordinates. 

Select whether the 

premultiplication of the Newton- 

Euler-Equations shall be done 

numerically or the minimal form 

with a symbolic 

premultiplication shall be used. 

This parameter will be used to 

select the recursive mode as 

soon as it's implemented. 

Select the angular formulation. 

The software has been using 

solely Kardan-angles (x-y-z) but 

now Euler-angles (z-x-z) are 

'explicit_Mconst' 

/ 'partialexplicit' / 

'ode' / 

'ode_automatic' 

'newtonEuler' / 

'minimal' / 

'recursive' 

'kardan' / 'euler' / 

'quaternion' 

3 von 19 30.08.2011 17:47


sys.par.eqm.kinematics 

sys.par.eqm.frameOfReference 

sys.par.eqm.massSymmetric 

sys.par.eqm.abbreviations 

implemented as well. It is 

planned to provide quaternions 

as well. 

Use relative or absolute 

kinematics 

Currently this parameter is 

linked to the kinematics, but it 

might be implemented 

independently. For relative 

kinematics described in the 

floating frame of reference of 

each body is used, while 

absolute kinematics describes 

all values in the inertial frame 

ISYS. Currently if kinematics is 

the master setting, this one is 

adjusted accordingly. 

Specification whether the mass 

matrix is symmetric or not, 

usually this is not to be changed 

by the user, but determined 

automatically 

Specify how many abbreviations 

are introduced into the system. 

A value of 0 means no 

abbreviations at all. A value of 1 

denotes the usage of scalar 

abbreviations for kinematic 

expressions of nodes of elastic 

bodies, which mainly improves 

readability and offers some 

speed advantage. A value of 2 

denotes the usage of many 

abbreviations for all elastic 

bodies. This is slower in the 

evaluation, however the 

possibility to change elastic 

bodies without a complete 

recomputation is available. 

Therefore this setting is quite 

interesting for an optimization 

of elastic bodies. 

'rel' / 'abs' 

'body' / 'ISYS' 

true / false 

1 / 0 / 2 

4 von 19 30.08.2011 17:47


General explanations 

Currently there are different calculation modes available. 

Different ways to set up the kinematics 

Absolute kinematics 

Relative kinematics 

Formulations of the equations of motion 

Minimal formulation: 

Semi-symbolic formulation: 

Let's have a look at the kinematics first. When dealing with rigid body multibody 

systems, usually all expressions are set up in the inertial frame ISYS. Jacobian 

matrices and other values are calculated by symbolic derivatives. This is algorithm is 

the same as performed manually. As the information of elastic bodies is described in 

the respective frame of reference of each body, the equations of motion are 

completely set up in this frame of reference. Therefore each block row, describing 

the motion of one body before multiplying with the global jacobian matrix is 

described in a different frame of reference. The values of the jacobian matrices and 

other values are only calculated by symbolic derivatives, where it cannot be avoided. 

All other operations are performed by multiplications due to relative kinematics. 

This replaces costly symbolic derivatives by simple multiplications. 

The formulations are distinguished in the following way. For the minimal 

formulation, the local equations of motion of all bodies are stacked and 

premultiplied with the transposed global jacobian matrix symbolically. This reduces 

the equations to the minimal number of equations. In the other formulation this 

multiplication is performed numerically. In the case of a small number of bodies 

with many degrees of freedom, so especially for flexible multibody systems. However 

if only a small number of modes is used together with a rather high number of rigid 

bodies a minimal formulation can be preferable. 

In the previous section, it was said that the equations of all bodies are stacked to 

obtain the Newton-Euler equations. This is a suitable procedure, when setting up the 

equations manually. However, here the calculations are much faster to use cell 

arrays. The equations could thus be written as 

One main time-saver is that otherwise the mass matrix and the Jacobian matrix 

are only sparsely populated. Their multiplication is therefore much faster when done 

in such a summation instead of composing the full matrices. In order to obtain the 

expressions from the Newton-Euler equations, you can use, e.g. the following 

5 von 19 30.08.2011 17:47


commands 

qa = vertcat(sys.eqm.qa{:}) 

Jg = vertcat(sys.eqm.Jg{:}) 

Mq = blkdiag(sys.eqm.Mq{:}) 

To calculate linear equations of motion the nonlinear equations of motion have to be 

calculated first, as they are linearized. 

If you calculated the equations of motion and want to have a look at them, you can 

find them here: 

nonlinear equations of motion in sys.eqm 

linearized equations of motion in sys.lin.eqm, with the set values for each 

coordinate specified in sys.lin.ref. 

Setting up the Equations of Motion 

In the following, the functions used to set up the equations of motion of a previously 

defined multibody system in Neweul-M² are explained. The system is defined in the 

file sysDef.m. 

Command 


calcEqMotLin 


writeMbsLin 

Description 

Set up the symbolic nonlinear equations of motion 

Linearize the symbolic equations of motion 

Write files for the numerical evaluation of kinematics and 

the nonlinear equations of motion 

Write files for the numerical evaluation of the linear 


Script called from calcEqMotNonLin to customize the 

scriptCalcEqMotNonLin 

software to your needs 

Script called from writeMbsNonLin to customize the 

scriptWriteMbsNonLin 

software to your needs 

Auxiliary files 

Command 

NE2minimal 

calcKin 

calcCon 

Description 

Transform the Newton-Euler-Equations to minimal form or 

simply remove all abbreviations 

Calculate the kinematics, distinguish there if relative or 

absolute kinematics 

Calculate constraint equations from kinematic loops 

6 von 19 30.08.2011 17:47


calcForcesFelem 

calcForcesReaction 

relativeKinematics 

absoluteKinematics 

Calculate applied forces of force elements 

Calculate the reaction forces in the system 

Calculate the relative kinematic values 

Calculate the absolute kinematic values from existing 

relative values 

As only the required absolute kinematic values are 

getAbsoluteKinematics calculated, this function provides a means to calculate 

additional values 

In the subsequent sections, these commands and their options are described in 

detail. In general, all parameters are optional. In case an option is not passed, a 

default value is used instead. Further, all options except numerical values have to be 

passed as strings. 

Nonlinear Equations of Motion 


Syntax 

calcEqMotNonLin('Option1','Value1','Option2','Value2'); 

Description 

This function is the key part of Neweul-M², here the biggest piece of work is done. 

Calculates kinematics, kinetics and from them the nonlinear equations of motion. All 

input arguments are optional, all fieldnames and options given by 

printSystemInformation('par',true) and the following are possible: 

Option 

Description 

When setting up the input vector, include all 

possible time derivatives or search and use only 

minimalInputVect 

necessary values resulting in the minimal input 

vector 

Calculate only the kinematics, without setting up 

OnlyKinematics 

the equations of motion 

The calculation of kinematics can be started at a 

StartFrame 

specific coordinate system 

Logical if the workspace shall be saved at 

intermediate steps. This feature is solely for 

useIntermediateSave 

debugging and finding problems in large systems, 

which do not run smoothly. 

Default 

Value 

true 

false 

'ISYS' 

false 

7 von 19 30.08.2011 17:47


This file contains several subfunctions which have been separate files in the past, 

which are mentioned in the help text. 


The equations of motion are stored in sys.eqm. 

Important called functions 

calcKin to calculate the kinematics 

calcCon to calculate everything necessary for kinematic loops 

calcForcesFelem to calculate all forces from force elements like springs and 

dampers 

NE2minimal to transform the Newton-Euler-Equations to minimal form or to 

simply remove any abbreviations 

Linearized Equations of Motion 

To calculate linear equations of motion the nonlinear equations of motion have to be 

calculated first, as they are linearized. For this partial derivatives with respect to the 

generalized coordinates and velocities are calculated and evaluated at the set values. 

Depending on the formulation of the nonlinear equations of motion the results of 

this function may look different. If the nonlinear equations of motion exist in 

minimal form the linearized mass, stiffness and damping matrices can be directly 

calculated. Otherwise the parts of the linearized equations of motion are calculated 

separately and combined numerically, similar as done with the nonlinear equations. 

calcEqMotLin 

Syntax 

calcEqMotLin; 

calcEqMotLin('Option1','Value1'); 

Description 

Linearizes the nonlinear equations of motion around given set values. 

Option 

Description 

Use minimal form or the Newton-Euler 

equations and then multiply the Jacobian 

Formulation 

matrix numerically. See #Options stored under 

sys.par for more information 

Logical, if true all set values are set to 

numerical zeros instead of the standard 

NumericalSetValues 

symbolic constants. If false, set values remain 

unchanged 

Default 

Value 

'newtonEuler' 

false 

8 von 19 30.08.2011 17:47


RelCalcValues 

Simplify 

SymbolicSetValues 

Calculate minimal form when using relative 

kinematics, for absolute kinematics this is true 

anyway 

If a logical value is passed, simplification can be 

switched on and off. Otherwise the value is 

passed as an option to the simplify command. 

Logical, if true all set values are set to 

symbolical parameters, e.g. for alpha to 

alpha_s. If false, set values remain unchanged 

false 

true 

false 

The set values are specified in the data structure in sys.lin.ref. Let's consider a 

generalized coordinate 'alpha', which as a default is linearized around the set values 

'alpha_s', 'Dalpha_s' and 'D2alpha_s'. As a standard, these set values are created 

automatically as constant parameters. In order to linearize around a time dependent 

configuration or trajectory, e.g. 'sin(t)', the following command is necessary after 

the definition of the generalized coordinate 

newUserVarTvar('alpha_s','sin(t)'); 

The time derivatives are dependent and therefore updated automatically. If 

numerical set values shall be used instead, the user can either use the flag 

mentioned above to set all to zero, or has to enter commands similar to the following 

sys.lin.ref.alpha_s = 0.1; 

sys.lin.ref.Dalpha_s = 0; 

sys.lin.ref.D2alpha_s = 0; 


The linearized equations of motion are stored in sys.lin. 

calcNumericalLinearization 

For some complex systems the symbolic linearization may take very long time. 

However, sometimes a linearization for one specific configuration is sufficient. Then 

the function calcNumericalLinearization can be useful. This function provides 

commands to linearize the equations of motion numerically using the finite 

differences method. 

Syntax 

[A,B,C,D] = calcNumericalLinearization; 

[A,B,C,D] = calcNumericalLinearization(0,zeros(sys.dof,1)); 

This function accepts specifications for the configuration which shall be used as set 

values. The return values are similar to those of eqm_lin_ssinout. 

9 von 19 30.08.2011 17:47


Functions for Numerical Evaluation 


Syntax 

writeMbsNonLin; 

writeMbsNonLin('Option1','Value1'); 

Description 

Creates functions for the evaluation of all kinematic values as position and velocity 

vectors, expressions of the nonlinear equations of motion, ... . 


Write files only for position vectors and rotation 

OnlyPositions false 

matrices. Enables an animation window 

Write files for position vectors and rotation 

FramesList matrices only for these given coordinate 

systems 

fieldnames(sys.ksys) 

For systems with kinematic loops, there are some choices on which formulation of 

the equations of motion is used. The index of the equations of motion is explained at 

#calcCon. But there are also the following different formulations available: 

explicit, constant mass matrix 

partial-explicit 

ODE formulation through separation of coordinates, see 

KurzBurkhardtEberhard11 (http://www.itm.uni-stuttgart.de/itmwiki 

/ITM_Literatur_pdf/KurzBurkhardtEberhard11.pdf) for more information. 

The equations of motion should be solvable with a standard integration algorithm 

and thus being in the form Msys * Dx = f(t,x). As many integration algorithms 

require this system 'mass' matrix Msys to be constant, we are restricted to that. 

Therefore the following DAE formulations are available: 

Name 

Equations of motion: 

State 

vector 

explicit: 

10 von 19 30.08.2011 17:47


partial 

explicit: 

writeMbsLin 

Syntax 

writeMbsLin; 

Description 

Creates functions for the evaluation of the matrices of the linearized equations of 

motion. 

Auxiliary functions 

scriptCalcEqMotNonLin 

Syntax 

scriptCalcEqMotNonLin; 

Description 

At some point in the development of the software, the question surfaced on how to 

make the program as versatile as possible, while focusing on the key features. This 

script and the script [#scriptWriteMbsNonLin] are the answer to that question. 

The main function to set up the equations of motion is called calcEqMotNonLin, 

being called after every modeling. Therefore if any user wants to include his own 

software module, it should be somehow called from that file, making it available for 

all his models. As this file is one of the key parts, we do not want to disclose its 

contents and workings. The solution is that after some reading of options, checking 

the system, setting up the kinematics and performing some other small tasks, the 

file scriptCalcEqMotNonLin is called. In this script every user can insert his own 

function calls to custom made files at the necessary step in the progress chain. The 

user could also alter anything in this file to adjust the usual order and way of calling 

the functions, even though it is strongly recommended not to do this. 

If you are interested in writing your own module to connect it to Neweul-M², the 

preferred location is the modules folder. If you want to store data in the system data 

structure, you could do this under sys.elements, which is very flexible and all 

evaluations are distinguished by a type property. Thus if you specify your own type, 

you could easily store all data there. 


The results are stored in sys.eqm or returned directly, depending on the requested 

11 von 19 30.08.2011 17:47


evaluations. 

scriptWriteMbsNonLin 

Syntax 

scriptWriteMbsNonLin; 

Description 

Similar to scriptCalcEqMotNonLin, this script is called from writeMbsNonLin, 

which is the main function to write files after the equations have been set up. Please 

feel free to insert your own calls. 


No entry 

NE2minimal 

Syntax 

result = NE2minimal(varargin); 

Description 

This functio started as a nice way to obtain the minimal formulation if the Newton- 

Euler-Equations have already been set up. As the expressions of the equations of 

motion may contain non-scalar abbreviations, which then alter the dimensions visible 

for the user, this function provides additional functionality. It can remove all 

abbreviations, which is partly necessary for the minimal form and completely 

necessary for the symbolic linearization of the equations of motion. However, this 

function can also provide the expressions of the Newton-Euler-Equations as symbolic 

matrices and not as cell arrays as stored under sys.eqm. For any options on how to 

call the function to obtain the result you need, please have a look at the help 

message of this file. 


The results are stored in sys.eqm or returned directly, depending on the requested 

evaluations. 

calcCon 

Syntax 

calcCon(y,Dy,D2y); 

Description 

Calculates the constraint equations for kinematic loops. The subfunction 'comcon' 

checks for redundant constraint equations and tries to assure their independency. It 

does not cover all cases, so the user has some responsibility to define independent 

constraints. The subfunction 'con2loop' assigns the constraint equations to the loops. 

12 von 19 30.08.2011 17:47


There is a parameter under sys.par.eqm.constraints.index which specifies the index 

of the system of equations. If this index is set to 1, the constraint equations are used 

on acceleration level, for 2 on velocity and for 3 on position level. However, the user 

has to ensure that the integration algorithm can handle the selected constraints. 

This function only calculates the necessary derivatives of the constraint equations 

and will skip the remaining part. Under #writeMbsNonLin the parameter 

formulation is described, which is closely related to the index. 


The results are stored in sys.eqc. 

Contained subfunctions 

comcon 

con2loop 

calcForcesFelem 

Syntax 

[qa, felemStruct_, Data_] = calcForcesFelem(varargin); 

Description 

Calculates all forces from force elements like spring-damper combinations, i.e. 

everything stored under sys.felem. If nothing is specified, this function does exactly 

that. However, the user may explicitly give a structure of force elements, then this is 

used and only the contained force elements are considered for the force calculation. 


Entries have to be made by the user to the system data structure, so it is more 

versatile. 

Example 

calcForcesFelem; 

calcForcesReaction 

Syntax 

[qr, allRfelem] = calcForcesReaction(varargin); 

Description 

Calculate the necessary values for the evaluation of reaction forces. Depending on 

the options specified, the reaction forces are calculated symbolically in the 

respective frame of reference, or they are only calculated as in the Newton-Eulerequations 

and further evaluations are done numerically. 

Input parameters, all optional and pairwise, are 

13 von 19 30.08.2011 17:47


Option 

Description 

Logical parameter, if true, reaction forces are calculated 

fullySymbolic symbolically, otherwise a part has to be evaluated 

numerically 

Default 

Value 

true 

Output parameters 

Option 

Description 

qr 

Vector of reaction forces of the Newton-Euler-equations being 

calculated. 

Structure of artificial force elements, which have been used for the 

allRfelem 

calculation of the reaction forces. 


All vectors and matrices created in this function are stored under sys.eqm Output 

parameters 

Field 

Description 

Vector of reaction forces contained in the Newton-Eulerequations, 

usually is removed by the pre-multiplication with the 

sys.eqm.qr 

global Jacobian matrix 

Vector of reaction forces described in the respective frame of 

sys.eqm.g 

reference of the bodies, following the equation qr=Q*g 

Distribution matrix, which describes the correlation between 

sys.eqm.Q the local reaction forces g and the forces qr in the global 

Newton-Euler-equations 

sys.eqm.N Matrix used in the calculation, is calculated as Q.'*inv(Mq)*Q 

Vector containing all generalized applied, coriolis, centrifugal, 

sys.eqm.kAndqhat 

inertia forces usually stored as vectors k and q 

Example 

calcForcesReaction; 

kardan2rotmat 

Syntax 

S = kardan2rotmat(phi, formulation_) 

14 von 19 30.08.2011 17:47


Description 

When the user specifies a three parametric angular description, this function is used 

to obtain the rotation matrix. As a standard, kardan angles (rotation order: x-y-z) are 

used. However, any description using three parameters can be used by specifying 

the order of the rotation axis, e.g. 'zxz', [1 2 3]. The function rotmat2kardan covers 

the inverse operation. 


No entry 

Example 

S = kardan2rotmat(sym('[a1;b1;c1]'), 'xyz'); 

rotmat2kardan 

Syntax 

phi = rotmat2kardan(S, useSimplify, formulation_) 

Description 

From a given rotation matrix, this function extracts the three parameter angular 

description. As a standard, kardan angles (rotation order: x-y-z) are used. However, 

any description using three parameters can be used by specifying the order of the 

rotation axis, e.g. 'zxz', [1 2 3]. The function kardan2rotmat covers the inverse 

operation. 


No entry 

Example 

phi = rotmat2kardan(sym('[1,0,0;0,cos(a1),-sin(a1);0,sin(a1),cos(a1)]'), true, 'xyz') 

relativeKinematics 

Syntax 

relativeKinematics(y,Dy,D2y,Yvars_,Yvars_D_,ksys) 

Description 

Calculates the relative kinematic values of all coordinate systems recursively, 

y,Dy,D2y are symbolic vectors containing the generalized coordinates, their time 

derivatives respectively. yt is a taylor-series expansion up to the second order terms 

of the generalized coordinates. Yvars_, Yvars_D_ contain the state dependent 

parameters and their directional derivatives. ksys has to be passed as the start 

coordinate system because of the recursive algorithm. Depending on the type of the 

coordinate system the subfunctions calcKinRel, calcKinRelNode are called. 

15 von 19 30.08.2011 17:47



The results are stored in the respective coordinate systems under sys.ksys.(...).relkin 

absoluteKinematics 

Syntax 

absoluteKinematics(ksys) 

Description 

Starting from the relative kinematic values calculated by relativeKinematics absolute 

kinemativ values and values necessary for the equations of motion are calculated. 

Some interesting kinematic values can be obtained via the function 

getAbsoluteKinematics at need. This has been introduced to calculate them only 

when necessary and not always. 


The results are stored in the respective coordinate systems. Depending on the 

calculation mode and the frame type the respective reference system is different. 

Let's have a look at the coordinate system named ksys with the reference system 

refsys and ISYS shall denote the inertial system. For flexible bodies refsys denotes 

the frame which describes the nonlinear reference motion. The first column gives 

the name of the substructure in 'sys.ksys.ksys '. The second column denotes the 

fields of these substructures, whereas in the remaining columns the coordinate 

systems in which the vector/matrix is described are given. If a field is left empty, 

this means that this value is not calculated by default. 

Structure 

entry 

Value 

Absolute 

Kinematics 

'abs' 

Relative 

Kinematics 

'rel' 

symkin r_rel refsys refsys refsys 

symkin phi_rel refsys refsys refsys 

symkin/numkin r ISYS ISYS ISYS 

symkin/numkin S ISYS ISYS ISYS 

symkin/numkin S_rel refsys refsys refsys 

symkin/numkin v ISYS ISYS ISYS 

symkin/numkin a ISYS ISYS ISYS 

symkin/numkin omega ISYS ISYS ISYS 

symkin/numkin alpha ISYS ISYS ISYS 

calckin v ISYS ksys ksys 

calckin a ISYS ksys ksys 

calckin omega ISYS ksys ksys 

calckin alpha ISYS ksys ksys 

calcKin phi ISYS ksys ksys 

Nodal 

frame 

'rel' 

16 von 19 30.08.2011 17:47


calckin vq ISYS ksys ksys 

calckin aq ISYS ksys ksys 

calckin omegaq ISYS ksys ksys 

calckin alphaq ISYS ksys ksys 

calckin Jt ISYS ksys ksys 

calckin Jr ISYS ksys ksys 

calckin Je ksys 

calckin Jges ksys 

calckin Tt ksys 

calckin Tr ksys 

If the relative kinematics are selected the equations of motion are set up in each 

local coordinate system. For a rigid body this means in the frame in the center of 

gravity. For a flexible body this means in the reference frame. The reason why the 

values just mentioned are in this case all described in ksys itself is to ensure an 

easier code. If a body is defined from a nodal frame, this body will require the values 

of its reference frame, like velocity or jacobian matrix. If there were a difference 

between a rigid and a flexible body in the way in which the kinematical data is 

stored, this would require some distinction at this point. 

getabsoluteKinematics 

Syntax 

[result_,commonCSys] = getAbsoluteKinematics(kinematic, ksysFrom, ksysTo) 

Description 

It is reasonable to calculate only those absolute kinematic values which are actually 

necessary. This function provides the possibility to calculate symbolic expressions 

which are not calculated as a standard. Please see the function itself for which 

values are available, as this is still growing. The kinematic value should be specified 

as kinematic, and the two coordinate systems from and to which this value shall be 

evaluated symbolically. As the shortest available connection via the organizational 

tree of the coordinate systems is used, they are discribed in the commonCSys, which 

denotes the first coordinate system, where the two branches meet. If ISYS is one of 

the given coordinate systems, it will always be commonCSys as well. 


If one of the two coordinate systems is ISYS the resulting absolute values will be 

stored under sys.ksys.(...).symkin. 

Example 

[r, commonCSys] = getAbsoluteKinematics('r', 'ISYS', 'ksys1'); 

17 von 19 30.08.2011 17:47


mapleSimplify 

Syntax 

res = mapleSimplify(expr,varargin) 

Description 

Wrapper function to call the simplify command. The existance of this file enables the 

seamless switching between using Maple or MuPad as symbolic engine. 


No entry 

Example 

res = mapleSimplify(sym('x1^2+6*x1+9')) 

mapleSubs 

Syntax 

res = mapleSubs(expr,old,new) 

Description 

Wrapper function to call the subs or eval command to either replace symbolic 

parameters or to evaluate symbolic expressions. The existance of this file enables the 

seamless switching between using Maple or MuPad as symbolic engine. 


No entry 

Example 

res = mapleSubs(sym('x1^2+6*x1+9'),sym('x1'),sym('y2')) 

writeStructure 

Syntax 

writeStructure(structure) 

Description 

Handy function to simply write a structure. If nothing is specified, STDOUT is used 

for the fprintf commands. Can also be written to a file. The result is a printout of all 

substructures and fields together with its values so it could be evaluated to obtain 

the original data structure. 


No entry 

18 von 19 30.08.2011 17:47


Example 

writeStructure(sys.par.eqm) 

See also 

ITM Wiki 

neweulm2 






_Equations_of_Motion" 


19 von 19 30.08.2011 17:47

Neweulm2 - Simulation and Animation - IT M Wiki 

http://www.itm.uni-stuttgart.de/itmwiki/index.php?ti... 

Neweulm2 - Simulation and 

Animation 

From ITM Wiki 

Neweul-M² can be used just to create equations of motion and the corresponding 

m-files. But it also offers a great variety of possibilities for simulation and 

animation which will be presented in this paragraph. 

Contents 

1 Simulation and Analysis 

1.1 freqResPlot 

1.2 fullModelRun 

1.3 newOpt 

1.4 optiEvalFreqRes 

1.5 plotStandardResults 

1.6 printSystemInformation 

1.7 runKiAn 

1.8 runModalAnalysis 

1.9 runTimeInt 

1.10 runSensAn 

1.11 runSysOpt 

2 Auxiliary functions for the simulation 

2.1 calcNomLength 

2.2 freqResponse 

2.3 initOpt 

2.4 kinematicAnalysis 

2.5 modalAnalysis 

2.6 staticEquilibrium 

2.7 timeInt 

2.8 writeFinalCond 

3 Animation 

3.1 Functions to be called directly by the user 

3.1.1 addGraphics 

3.1.2 animFreqResponse 

3.1.3 animModeShape 

3.1.4 animTimeInt 

1 von 26 11.11.2011 18:06



3.1.5 createAnimationWindow 

3.1.6 defineGraphics 

3.1.7 drawCube 

3.1.8 drawElasticBeam 

3.1.9 drawLine 

3.1.10 drawMesh 

3.1.11 drawRotBody 

3.1.12 drawSphere 

3.1.13 drawSpring 

3.1.14 drawSTL 

3.1.15 fitCanvas 

3.1.16 plotTrajectories 

3.1.17 setVisibility 

3.1.18 showModeShape 

3.1.19 transformGraphics 

3.1.20 updateGeo 

3.2 Functions called internally 

3.2.1 drawSys 

3.2.2 initGraphics 

4 See also 

4.1 ITM Wiki 

Simulation and Analysis 

Simulation 

Command 

Description 

freqResPlot 

Plot the frequency response from given inputs to 

outputs at certain frequency sample points 

fullModelRun 

Set up the system and run all predefined simulations 

printSystemInformation Print some information about the system 

runKiAn 

Perform a kinematic analysis after setting all 

necessary values 

runmodalAnalysis 

Perform a modal analysis after setting all necessary 

values 

runTimeInt 

Perform a numerical time integration after setting all 

necessary values 

2 von 26 11.11.2011 18:06



runSensAn 

runSysOpt 

Calculate the gradient with respect to a given 

criterion function and design parameters 

Perform a parameter optimization of a given criterion 

function and design parameters 

Auxiliary functions for the simulation 

Command 

Description 

Calculate the nominal length of all force elements if at the 

calcNomLength initial conditions those elements are 

unstretched/compressed 

freqResponse 

Calculate the transfer function from certain system inputs 

to outputs at given frequency sample points 

initOpt 

Set options for a parameter optimization 

modalAnalysis Perform a modal analysis 

staticEquilibrium Calculate the static equilibrium numerically 

timeInt 

Perform a numerical time integration after some setting up 

and checking 

writeFinalCond 

If a final condition for the time integration is given, this 

function will do all necessary steps 

Animation 

Command 

Description 

addGraphics 

Attach a graphic surface object at a given coordinate 

system 

animModeShape Animate a mode shape after a modal analysis 

animTimeInt 

Animate the result of a numeric time integration, 

kinematic analysis, ... 

Create a new animation window, keeping current 


settings as far as possible 


Script in which the user can define graphic objects 

drawCube 

Create cuboid graphic representation 

drawLine 

Draw a line connecting several coordinate systems 

drawRotBody 

Create an axis rotational solid representing e.g. a 

body 

drawSphere 

Create a spherical graphical representation 

3 von 26 11.11.2011 18:06



drawSTL 

fitCanvas 

plot_trajectories 

setVisibility 

showModeShape 

transformGraphics 

updateGeo 

Read data from a CAD geometry file (.stl) and create 

a graphical representation from it 

Adjust the axis scaling so the animation will stay 

visible during its run 

Function to create and update trajectories of 


Change visibility settings of all objects or classes of 

objects in the animation window 

Statically display mode shapes of a modal analysis 

Before attaching graphic representations to a 

coordinate system, this function can give them a 

constant translational or rotational offset 

Update the animation window to a certain time and 

set of generalized coordinates 

Auxiliary functions for the animation 

Command 

Description 

drawSys 

Create all necessary representations for a system in the 

animation window, called from createAnimationWindow 

Initialize settings and create an animation window, called from 

initGraphics 


freqResPlot 

Syntax 

[fh,ah,g] = freqResPlot(t,in,out,freqs,varargin); 

Description 

Creates a bode plot of the frequency response at given time t, from input in to 

output out for frequencies freqs. In varargin other options can be passed. It 

returns the figure fh, axes handles ah and the frequency response matrix g. 

Uses the function frequencyResponse to evaluate the transfer functions. 

Optional input arguments provide access to several settings like using certain 

groups of in- or outputs. 


No entry 

4 von 26 11.11.2011 18:06



Example 

freqRespPlot; 

freqRespPlot(0,'MyInput','MyOutput',[1:10:100]); 

fullModelRun 

Syntax 

fullModelRun(varargin); 

Description 

When a user does not yet know exactly how to use the software, this command is 

very useful. When it is called from an examples folder, first the system definition 

is called and the equations are set up. Then all available simulations for this 

model are called. This allows the user to easily call the provided files and to 

investigate the system later. This function is also called by the graphical 

gettingStarted user interface. 


No entry 

Example 

fullModelRun; 

fullModelRun('DisplayCommands',true); 

newOpt 

Syntax 

[res_, opts] = newOpt(varargin); 

Description 

This function combines all currently available ways for a parameter optimization 

or sensitivity analysis in one function. This incorporates the previously used 

functions optiEvalFreqRes, runSensAn and runSysOpt. Here all options stored 

under sys.par.opt are used, but the user can specify options in the usual 

pairwise manner. 


sys.results.opt 

Example 

newOpt; 

5 von 26 11.11.2011 18:06



optiEvalFreqRes 

Syntax 

res_ = optiEvalFreqRes(varargin); 

Description 

There are many ways to conduct a parameter optimization of a mechanical 

system. One very fast and useful way is to use the transfer functions between 

system in- and outputs. Of course this uses a linear system formulation, which is 

not always suitable. But the great advantage is the speed and the simple usage 

of many transfer functions at once. As a standard, all available transfer 

functions are evaluated at the given frequencies, then for each frequency the 

maximum amplitude of all functions is determined. Over the complete set of 

frequency points, a certain number of maximum values is selected. These points 

represent the most critical combinations of transfer function and frequency. The 

double selection is necessary to avoid a certain independency from the number 

of system in- and outputs and frequency set points. For the selected points, the 

amplitudes of the transfer functions is summed and used as a criterion. This 

selection process is conducted in every optimization step, which has shown to be 

quite a good way to cover even complex systems. The design parameters are 

scaled to ensure good behavior of the optimization algorithm. All options are set 

in initOpt.m or any other options file, then being specified explicitly. 


sys.results.opt 

Example 

optiEvalFreqRes; 


Syntax 

plotStandardResults('Option1','Value1'); 

Description 

If you want to plot any curve derived from a result in Neweul-M², this 

function is the place to try first. 

Very often similar calculations and plots are carried out with Neweul-M². This 

function provides a selection of the plots which are created most often. This 

includes plots of the states, trajectories of coordinate systems, system outputs 

and others. A complete list can be found in its help commentary. This function 

6 von 26 11.11.2011 18:06



provides a large number of options, concerning both, the data to plot and its 

formatting and output. A very useful feature is that the calculated data is 

available as second output argument. This provides a very simple way to obtain 

trajectories, system outputs and other data at specific time points. 


no entry 

Example 

plotStandardResults; 

plotStandardResults('Type','constraints','subplot',true); 

printSystemInformation 

Syntax 

printSystemInformation('Option1','Value1'); 

Description 

Even though Neweul-M² can handle very different types of systems, there are 

some things which are good to know about systems. So this function was 

developed as a collection of commands to display information which I used to 

look up for systems I could lay my hands on. For example when one of the users 

had a problem with a model, then I used to look for some structure of the 

coordinate systems, the generalized coordinates have been used in which 

definitions, where do we have force elements, ... . At some point we created a 

function which would display all this information with just one command. At a 

later point in time, this function was extended to also provide numerical 

information about the system, meaning positions, orientations, mass properties, 

... for given states. This is especially useful when a system has been modeled in a 

different software before or measured from a real structure. Then one can easily 

verify the model by comparing the positions of some coordinate systems. Please 

type help printSystemInformation for more information on how to adjust the 

function to your needs. This function can be called from the GUI from the 

System Information menu item. 


no entry 

Example 

printSystemInformation; 

printSystemInformation('all'); 

printSystemInformation('numerical',true,'y0',0.1*ones(sys.dof,1)); 

7 von 26 11.11.2011 18:06



runKiAn 

Syntax 

runKiAn; 

Description 

Sets Parameters, runs a kinematic analysis and animates the results. 


Parameters are stored in sys.par.kian, results in sys.results.kian. 

Example 

runModalAnalysis 

Syntax 

runModalAnalysis; 

Description 

Set options, run a modal analysis and display the results. This file calls 

#modalAnalysis and #showModeShape. It can be used to set specific options, 

otherwise these functions may be called directly as well. 


Results are stored in sys.results.modal. 

Example 

runTimeInt 

Skript to set all necessary parameters and then start a time integration of the 

system. Syntax 

Description 

The script runTimeInt.m initializes all parameters necessary for a numeric 

time integration and animation of the equations of motion before calling the 

functions to perform this task. The functions that are called from 

runTimeInt.m are in this order 

Function name 

Tasks 

Calculating the static equilibrium of the system to be able 

staticEquilibrium.m to define initial conditions relative to the equilibrium. 

This only works for systems without kinematic loops. 

timeInt.m 

Run the numeric time integration with the given options. 

8 von 26 11.11.2011 18:06



fitCanvas.m 

plot_trajectories.m 

animTimeInt.m 

Adjust the visible area in the animation window so the 

complete motion of all coordinate systems can be seen. 

Plot a line along the trajectory of the given coordinate 

systems. This line remains static while the coordinate 

system moves along it during the animation. 

Animate the result of the time integration with the 

defined coordinate systems, lines and shapes. 


Options are stored in sys.par.timeInt, while results are stored in 

sys.results.timeInt. 

Example 

runSensAn 

Syntax 

runSensAn(varargin); 

Description 

Performs a sensitivity analysis, where all settings are done in initOpt.m, which 

can be found in each model folder. Optional parameters are only for the call 

with the GUI. Currently there are three methods available: 

Finite Differences, basic method but slow with big errors 

Direct Method, good choice if there are not too many design variables 

Adjoint Variable Method, especially good with many design variables, has 

larger errors for kinematic loops 

This task requires some calculations and therefore the following routines have 

been created 

Function name 

Tasks 

initOpt.m 

Set all options for the calculation, to be edited by user 

Matrices_grad.m Calculation of Matrices of partial derivatives 

OptiCalcInitCon.m Calculate initial conditions 

Calculate the function value and the gradient with the 

OptiEval_adj_sep.m 

adjoint variable method 

Calculate the function value and the gradient with the 

OptiEval_dir_tog.m direct method, where the sensitivity equations and the 

equations of motion are integrated together. 

9 von 26 11.11.2011 18:06



write_psi.m Create files from the definition of the function criterion 

writeOptiDirect.m Create all files necessary for the direct method 

writeOptiAdjoint.m Create all files necessary for the adjoint variable method 


Parameters are stored in sys.opt and results in sys.results.opt. 

Example 

runSysOpt 

Syntax 

runSysOpt(varargin); 

Description 

Performs a parameter optimization, currently with the included Matlab 

optimization algorithms. For other options and settings see runSensAn. 


Parameters are stored in sys.opt and results in sys.results.opt. Example 

Auxiliary functions for the simulation 

Here some functions are presented which can be quite useful but don't really 

make a simulation of their own. In addition they are often not directly called by 

the user but through some intermediate routines. 

calcNomLength 

Syntax 

calcNomLength(varargin); 

Description 

Determines the nominal lengths of force elements from given initial conditions. 

Then these initial conditions describe the state where all force elements have 

zero forces. Optionally the initial values can be passed. As numerical values are 

necessary it has to be called after initSys. 


Changes values of parameters, but doesn't create new entries. 

Example 

10 von 26 11.11.2011 18:06



freqResponse 

Syntax 

g = freqResponse(t,in,out,freqs,varargin); 

Description 

Calculates the frequency response g from input in to output out, where both 

can be vectors at given time t. This is evaluated at the frequencies defined in 

freqs. If the equations of motion have been linearized symbolically they are used 

as a standard. However, should they be unavailable, the necessary values are 

calculated numerically using finite differences. 


Example 

g = freqResp(0,'MyInput','MyOutput',[1:10:100]); 

initOpt 

Syntax 

initOpt; 

Description 

This is a script which can be located in the model folders. If it exists, it is called 

during a sensitivity analysis and parameter optimization. Sets all options for a 

sensitivity analysis or parameter optimization. For more information, please first 

have a look at one of the provided examples and their version of this file. Then 

depending on the desired optimization, please investigate their options. The file 

initOpt is just a collection of options, where those unnecessary for the current 

optimization are simply ignored. 


Everything is stored in sys.par.opt. 

Example 

kinematicAnalysis 

Syntax 

kinematicAnalysis(varargin); 

Description 

Performs a kinematic analysis, which means that the user may prescribe 

functions for independent generalized coordinates. These functions will be 

11 von 26 11.11.2011 18:06



evaluated, which can be used to investigate special configurations, reachable 

space of a robot or other such things. Please note, that here only the kinematics 

is investigated, meaning that all forces, torques or other effects are neglected. 

Constraint equations are respected. 


sys.results.kian 

Example 

kinematicAnalysis; 

modalAnalysis 

Syntax 

modalAnalysis(t,varargin); 

Description 

Performs a modal analysis of the system with the default settings and without 

display. For a display of the Eigenmodes please see showModeShape. The 

Parameter t defines the time at which the matrices are evaluated. No optional 

parameters available yet. 


sys.results.modal 

Example 

modalAnalysis(0); 

staticEquilibrium 

Syntax 

[ye,res] = staticEquilibrium(t,ys,Options); 

Description 

Calculates the static equilibrium ye of the system at time t to initial guess ys. 

The residual of this root finding is returned as res, which should be zeros. In 

Options additional options for the root finding can be passed. All parameters 

are optional. 


Results are to be stored in sys.results.statEq, has to be selected by the user. 

Example 

12 von 26 11.11.2011 18:06



[ye,res] = staticEquilibrium(sys.par.timeInt.t0, zeros(sys.dof,1)); 

timeInt 

Perform a time Integration of the equations of motion. This includes all 

preparations because of possible options set in runTimeInt. 

Syntax 

result = timeInt(y0,Dy0, 'parameter1','value1', ...) 

Option Description Default value 

y0 Initial conditions for the position. 

sys.par.timeInt.y0 or 

zeros 

Dy0 Initial conditions for the velocity. 

sys.par.timeInt.Dy0 

or zeros 

'linear' Uses the linearized equations of motion. false 

'integrator' Specify the integration algorithm. 

@ode45 

'intOpts' Integration options structure. odeset; 

't0' or 't1' Initial or final time of the integration. 0 or 10 

'time' Time vector, equal to [t0 t1]. [0 10] 

'display' 

Display during integration, one of this list: 

'waitbar','odeplot','animation','none'. 

'none' 

'waitbar' Display a progress bar during integration. false 

'Function' Specify the function to be integrated. @eqm_nonlin_ss 

There are some other options available, which are also available through the 

parameters stored in sys.par.timeInt. 

Description 

Before starting the time integration some preparations take place 

Creating functions for the final conditions. 

Check if the integration algorithm is valid for this system. 

If the system contains kinematic loops, calculate consistent initial 

conditions. 

Set all necessary options. 


Returns a structure similar to the result of Matlab ode-solvers extended by the 

calculation time and information whether the linear or nonlinear system has 

been integrated. 

13 von 26 11.11.2011 18:06



Example 

sys.results.timeInt = timeInt(y0, Dy0); 

sys.results.timeInt = timeInt(ones(sys.dof,1),zeros(sys.dof,1), 'integrator',@ode45, ... 

'intOpts',odeset, 'time',[0,10], 'linear',' '); 


Syntax 


Description 

Usually the time integration goes over the complete time interval [t0, t1]. This 

function enables the user to define a condition, so the integration can be 

stopped when a certain condition changes its sign. If a final condition for the 

time integration is stored in the structure sys, this creates the necessary file 

(sysFunctions/finalCond.m) and options. 


The final condition is stored in sys.par.timeInt.finalCond 

Example 

Animation 

Functions to be called directly by the user 

addGraphics 

Syntax 

addGraphics(CoordSys, ObjectHandle, createEntry); 

Description 

Attaches created primitives with handle ObjectHandle to a given coordinate 

system CoordSys. With the boolean parameter createEntry the insertion into 

the system data structure can be avoided. Otherwise all surface or patch objects 

are stored in sys.graphics.surfaces 


sys.graphics.surfaces 

Example 

14 von 26 11.11.2011 18:06



ObjectHandle = drawSphere([0 0 0],0.02,20,'red'); 

addGraphics('BODY1_cg', ObjectHandle); 

animFreqResponse 

Syntax 

[result ye_ t_] = animFreqResponse(t,in,freq,varargin); 

Description 

Evaluate the frequency response from input in to all generalized coordinates at 

frequency freq and animate it. 


If nothing is specified, results are stored under sys.results.freqResponse in the 

common format. 

Example 

animFreqResponse(0,'myInputID',300); 

animModeShape 

Syntax 

animModeShape(modalResults, OrderOfMode, varargin); 

Description 

Performs an animation of a given mode shape with index OrderOfMode, 

calculated by a prior call of ModalAnalysis.m. Optional parameters can be 

used for further options 


Amplitude Amplitude of the eigenmode 1 

FramesPerPeriod Specify number of frames for each period 40 

TimePerPeriod Set period duration 2 

Repetitions Set number of repetitions 3 


Example 

animModeShape(sys.results.modal,1); 

15 von 26 11.11.2011 18:06



animTimeInt 

Animation of results of a time integration or similarly stored results. 

Syntax 

animTimeInt(tisol, 'Parameter1','Value1', 'Parameter2','Value2') 

Description 

Animates the motion described by a result as from a time integration. Therefore 

also the result of a kinematic analysis can be used. 

Parameter 

Description 

Default 

value 

tisol Structure with integration result as of ode45 - 

'TimeStep' Stepsize for animation time 'Optimal' 

'Stride' Real time factor, e.g. slow motion 1 

'CenterCS' 

Centers the view during the animation to this 

Coordinate system 

- 

'Record_avi' 

Records animation, i.e. a movie, to the 

.avi-filename passed as argument 

- 

'Print_frames' 

Print all frames of the animation to the folder 

specified as second value 

- 

'Resolution' Set resolution for 'Print_frames' in dpi 600 

Usually the trajectories are updated 

'plot_trajectories' 

automatically, but can be switched off 

true 

If 'TimeStep' is passed with 'Optimal' as an argument the optimal time step size 

is decided automatically. If nothing is specified, the result of the time 

integration is used. 


Example 

animTimeInt; 


Syntax 

createAnimationWindow(varargin); 

Description 

16 von 26 11.11.2011 18:06



If an animation window exists, it is closed. All other plot windows are unaffected. 

Then a new animation window is made, including any previously defined graphic 

objects, no matter if lines, markers, surfaces, patches, ... . This function was 

created to simplify the creation of an animation window. Therefore no matter 

what is available, exists or has been defined previously, this function is meant to 

recreate it as close as possible. Therefore all settings should be checked so it 

always works. Currently no options are available. 


Example 

createAnimationWindow; 


Syntax 


Description 

Script which the user has to write, to define graphic visualizations of the bodies. 

This includes the creation of primitives described below, e.g. 

drawCube Draw cuboids 

drawLine Draw lines connecting two coordinate systems 

drawRotBody Draw rotational bodies, open or closed 

drawSphere Draw spheres 

drawSTL Read .stl files from CAD-softwares and draw corresponding shapes 

transformGraphics Transform graphic objects in position and orientation 

with respect to their governing coordinate system. This function is for 

constant offsets not for an animation. 


Example 

drawCube 

Syntax 

h = drawCube(CenterVect,dx,dy,dz,color,varargin); 

Description 

Creates a cuboid in the animation window with handle h. This cuboid is centered 

at CenterVect(1x3), with the side lengths dx, dy, dz and a given color. It has to 

be attached to a coordinate system with addGraphics. 

17 von 26 11.11.2011 18:06



As optional input arguments the following are possible 

Option 

Description 

Default 

Value 

Tag Specify the tag of this object 'Cube' 

Color of the faces, overwrites the previously given 

FaceColor 

color, available to unify creation of shapes. 

[0 0 1] 

EdgeColor Color of the edges 

'none' 

Color Set face and edge color - 

FaceAlpha Set transparency of the faces 1 

EdgeAlpha Set transparency of the edges 1 


No entry 

Example 

h = drawCube([0 0 0], 0.3,0.1,0.1, 'blue'); 

drawElasticBeam 

Syntax 

handle = drawElasticBeam(lineID, varargin); 

Description 

After adding a line element with drawLine this function can be used to asign a 

certain crosssection to this line. The crosssection can be specified arbitrarily or 

one of the predefined ones (rectangle, circle or triangle can be used. If desired 

the faces can be removed by setting the 'FaceColor' option to 'none' or they can 

be transparent. As is common, non-required options are to be given in 

argument/value pairs. 


See sys.graphics.surfaces. 

Example 

drawElasticBeam('myLine','Sidelengths',0.1); 

drawElasticBeam('myLine','Triangle',0.15,'FaceColor','none'); 

drawLine 

18 von 26 11.11.2011 18:06



Syntax 

[handle, error_msg] = drawLine(ListofFrames, ID, varargin); 

Description 

Adds a line object to the animation window, which connects the coordinate 

systems specified in ListofFrames. If two are given, they are connected with a 

straight line, more coordinate systems are connected by splines. For 

identification it is assigned an ID, other options are optional in varargin. These 

additional options are to be given pairwise and all of Matlab's line options are 

available, as they are passed straight through. 


See sys.graphics.line. 

Example 

drawLine({'BODY1', 'BODY2_cg'}, 'MyLine','Color',[0 1 1]); 

drawMesh 

Syntax 

h = drawMesh(ID_,varargin) 

Description 

Depending on the software used to model the elastic bodies and perform the 

model reduction, so called 'mesh' data is available. This is usually the complete 

outer surface of the elastic body, which can then be used for an animation. If 

such data is available, this function is called automatically at body definition. 

This function also provides options to change settings like the color of the 

graphical representation. 


See sys.graphics.surfaces.Mesh_1. 

Example 

drawMesh('BODY1','FaceColor',[1 0 0]) 

drawRotBody 

Syntax 

h = drawRotBody(rvec,zvec,varargin) 

Description 

Creates a rotational solid in the animation window with handle h. The 

19 von 26 11.11.2011 18:06



crosssection which is rotated around the z-axis is defined by coordinate pairs of 

support points rvec, zvec. It has to be attached to a coordinate system with 

addGraphics. 



Tag Specify the tag of this object 'RotBody' 

FaceColor Color of the faces [0 0 1] 

EdgeColor Color of the edges [0 0 1] 




NumPoints Number of interpolation points on circumference 32 


No entry 

Example 

h = drawRotBody([0.025 0.025],[0 1]); 

h = drawRotBody([0.025 0.025],[0 1], 'FaceColor','yellow', 'EdgeColor','green'); 

drawSphere 

Syntax 

h = drawSphere(CenterVect, r,n, color, varargin); 

Description 

Creates a sphere in the animation window with handle h. This sphere is centered 

at CenterVect(1x3), with the radius r, n interpolation points around the 

circumference and a given color. It has to be attached to a coordinate system 

with addGraphics. 



Tag Specify the tag of this object 'Sphere' 

EdgeColor Color of the edges 

'none' 


20 von 26 11.11.2011 18:06






No entry 

Example 

h = drawSphere([0 0 0],0.2,20,'red'); 

drawSpring 

Syntax 

drawSpring(ksys1, ksys2, ID, varargin); 

Description 

Creates a representation of an elastic spring connecting two coordinate systems 

ksys1 and ksys2. As optional inputs some specifications of the line and the 

dimensions of the spring can be given. 


No entry 

Example 

drawSpring('KSYS1','KSYS2','mySpring'); 

drawSpring('KSYS1','KSYS2','mySpring', 'Color',[1 0 0], 'diameter', 10); 

drawSTL 

Syntax 

h = drawSTL(filename, c, dx, dy, dz, fcolor, ecolor, varargin); 

Description 

Reads an STL file from filename which can be created with a CAD program and 

creates the corresponding shape in the animation window. This shape is located 

at the centervector c with scaling factors for all axis directions dx, dy, dz. The 

color of the faces is set to fcolor and the color of the edges to ecolor. The 

handle is returned in h, it has to be attached to a coordinate system with 

addGraphics. 


21 von 26 11.11.2011 18:06




Tag Specify the tag of this object 'STL' 





No entry 

Example 

h = drawSTL(myshape.stl, [0 0 0], 1, 1, 1, [0 0 1], [0 1 0]); 

fitCanvas 

Syntax 

fitCanvas(figureOpt, varargin); 

Description 

Scales the axes in the animation window so the most recent simulation result fits 

in nicely. figureOpt is one of the following: 

'square' the same as if you type axis square by hand 

'small' the same as if you type axis small by hand 

'equal' the same as if you type axis equal by hand 

'CenterCS' allows you to center the animation to a given coordinate system. 

For more information type help fitCanvas in Matlab. 

There are some optional Parameters you can use, which are described in the file. 


No entry 

Example 

fitCanvas('equal'); 

plotTrajectories 

Syntax 

[curves, csys_names] = plotTrajectories(csys_specifier, varargin); 

22 von 26 11.11.2011 18:06



Description 

Creates a line along the trajectory of a given coordinate system csys_specifier 

and optionally plotting options. When called without arguments all lines are 

updated. To reset everything call plotTrajectories('reset'). This function is 

usually called after a time integration, but can be called already in the modeling 

step. With the option 'Refine' a factor for the number of interpolation points can 

be specified, e.g. by calling plotTrajectories('Refine',2); twice as many 

interpolation points are used. In curves the support points are returned, while 

in csys_names the names of the corresponding coordinate systems are 

available. 


All the information is stored under sys.graphics.marker. Each line gets one 

substructure, called as its corresponding coordinate system. Most entries are 

optional, specifying line properties. A default structure for coordinate system 

csys1 looks like 

sys.graphics.marker.cys1.tag = 'automark_csys1'; 

Example 

plotTrajectories('BODY1'); 

setVisibility 

Syntax 

setVisibility(Vis, varargin); 

Description 

Sets the visibility of objects to Vis ('on'/'off'). Optionally you can select which 

object shall be changed. 


No entry 

Example 

setVisibility('on'); % Switches everything on 

setVisibility('off','Type','Text'); % Disables the text 

setVisibility('off','Body','BODY_1'); % Makes 'BODY_1' invisible 

showModeShape 

23 von 26 11.11.2011 18:06



Syntax 

[myFigs,myAxes] = showModeShape(modalResults,n,varargin); 

Description 

Displays the all or the given modeshapes. The modeshapes should be available in 

modalResults, while the index of a certain mode shape n can be specified. 


Option 

Description 

Default 

Value 

Amplitude Amplitude for the mode shape 1 

ShowRefPos 

Parameter if the reference position is to be 

displayed 

'off' 

RefPosTransparency Transparency of the reference position 0.5 

AdjustFigure Option if figure size is to be adjusted true 


Example 

showModeShape(sys.results.modal, 2); 

transformGraphics 

Syntax 

transformGraphics(h,varargin); 

Description 

Move and rotate the graphic object with handle h. This changes the position and 

orientation of a graphic object relative to its describing coordinate system, 

which is moved during an animation. So it is a static translation or rotation. 



Translation Move graphic object [0 0 0] 

RotationAngles Kardan angles to rotate the object [0 0 0] 

RotationMatrix Specify rotation matrix to rotate object eye(3) 

RotationOrigin Specify the point of reference for the rotation [0 0 0] 

24 von 26 11.11.2011 18:06




No entry 

Example 

transformGraphics(h,'RotationAngles',[0,-0.5*pi, 0]); 

updateGeo 

Syntax 

updateGeo(t,y); 

Description 

Dynamically update the animation window to a given time t and a position vector 

y. If no input arguments are specified but an animation window exists, the same 

configuration is used, otherwise all values are initialized with zeros. 


No entry 

Example 

updateGeo(0,zeros(sys.dof)); 

Functions called internally 

drawSys 

Syntax 

drawSys(ksyslist); 

Description 

Creates coordinate systems and assigns them to the hggroups created by 

initGraphics. A list of coordinate systems can be specified, otherwise all are 

used. In former versions this function has been called directly by the user, now 

this task is done by #createAnimationWindow. 


initGraphics 

Syntax 

initGraphics(varargin); 

25 von 26 11.11.2011 18:06



Description 

Creates and initializes a figure window. This function is the first to be called. In 

former versions this function has been called directly by the user, now this task 

is done by #createAnimationWindow. 



KsysArrowSize 

Size of the arrays of coordinate 

systems 

0.08 

KsysArrowColors Colors of the vectors {'red','yellow','blue'} 

Number of points on 

KsysArrowNumPoints 

circumference 

10 

KsysArrowShapeRatio Ration length/thickness of arrows 1/20 

KsysFontSize Fontsize for labels 12 


sys.graphics 

Example 

initGraphics; 

See also 

ITM Wiki 

neweulm2 






_Simulation_and_Animation" 

This page was last modified 12:13, 10 November 2011. 

26 von 26 11.11.2011 18:06

Neweulm2 - Exporting - IT M Wiki 

Neweulm2 - Exporting 

From ITM Wiki 

Neweul-M² offers a few possibilities to create files to export some parts of the 

model. 

Contents 

1 Export data from Neweul-M² 

2 Functions to be called by the user 

2.1 exportEqMot 

2.2 writeAnimGeo 

2.3 writeSfunction 

2.4 writeStrFile 

2.5 writeSysDef 

2.6 Loading and Saving 

3 Auxiliary functions 

3.1 mcode2c 

3.2 symStruct2num 

4 See also 

4.1 ITM Wiki 

Export data from Neweul-M² 

Overview over available files: 

Command 

exportEqMot 

writeAnimGeo 

writeSfunction 

writeStrFile 

writeSysDef 

Description 

Export equations of motion to be independent of the system 

data structure 

For an animation in Anim, write the geometry files 

Write the equations of motion to a Simulink S-function in C 

For an animation in Anim, write the simulation specific 

data 

Write the inputfile sysDef.m for the current model 

1 von 6 30.08.2011 17:48


Loading and 

Saving 

Loading and saving of systems is described under system 

definition 

Auxiliary files 

Command 

Description 

Replace symbolic constants by numerical values in a given 

symStruct2num 

data structure 

mcode2c Convert Matlab Syntax of symbolic expressions to C-code 

Functions to be called by the user 

exportEqMot 

Syntax 

exportEqMot(varargin); 

Description 

Write the equations of motion, or some interesting values to a file, where all 

parameter values are defined in the file itself. This makes it independent of the 

global structure sys. Therefore it is called export, because there is no way back 

to the actual system. 


No entry 

Example 

exportEqMot; 

exportEqMot('Linear',true,'Symbolic',false); 

exportEqMot('Expression',sys.lin.eqm,'Symbolic',false,'WhiteList',{'alpha_s','Dalpha_s'}); 

writeAnimGeo 

Syntax 

writeAnimGeo; 

Description 

In order to perform an animation with Anim some files are necessary. One 

should create representations for the bodies (*.geo), a file with a list of all those 

2 von 6 30.08.2011 17:48


representations (*.geoall) and one file containing the positions and orientations 

of the corresponding frames of reference. This function creates all simulation 

independent files, meaning the first two of this list for the geometry. For the 

simulation data, please have a look at writeStrFile. Currently there are no input 

parameters available. The list of all geometries is called [sys.id,'.geoall'] and for 

every surface object in the animation window one .geo file is created with the 

name of the corresponding data substructure being the filename followed by 

.geo. These names are not too clear, as they are called e.g. 'Cube_1.geo', but 

they are definitely unique. 


No entries 

Example 

writeAnimGeo; 

writeSfunction 

Syntax 

writeSfunction(S_name, mode); 

Description 

Exports the equations of motion to a Simulink S-Function, which is written in C. 

Therefore the filename S_name has to be passed and the file will be created in 

the folder sysFunctions and readily compiled. Another file for the initialization 

will also be created but the function will print an explanation during its call. The 

parameter mode can be either 'linear' or 'nonlinear' describing which equations 

of motion are to be exported. 

In Simulink there are quite a few parameter names which are already 

assigned a specific value and purpose. This can cause problems, as this 

includes names like 'm' or 'S'. But there is no list of these names 

available. 

Currently this functionality is under development, so check for changes in the 

release notes. 


No entry 

Example 

writeSfunction('MySFunction.c', 'nonlinear'); 

3 von 6 30.08.2011 17:48


writeStrFile 

Syntax 

writeStrFile(tisol, deltat, varargin); 

Description 

Creates a .str file for an animation with anim. The other files, e.g. geometry, 

have to be provided by the user. As input a result of a time integration or other 

motion tisol has to be provided. A time stepsize deltat for the animation has to 

be given. If nothing else is specified the file has the name of the system ID. 

Optional input arguments are: 

'Filename','MyFile.str' Sets the filename to MyFile.str 

'CoordinateSystems',{'CSYS1','BODY1_cg'} Writes data only for these 


'CoordinateSystems','cg' Writes data only for centers of gravity of all bodies 


No entries 

Example 

writeStrFile(sys.results.timeInt, 0.05, 'CoordinateSystems','cg') 

writeSysDef 

Syntax 

writeSysDef(sysDefName); 

Description 

From the data stored in the structure sys this function creates the necessary 

input file to recreate the system. In a former version two files have been created, 

but now only sysDef.m is written containing all system definitions (bodies, force 

elements, ...). This allows the user to switch from the GUI to the command or 

input file based mode. The filename to which the system is exported can be 

specified in sysDefName. Now also all graphic objects, meaning surface/patch 

objects, dynamic lines and trajectories are exported to this file. This is possible 

because constants can be given a numerical value immediately and information 

on graphic objects is available in the data structure. So then only one file is 

necessary to store the complete information in one file. 


No entries 

Example 

4 von 6 30.08.2011 17:48


writeSysDef; 

Loading and Saving 

To load or save a system to a .mat file and its animation window to a .fig file, 

please see neweulm2 - System Definition#Loading and Saving 

Auxiliary functions 

mcode2c 

Syntax 

outputvect = mcode2c(inputvect); 

Description 

For a given symbolic array inputvect this function returns C-code syntax 

evaluating this expression. This includes e.g. changing power signs and ensuring 

that all numerical values are of type double. 


No entry 

Example 

outputvect = mcode2c(sys.eqm.M); 

outputvect = mcode2c(sys.eqm.M(1,1)); 

symStruct2num 

Syntax 

exprStruct_ = symStruct2num(exprStruct_, whiteList_); 

Description 

In the data structure exprStruct_ all symbolic parameters previously declared 

as constants are replaced by their corresponding numerical values, unless those 

parameters in the cell array whiteList_, which are kept. A similar data 

structure is returned as exprStruct_. If the input data structure is only one 

array, the output has the same dimensions and data type. 


No entry 

Example 

5 von 6 30.08.2011 17:48


exprStruct_ = symStruct2num(sys.eqm, {'g','alpha'}); 

See also 

ITM Wiki 

neweulm2 






_Exporting" 

This page was last modified 15:40, 30 June 2011. 

6 von 6 30.08.2011 17:48

Neweulm2 - Programming tips - IT M Wiki 


Neweulm2 - Programming tips 

From ITM Wiki 

Contents 

1 Programming tips 

1.1 Comments 

1.2 Variable names 

1.3 File names 

1.4 Conditionals and loops 

1.5 Graphic user interfaces 

1.5.1 Useful hints to design a new GUI 

2 See also 

Programming tips 

The most important rule is: 

Upload only files on the server, that run without errors! 

There will always be some bugs left to be found later when adding new 

features, but please test your files before commiting them. 

Do a spell checking on all your prompts, printouts and labels. 

Remember that the program has to run not only on the institutes Linux 

computers, but on other ones, e.g. with Windows as well. A useful 

command in Matlab for this is 'filesep', which gives you the correct divider 

(/ or \) for the current machine. Please avoid calling any non-Matlab 

commands, as they are usually not portable between different operating 

systems. 

A difficult thing to check is whether you are using a certain toolbox. If you 

are using a toolbox which not everyone might have, a fallback solution is 

very useful, which can run without the special features. Of course this 

fallback will offer less functionalities. 

Try to write the program so it checks if all information exists properly. 

Examples for this is ensuring linearized equations of motion for a modal 

analysis, or missing entries in the global variable gui for graphic 

applications. 

1 von 6 30.08.2011 17:48



Comments 

Please comment your files extensively, you can hardly have too many comments. 

Without comments, not even you will understand the program after a month. 

The preferable language for comments is english although there are still some 

german comments left. 

In a file containing a function myfunction the commented block from line 2 is 

displayed when entering help myfunction in Matlab. Describe the purpose of this 

file and all in-/output variables. An extensive help comment can be found in the 

function finiteDifferences. It doesn't have to be always this long, but this text 

should be enough to know where this function fits in the complete program. The 

help comment however has to fulfill some criteria: 

The first line has to be the complete syntax of this function including all 

output and input arguments as written after the function command. This is 

vital as when this software is passed on to users outside the institute they 

cannot read the source code, but only the help messages. Therefore they 

need these informations. 

Following this, a short explanation has to follow what this function does. 

This section, as all other comments too, should be in english to ensure, 

everyone can understand it. 

Then write a list of all required input arguments in the order of their 

appearance together with explanations. These explanations should contain 

the required data type. However as soon as there is some standard value, 

which will usually be passed, you should check this argument in your code. 

If an empty expression is passed, or the user called the function with too 

few arguments, you should use this standard value. In the help text, this 

standard value should appear in curly brackets {}. 

Then write a list of all optional input parameters, usually to be given in 

argument/value pairs. Again, include the data type and the standard value. 

Then a list of all return values should follow so the user knows what he 

will get back and in which form. 

Depending on the file, you might want to include your name, so if someone 

has questions they can contact you. 

Variable names 

Please use telling names, so someone else can understand what this 

parameter is for, e.g. to determine if the linear or nonlinear equations are 

to be used, use islinear instead of flag. 

Name logical parameters so people understand them, islinear would be 

much better than only linear. Most often the prefixes is or use are very 

helpful. Try calling them affirmative like isFound not isNotFound. 

2 von 6 30.08.2011 17:48



Try to avoid the parameters i and j. Many people like to use them, 

especially for loops, but in Matlab they represent the complex unit! For 

internal parameters, try using parameters with trailing underscores like g_, 

h_ to avoid name conflicts. They look strange at first, but that's why 

probably most users won't type them. 

Do not introduce new global variables! Should it be unavoidable, create 

a new global structure. Never create single global parameters. 

File names 

When thinking of filenames, the most important rule is that it needs to be a 

telling name! If nobody understands what this file will do, it's no use. 

Please try to start them with lower case letters, which makes typing easier 

when using the [Tab] key. 

If the name consists of several words, it is easier to read when new words 

only start with capital letters, e.g. finiteDifferences.m. Use underscores 

only if necessary. 

If you write a file under a very general name, your code should live up to 

this task. E.g. when you call your file finiteDifferences or 

frequencyResponse it cannot be restricted to a very specialized case of 

application. Otherwise you would block other filenames or provoke 

problems when two functions have the same name. 

If you wrote a function which will only be called from one file, insert it as a 

subfunction to this file. This avoids quadrillions of files and keeps this 

number to a reasonable amount. At the end of each subfunction write a 

short comment like 

end % END OF myFunction 

Conditionals and loops 

Every if() statement ought to provide an else case, so nothing is forgotten, 

as well as every switch needs its otherwise. In the first appearance of such 

conditionals, you should throw errors if some input is not understood. The 

idea is to produce the error at the first possibility, especially before 

something would be changed at the system data structure. 

Try distinguishing your cases without respect to the case of characters by 

using strcmpi and switch lower(myCrit). 

In order to get Matlab as fast as possible, you should use vector operations 

as often as possible. Instead of 'for h_=1:10; myVect(h_) = h_; end' type 

'myVect=[1:10];', which is much faster. 

When you need to make a loop over a matrix like 'for h_=1:5; g_=1:10; 

myMatrix(g_,h_)=...; end; end' it is better to have the inner index (here 'g_') 

to run columnwise as shown in the example. This usually contradicts the 

3 von 6 30.08.2011 17:48



rule to use the loop parameters in alphabetical order at some point, but 

improves speed. 

Graphic user interfaces 

The only way to ascertain user expectations is to do user testing. No amount 

of study and debate will substitute, so use your GUI a few times or ask 

someone to use it. 

Try to provide default values which can be changed later and call this 

setting Standard. 

Write help messages tightly and make them responsive to the problem: 

good writing pays off big in comprehension and efficiency. 

Write Tooltip Messages whenever possible, this are the messages displayed 

when moving the mouse over this uicontrol. 

Make Actions reversible. Always allow "Undo". To close a GUI with saving all 

settings use "OK" button, without saving "Cancel". 

Spell check all labels visible in the GUI. 

When something takes longer, try to make some progress information. Or 

at least show that the program is busy and not dead. 

Print information on what is being done in the standard output (Matlab 

window). 

Menu and button labels should have the key word(s) first. 

Example from a fictitious word processor: 

Wrong: 

1. 

2. 

3. 

Insert page break 

Add Footnote 

Update Table of Contents 

Right: 

Insert: 

1. 

2. 

3. 

Page break 

Footnote 

Table of contents 

Useful hints to design a new GUI 

The eaiest way to design a GUI in Matlab is by typing guide, which is a graphical 

tool for this purpose. Here are some hints on how to proceed, based on our 

experience. 

Make a rough draft of your GUI on a paper first. It saves an incredible 

4 von 6 30.08.2011 17:48



amount of time and work. 

From the paper draft, you will know the following things: 

which information shall be entered and displayed in this GUI 

the arrangement of your control elements 

which types of control elements you want to use, e.g. several radio 

buttons or one popup menu 

is there a way to structure your elements, e.g. by combining them in 

frames, which are just boxes with titles, to make the GUI easier to 

understand 

insert the control elements in the order in which they shall be used. This 

automatically sets up the correct order when using the TAB key. When you 

insert the control elements, immediately specify the Tag property. This is 

the identification with which you can access the control elements. The Tag 

should always consist of two parts. First there should be the information of 

the type of control element, then a telling specification of its purpose. This 

makes the code easy to write, to read and to understand. In addition, it 

saves time, because the tags all follow the same pattern, so you don't have 

to think about them while programming. Examples for this are 

button_apply, popup_groups, radio_input, edit_id, text_id, 

panel_centerOfGravity 

as soon as you save the first time, an m-File is created. This contains 

functions called according to the used Tags. As soon as you change a Tag, a 

search and replace command is used, so be careful if your Tags have been 

too short or could also appear as variable names 

adjust the dimensions of the elements. For all text elements, a height of 

1.5 appears quite good. Don't choose the width of the elements too tight, as 

the sizes vary slightly between different Matlab versions and operating 

systems. The best is to select a standard width for each part of the GUI and 

assign it to all elements, regardless if they need or not. Choose one 

appropriate size for all buttons 

arrange the elements using the provided tool 

the Opening function should do all adjustments to update the GUI to 

current settings. Then you can simply call the GUI without closing after 

each significant change. Then the GUI will reappear at the current position. 

If some settings should be performed only the very first time, this GUI is 

called, insert them in the respective CreateFcn of the element. 

when some data shall be stored, e.g. to check whether the user changed the 

ID of the modeling element under consideration, store this under 

handles.data and don't forget the command guidata(hObject, handles); to 

store this data after the insertion. 

check whether all data is available to avoid errors 

use the function getTxtContent to ensure all entered information is valid 

5 von 6 30.08.2011 17:48



See also 

Web: 

http://www.asktog.com/basics/firstPrinciples.html 

http://www.usabilitynet.org/management/b_design.htm 

http://www.datatool.com/downloads/matlab_style_guidelines.pdf 


_Programming_tips" 


6 von 6 30.08.2011 17:48

Neweulm2 - FAQ - IT M Wiki 

Neweulm2 - FAQ 

From ITM Wiki 

Here a list of frequently asked questions could evolve. It is also meant for a place 

for useful comments, that somehow don't fit in a category. 

Contents 

1 Frequently asked Questions 

1.1 Are there any restrictions to the complexity of the systems? 

1.2 Are there any names reserved for special purposes? 

1.3 I modeled something, where can I find the data? 

1.4 I ran a simulation, where did the results go? 

1.5 Is there a way to access the equations of motion? 

1.6 I didn't specify any parameters, what did the program use? 

1.7 I found a .m and .p file with the same name? 

1.8 An error occurred or the program crashed, what shall I do? 

1.9 Is there a difference between commands and the GUI? 

2 My system is too complex, what can I do? 

2.1 I use only absolute coordinates and it still takes forever! 

2.2 To simplify or not to simplify, that is the question. 

2.3 Calculate fully symbolic or rather do some work numerically? 

2.4 There are so many options, where can I find which I chose? 

2.5 Nonlinear equations work, but it always crashes at the 

linearization. 

2.6 Symbolic modeling is the best! 

2.7 Can I split up my system in simple parts? 

2.8 What is the orientation of my force elements? 

2.9 When I open a file, the Matlab editor crashes! 

2.10 I've done everything and nothing helped! 

Frequently asked Questions 

Are there any restrictions to the complexity of 

the systems? 

1 von 8 30.08.2011 17:49


Yes, there are some restrictions. When entering really big systems Maple or 

MuPad require quite a lot of time to come up with a result. The operation that 

needs the most effort is to simplify expressions with mapleSimplify. 

There is another known problem. Because of the currently used explicit 

formulation, many rotations can bust the algorithm. Especially if these rotations 

are to be executed in a row, in a chain-like structure, the rotation matrices grow 

immensely. Up to approximately six rotations it usually works, above this the 

program cannot solve it. If you encounter problems have a look further down at 

#My system is too complex, what can I do?, where possible cures are presented. 

Are there any names reserved for special 

purposes? 

Yes, there are. See neweulm2 - System Definition#Restrictions for Names for 

more details. 

I modeled something, where can I find the data? 

Every modeling element is stored with its complete input data in the system data 

structure sys. For each type of modeling element you can find a substructure 

which is then separated by the IDs of these elements. If you want to know where 

to search, please have a look at Neweulm2_-_System_Definition#newSys. 

I ran a simulation, where did the results go? 

All simulation routines are written so they have to modes of calling them. If you 

specify a return argument, e.g. 

result1 = timeInt(0, ones(sys.dof,1)); 

the result is only written to that variable. If nothing is specified, e.g. 

timeInt(0, ones(sys.dof,1)); 

all results go in their default location in sys.results, here sys.results.timeInt. 

Is there a way to access the equations of motion? 

Yes, this is one main advantage of this program. You can find the nonlinear 

equations of motion in sys.eqm and the linearized equations of motion in 

2 von 8 30.08.2011 17:49


sys.lin.eqm. However, if you need numerical values for these expressions please 

have a look at the files in the folder sysFunctions, because for each of the 

expressions you can find at the locations mentioned above, one m-file function is 

created exactly for this purpose. 

I didn't specify any parameters, what did the 

program use? 

All functions are written so they can run with only the most essential input data. 

If parameters are not specified, standard values are taken instead, e.g. you 

could start a time integration by typing timeInt;. If you wonder what these 

standard values are, please type help Functionname or just open the function 

and have a look in there. Always at the very top of the file you first find a 

comment containing the help explanations. And usually right under this, the 

default values are set, then optional input arguments read and their properties 

checked. 

I found a .m and .p file with the same name? 

Matlab offers a function called pcode whose purpose is to hide source code from 

users. It does not compile the given file but creates an intermediate stage 

keeping platform independency. The resulting file then gets the file extension .p 

but cannot contain any comments. That's why for each .p file you will find a .m 

file with the same name containing the help message displayed when typing 

help functionname. We started to use these p-functions to distribute our code 

more easily without having the fear that someone starts his own development 

from there. If you have questions on what happens in those functions, think that 

there are some errors contained, please contact your contact person at the ITM. 

An error occurred or the program crashed, what 

shall I do? 

In the case you were trying something, when the error came, do it different ;-). 

However, if you were actually working with the program you might want to 

follow the following checklist: 

Save your work. 

If it is any error related to the graphical animation, create a new animation 

window by typing createAnimationWindow and try the task again, that 

crashed the program before. 

Check your entry, if you made some mistake. If you're not sure, how you 

were supposed to enter the information, type help FUNCTION were 

3 von 8 30.08.2011 17:49


FUNCTION stands for the function causing the error, or in the GUI, click on 

'?'. If this is the case, but you think this wrong way was more inuitive, 

please tell your contact person or developer! 

With every error, you get a link to the line in the file, where the error 

occurred. If it's in an m-file, try clicking that link and see if you find out, 

why the program crashed. 

Try, if the error is reproducible. If so, find out what you have to do, to cause 

it and inform your contact person for the software about it. 

Please do not leave any reproducible errors be without telling your 

contact person or developer! 

Sometimes, when deleting and editing elements with the GUI some things 

are left over and not cleaned up properly. So if you were working on the 

system for some time with the GUI you can try exporting it to an input file 

through the [File][Export System] menu or by calling writeSysDef. After 

creating this input file, please save all your data to a .mat file and clear the 

workspace. Then run the input file you just created and calculate the 

equations of motion. Then your system has been built from scratch and 

should work again. If this didn't help, you probably encountered a more 

serious problem. 

Is there a difference between commands and the 

GUI? 

The graphical user interface (GUI) is only used to compose commands which 

already exist. Therefore the GUI does not provide any additional functionality 

except to provide the commands more easily. On the other hand, this means that 

all new developments appear in the command line version first, before being 

integrated into the GUI. And the GUI usually does not provide all possible options 

to make things more simple. 

My system is too complex, what can I 

do? 

There might be some situations like the following: 

If you want to set up the equations of motion and it takes very long time, you 

might want to know what you can try to speed things up. If your system quits 

with the message 'Out of memory!' you're looking for a solution. Or if you have 

any other problems with the way the equations are set up and you just want 

everything to be simpler you are in need of some tweaks. This section shall 

explain a few 'screws' which you can turn and they might change the programs 

behavior the way you like, without changing the result. As there are many 

4 von 8 30.08.2011 17:49


possibilities which cause you to look for such a solution, all questions are very 

vague. But their main purpose is to let you know in which direction you can 

investigate. 

I use only absolute coordinates and it still takes forever! 

The program offers two ways to calculate the kinematics, relative and 

absolute. When using absolute kinematics, the absolute position vectors are 

set up and symbolically differentiated with respect to the generalized 

coordinates and time. This is repeated to obtain the accelerations, and the 

rotations are calculated similarly. This mode works only for rigid bodies, as soon 

as you have at least one elastic body in the system, the program changes to the 

other mode. The main reason for this is that in absolute mode, all equations are 

set up in the intertial frame ISYS, which is very inconvenient for elastic bodies. 

When using relative kinematics, velocities and accelerations are mostly 

calculated by adding and multiplying the necessary expressions to obtain the 

derivatives. Only where absolutely necessary, symbolic derivatives are used. 

Another difference is that all equations are set up, described in the frame of 

reference of each single body, except for some elastic bodies in the center of 

gravity. 

These two aspects, the describing frame of reference and the way to obtain the 

accelerations may make quite a difference in the look of the equations of 

motion. This leads to two conclusions: 

'Use relative kinematics for relative coordinates and absolute kinematics for 

absolute coordinates.' 

'For long chains of bodies, relative kinematics is better.' 

At this point it might be good to just think and analyze whether you prefer 

relative or absolute descriptions. Sometimes, one defines the system in one 

specific way without thinking about possibilities of how to do it different. 

To simplify or not to simplify, that is the question. 

The function calcEqMotNonLin.m offers an option to control the way 

simplifications are attempted. Most often, it is better to use the 'simplify' 

command. But especially when the expressions get long, this can take a lot of 

time, so you might want to try it without simplification. In the past, you could 

only switch the simplifications on or off, now you have more control. The 

parameter to control this setting is sys.par.codegen.simplify which can take 

integer values from 0 to 10. The value 10, which is the default, means simplify 

at every opportunity. The value 0 means do not simplify at all. Therefore you 

should be extremly careful to set this parameter to 0, as then some algorithms 

will not work properly anymore. For all even values (2,4,6,8,10) when Maple is 

5 von 8 30.08.2011 17:49


used as symbolic engine, the combine command is called. For all odd numbers 

and zero, this command is omitted. The combine command helps recognize e.g. 

trigonometric addition formulas. If you run into problems, just try switching it 

off. So you can try reducing this value e.g. to 4, which will still simplify where 

it's probably quite useful, but mostly the expressions are simply kept. 

Calculate fully symbolic or rather do some work numerically? 

When using the relative kinematics, one can use the minimal form of the 

equations of motion (M*D2y+k=q) with the Mass matrix M being 

transpose(J)*Mq*J or do this multiplication with the transposed global jacobian 

matrix J numerically. To judge which way is preferable, we should have a look at 

the dimensions of these matrices. The matrix Mq is quadratic and has the 

dimension 6*p, where the system contains p rigid bodies. Of course if the 

system contains elastic bodies, the size will still increase. The jacobian matrix J 

has dof columns, where dof represents the number of degrees of freedom. 

When having a small number of bodies, but comparably many degrees of 

freedom such a partial symbolic formulation may be useful. This comes from the 

fact that this would probably cause a complex jacobian matrix. If you have many 

bodies, but a comparably small number of degrees of freedom, the minimal 

form should be better, because the jacobian matrix would contain a lot of zeros, 

vanishing during the multiplication. 

There are so many options, where can I find which I chose? 

Parameters to determine how the software handles your system are stored under 

sys.par. So you can either have a look directly into the data structure, or you can 

choose one of two much more comfortable ways. 

SystemParameters: This opens a GUI which lets you inspect and change the 

parameter settings graphically. You also are shown all possibilities together 

with some explanations. 

printSystemInformation: This is a very useful function to give you 

information about your system. It currently offers three sets of information: 

general, numerical and parameter. Here the parameter is the one you are 

looking for as it will print all current choices together with explanations. 

The other two present either numerical data like positions, inertia, ... or 

general information about the system structure, like the structure of 

coordinate systems. 

Nonlinear equations work, but it always crashes at the 

linearization. 

When linearizing the equations of motion, as a default, for each generalized 

6 von 8 30.08.2011 17:49


coordinate and its time derivatives symbolic set values are introduced. If you 

already know that you will only linearize around set values being zeros, you can 

save quite some space and time by telling this to the program. For this purpose 

calcEqMotLin.m offers an option called NumericalSetValues, which will 

exactly do that. 

There is the possibility to do a numerical linearization. If you need the equations 

linearized only for one configuration, you might want to look at 

calcNumericalLinearization. 

Symbolic modeling is the best! 

Of course symbolic modeling and setting up of equations has many advantages. 

But if you define a parameter for everything, the expressions have to get very 

long. For small models this doesn't pose a problem, but if your PC cannot cope 

with the resulting amount of data, you should think about a change. Depending 

on the point, where the expressions you have different choices. 

If only the linearization gets stuck, you can set up the equations of motion 

symbolically and then have a look at the function symStruct2num.m. It allows 

you to replace constants by their values and keep desired parameters 

symbolically for any given structure. By this you could perform only the 

linearization with numerical values. 

If the system is already difficult to set up nonlinear, you could check which 

parameter values you can insert immediately at the definition. For this you 

might introduce parameters in sysDef.m but when creating modeling elements 

like bodies, you could directly pass those parameters' values. 

Can I split up my system in simple parts? 

A powerful one is to think if you can split up your system in substructures. If 

you can separate your system and model parts of it separately, you can save 

quite some time. For example, if your system contains a lot of linear force 

elements connecting two bodies, it is quite easy to split up the model. In a first 

step you only model those two bodies, where one of them is even unmovable, 

then you add all force elements. If you then calculate the equations of motion 

and linearize them, the resulting stiffness matrix, can directly used to represent 

all of those force elements. Meaning, you can store the numerical values of this 

stiffness matrix and simply insert it in the full model. Then the program only 

has to consider one force element and not the complete huge number. 

What is the orientation of my force elements? 

A bit similar to the last part, where it was proposed to insert numerical values 

7 von 8 30.08.2011 17:49


instead of symbolic parameters, where possible, another trick exists. If you have 

many force elements in some orientation, it may be possible to rotate their 

stiffness, damping and other properties numerically to one governing frame and 

insert them then in the equations of motion. Especially, if you can transform 

them to the frame of reference of the attached body, it is possible to save some 

calculation time. 

When I open a file, the Matlab editor crashes! 

Unfortunately the Matlab editor can only handle files up to a certain file size, 

which can be topped quite easily. But don't worry, other editors like the Emacs 

or Vi don't have any problems up to significantly larger sizes. So please just try a 

different editor first. 

It can happen, that the files get so big, it slows down the simulations 

significantly. If you are using Maple for the symbolic calculation, you can try an 

option of newSys called CodeOptimize, which sets 

sys.par.codegen.optimize=true;. This changes the creation of files for the 

numerical evaluation. It causes the program to search in the expressions for 

repeating elements. Those are then evaluated at the top of the function and the 

full expressions are set together by these precalculated parts. Matlab does 

something a bit similar at runtime anyway, but for some systems it still has a big 

impact. One disadvantage is that you lose any readability in those files. 

I've done everything and nothing helped! 

First remark, please consider all the things mentioned here to be tricks worth 

trying. They depend strongly on the system under consideration and its 

description. So if you simply used all of them, you probably went from bad to 

worse. Please think about, which might help you or simply try them one by one, 

but they are no universal remedies! 

If you still get problems, don't worry, there are always some tricks left in the 

box. If they are not written here, they are either simply not documented, or 

maybe not even implemented. But if you still have some problems, please 

contact one of the persons developing this software and ask if they have an idea. 

Retrieved from "http://www.itm.uni-stuttgart.de/itmwiki/index.php 

/Neweulm2_-_FAQ" 

This page was last modified 17:58, 14 March 2011. 

8 von 8 30.08.2011 17:49

Neweulm2 - Release notes - IT M Wiki 


Neweulm2 - Release notes 

From ITM Wiki 

Here a list shall be maintained with all major changes. This is mostly to allow the 

users to get informed of new features. It is kept in an anti-chronological order, 

so recent changes appear on top. 

This is a research software, this means that there can always be some errors in 

the code. New features are especially vulnerable for them! Please always 

critically estimate if your results are reasonable. 

10.11.2011: Introduced newOpt for the optimization/sensitivity analysis, 

fixed some other issues 

28.10.2011: Change in coriolisSum for elastic bodies 

21.10.2011: Bugfix for the evaluation of omega 

07.10.2011: Implemented better checking if variable names are valid 

06.10.2011: Fixed modal analysis for kinematic loops*04.10.2011: 

Introduced fullModelRun to model the system and simulate everything. 

Introduced rotateElBody to include constant rotations in the data structure 

of elastic bodies. 

15.09.2011: Improved drawRotBody, improved performance for force 

elements 

14.09.2011: Added a new example chain for the recursive algorithm 

09.09.2011: Fixed quite a few bugs. Introduced a way for restricted 

licensing. 

04.09.2011: Improved C-export and added many new features for it 

30.08.2011: Introduced automatic representation of elastic bodies with 

meshes, see drawMesh. Updated newmark-type integrators 

24.08.2011: Changed animation objects to all being patches. 

17.08.2011: Changed angular description for SpringDampCmp force 

elements. Now using very simple way. Old formulation is available as 

SpringDampCmp_Rotmat. 

04.08.2011: Updates in several GUIs. 

02.08.2011: Added Newmark Integrators by Andreas Hanselowski. 

25.07.2011: Reworked C-export. 

22.07.2011: Now supporting all three parameter angular descriptions. 

21.06.2011: Enabled constant orientation offest for nodes of elastic bodies. 

10.06.2011: Improved GUI for graphic objects to be able to edit objects. 

31.05.2011: Introduced the possibility to include general (meaning 

user-defined) surface and patch objects in the animation window. 

30.05.2011: Extended functionality of constraint equations, introduced 

1 von 6 11.11.2011 18:07



modifyBody to edit bodies. Animation uses orientation of g-vector. 

24.05.2011: Automated abbreviations can now be selected in desired level 

via sys.par.eqm.abbreviations. Compatibility with MatlabR2010a was 

increased. 

18.05.2011: Changed storage of equations of motion to cell arrays. 

06.05.2011: Fixed the implementation of Joint Systems for elastic bodies. 

20.04.2011: Reintroduced absolute kinematics, as default using relative, as 

it's much faster. 

15.04.2011: Using abbreviations of values for elastic bodies. 

18.04.2011: Graphical user interface to get started. This shows commands 

which are necessary for simple examples. 

31.03.2011: Introduced animFreqResponse, allowing the animation of one 

specific frequency response, now using numerical linearization if symbolic 

is unavailable. Using findroot if fsolve is not available. Rewrote kinematic 

analysis to respect initial conditions. 

24.03.2011: Introduced drawSpring, improved calculation of phi angles, 

especially for rotational springs 

22.03.2011: The functions to define graphic objects now accept symbolic 

constants in use in neweulm2. 

21.03.2011: Introduced the possibility to use the complete FE mesh for an 

animation 

15.03.2011: Introduced scripts in calcEqMotNonlin and writeMbsNonlin to 

allow users to write their own modules 

14.03.2011: Rewrote kinematics to strictly distinguish between relative and 

absolute values, hopefully improves speed 

14.03.2011: Fixed time interpolation in plotStandardResults, allow 

combinations of symbolic parameters as set values 

05.03.2011: Improved mapleSimplify and mapleSubs 

23.02.2011: Added our own rootsearch algorithm 'findroot', then the 

Optimization Toolbox is not necessary to calculate an equilibrium. 

Generalized writeAnimGeo so it can be used without neweulm2 

18.02.2011: Fixed calculation of reaction forces for elastic bodies 

11.02.2011: Improved the recreation of the animation window by storing 

the current configuration in the axes 

10.02.2011: Added the GUI SystemParameters to inspect and set 

parameters to control the behavior of the software. Introduced automatic 

calculation of Lagrange Multipliers for the QR and SVD method 

04.02.2011: Added the reverse modeled slider crank which sports nice 

singular configurations to compare system descriptions 

03.02.2011: Implemented non orthogonal reduced bodies which may cause 

non-symmetric mass matrices 

20.01.2011: Introduced drawElasticBody for the graphical representation 

of elastic beams (no animation of torsion) 

20.01.2011: Modularized calcEqMotNonLin.m, finished DAE to ODE 

2 von 6 11.11.2011 18:07



conversion via SVD and QR method 

19.01.2011: Generalized the possible angular descriptions 

12.01.2011: Added a new formulation for systems with kinematic loops 

03.01.2011: Added some fixed step solvers 

17.12.2010: Function plotStandardResults introduced to create the most 

common plots 

16.12.2010: Options can be displayed by 

printSystemInformation('Parameter',true) 

16.12.2010: A cheat sheet, meaning a very short explanation is available 

under info/cheatSheet.pdf 

13.12.2010: Unified the option parameters substructures sys.par 

08.12.2010: Now only one set of constraint functions for DAE systems is 

being used, no special ones to calculate initial conditions. 

07.12.2010: Generalized kinematic loops and constraint equations to even 

allow nonholonomic constraints. 

10.11.2010: Fixed a few bugs. Removed initSys.m, its functionality is now 

included in startSysDef.m. 

03.11.2010: Another update for the linearization. The search path is now 

handled by addpathNeweulm2.m. The SHA1 Hash-keys from GIT are now 

stored to identify program versions. 

26.10.2010: Unified the syntax for system outputs. Changed to GIT as 

version control system. 

25.10.2010: Reworked the GUI to define elastic bodies, fixed calls for 

Krylov reduction of elastic bodies. 

15.10.2010: Linearization has completely changed, now being able to 

linearize DAE systems with kinematic loops. 

14.10.2010: Added the type combination for system outputs, freqResPlot 

allows all states to be considered outputs. 

01.10.2010: The function timeInt.m offers stabilization for systems with 

constraint equations. Recently updated some functions for kinematic 

analysis. 

17.09.2010: Fixed a bug in iszero.m, inertia tensors are checked for 

symmetry in newBody, separation of coordinates for kinematic loops works 

now also for absolute kinematics. 

09.09.2010: Included separation of coordinates for kinematic loops, 

introduced iszero.m 

26.08.2010: Fixed some issue for reaction forces. Updated system outputs 

in GUI. 

23.08.2010: printSystemInformation now also provides numerical 

information. 

16.08.2010: For elastic bodies the information can be given directly as a 

struct-variable. 

09.08.2010: Introduced version numbers. More possibilities to choose the 

system description with kinematic loops. 

3 von 6 11.11.2011 18:07



05.08.2010: Runtime optimization now available under MuPad. 

09.07.2010: In the last few days, some bugs have been fixed. 

22.06.2010: Matmorembs is now called via a symbolic link, using the new 

data structure of Matmorembs. 

17.06.2010: Included 'See also' in help messages. 

01.06.2010: Included integration algorithms (for research use only). 

31.05.2010: New folder structure. 

28.05.2010: Several bugfixes and improvements to the recent changes. 

26.05.2010: Implemented some big changes. The storage of in- and outputs 

is different, offering more types and possibilities. Removed many files by 

including their funcionality as subfunctions in their calling files. 

05.05.2010: Included the preprocessor implemented by Nicolai Wengert to 

define elastic bodies directly in Matlab. 

22.03.2010: The use of the simplify command can be controlled by the 

parameter sys.par.codegen.simplify varying in the integer range [0,10]. 

The value 10 representing the most frequent use and 0 avoiding every 

single call of mapleSimplify. 

17.03.2010: Tested compatibility with Matlab 2010a. Introduced a gui for 

frequency response curves. 

15.02.2010: Recently many help messages have been rewritten and 

extended. 

14.01.2010: Improved behavior for zero entries in rotmat2kardan.m. Fixed 

some bugs 

05.11.2009: Sped up the independency checking for kinematic loops. 

Added the automated export of geometries to Anim by writeAnimGeo.m. 

21.10.2009: Fixed a bug from the last update concerning the Spline 

Toolbox and some minor issues. Found the replacement of set values for the 

second derivatives was missing in calcEqMotLin.m. 

08.10.2009: The Spline and System Control Toolbox were necessary for 

some tasks. Now the Spline Toolbox is not used anymore and the System 

Control Toolbox is used only if available. Otherwise the frequency response 

is calculated manually, which is often slower than with the toolbox. 

25.09.2009: Improved the change between Maple and MuPad. Implemented 

additional features in animTimeInt.m. 

11.08.2009: Improved the use of the assume command of the last update. 

06.08.2009: In calcEqMotNonLin.m Maple (not MuPad) is told to assume 

small values for all parameters. This basically only make a difference for 

inverse trigonometric functions. Then asin(sin(alpha)) can be reduced to 

alpha. 

04.08.2009: Introduced automatic checking, which symbolic engine is 

used. Now both, Maple and MuPad should work without adjustments. 

23.07.2009: Over the time several small changes have been applied 

improving comfort, error prevention, comments. In the meanwhile all 

graphic objects, meaning surface objects and both types of lines can be 

4 von 6 11.11.2011 18:07



exported to sysDef.m as well. 

08.06.2009: Redesigned the GUIs EditBody and GraphicObjects. The first 

was necessary to offer all options and allow changes to the data. The latter 

shows more options on a smaller space and is a preparation that existing 

objects can be edited. 

27.05.2009: The gradient calculation now accepts the relative description 

and flexible bodies because the necessary explicit values of M, k and q are 

calculated automatically. The export to C was improved, because the 

function mcode2c.m has been rewritten. 

19.05.2009: Information of graphic objects like spheres, cubes, ... is now 

stored under sys.graphics.surfaces. This enabled the writing of the function 

createAnimationWindow.m which recreates the complete animation 

window containing all graphic objects. This data is inserted upon creation 

of the graphic objects, so in order to have an effect loading a figure is not 

enough, but the file defineGraphics.m or defineGraphics_log.m has to be 

executed. 

05.05.2009: For constant parameters now the value can be specified upon 

creation. For flexible bodies with a buckens frame of reference a flag exists 

to distinguish different types of support. System inputs can be state 

dependent, which allows closed-loop-simulations. But for these system 

inputs the user has to be very careful about what he does, as hardly any 

checking is done. 

09.04.2009: Fixed some errors in calcEqMotNonLin.m. There values have 

been described in wrong coordinate systems. Now the mass matrix in 

sys.body.().M is always described in the local coordinate system. In the 

following table cases which contained problems are highlighted: 

Kinematics/body 

type 

Inertia 

tensor 

Gravity vector 

absolute/rigid ok ok ok 

relative/rigid 

described in 

ISYS, not CG 

relative/flexible ok ok 

described in 

primary system, 

not CG 

Force element 

described in 

coordinate system, not 

CG 

described in nodal 

frame, not frame of 

reference 

09.04.2009: Volume elements for pressure forces are included. STL files 

can be imported to the animation window. Moved the storage position of SID 

data of flexible bodies. 

06.04.2009: Added the possibility to use buckens frame of reference in the 

center of gravity for flexible bodies. With the command drawLine.m several 

5 von 6 11.11.2011 18:07



coordinate systems can be connected by cubic splines to represent flexible 

bodies. 

26.02.2009: Changed the names and folders on the server to Neweul-M² 

19.02.2009: Linearization of systems with flexible bodies available on two 

ways: Calculate M,k,q or use partial derivatives. 

06.02.2009: With the 'combine' command, addition theorems of sine/cosine 

are available. State dependent parameters support linearization, introduced 

two force-application points. 

08.01.2009: Force Elements offer a nominal force, which is applied at the 

nominal length. 

22.12.2008: Instantaneous update of the animation window in the GUI. 

19.12.2008: System can be changed to semi-symbolic formulation, export 

to m-files (independent of sys) is possible. 

16.12.2008: Flexible bodies are supported in the GUI. 

05.12.2008: Flexible bodies are implemented, no buckens frame supported 

yet. Introduced the function printSystemInformation. Added the file 

finiteDifferences. 

24.11.2008: Explicit definition of generalized coordinates wanted. 

11.10.2007: First available log entry. 

2006: Project has been started under the name of Symbs. 


_Release_notes" 

This page was last modified 16:28, 10 November 2011. 

6 von 6 11.11.2011 18:07

PDF file - Institut fÃ¼r Technische und Numerische Mechanik

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?