Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
SCHOOL OF ENGINEERING
DEPARTMENT OF ENGINEERING DESIGN AND PRODUCTION
Petri Seppänen
Great thanks to Janne “the XP coach” Ojala. He has guided me to understand extreme
programming and software development. He taught directly, rolled up his sleeves and taught
by doing, suggested changes in how a practice is implemented, offered ideas to solve a thorny
technical problem, and served as an intermediary between the team and other management.
Thanks also to Jari Juhanko, Petri Makkonen, Kaur Jaakma, Antti Valkonen and Andrea Buda.
Special thanks to Tero, Mikko, Mika, Timo and Kirsi. I am grateful to Pekka, who gave me an
opportunity to work at Aalto University (formerly the Helsinki University of Technology). I also
thank Hanna and Tero for checking the spelling. Thanks also to CSC from software support and
offering CAE programs for this thesis.
The master thesis is dedicated to my mom Mervi and to my departed dad Pekka.
“Programming CAE program to recognize model geometry is like teaching a blind one to paint
the Mona Lisa”
Espoo 23.1.2012
Petri Seppänen
AALTO UNIVERSITY ABSTRACT OF MASTER´S THESIS
PO Box 1100, FI-0076 AALTO
http://www.aalto.fi
This thesis is one part of the Tekes funded Silicom project. Growing demands from customers,
tightening legislation and trend for better productivity are setting demand for designers and experts
to use better simulation tools (CAE) to re-use simulation data and to integrate different CAE
programs work together. The better usability of the simulation data management tools is also
researched in the project. The main idea of the project is to research how Finnish industry could
better answer these challenges in a digital design of the future.
The thesis focuses how finite element method can be integrated application independently into a
digital design. The finite element method is a numerical technique for solving partial differential
equations. The finite element method is used for example in structural and durability analysis and
thermal calculations in the mechanical engineering field. Digital design means that a product is
designed and tested in a digital environment by using simulation programs.
The software vendors are limiting the better usability of the simulation tools, because vendors are
offering products which are working well only with products from the same vendor. The main idea
of the application independent finite element method is to automate with all possible finite element
programs and the integration between different programs is not limited to programs from the same
vendor.
The results of this thesis can be used in the automation of the finite element method and in the
integration of finite element tool into digital design. Benefits are that the designer can use simulation
tools without having a great experience from the simulation tools. Other benefits are that old
simulations can be re-used. The main results of the thesis can be summarized as: workflow for FEA
integration, Cube development and test environment and application integration framework.
1 Introduction .......................................................................................................................... 1
1.3 Aims............................................................................................................................... 4
3 Methods .............................................................................................................................. 30
4 Results ................................................................................................................................. 45
4.1 User stories for developing FEA integration for digital design ................................... 45
5 Discussion ............................................................................................................................ 62
5.1 User stories for developing FEA integration for digital design ................................... 62
6 Bibliography ........................................................................................................................ 65
u Displacement
Internal force
Virtual work
Nodal force
Natural modes
Statistical dispersion
Expected value
Variance
Arithmetic mean
Sample variance
Mass matrix
Eigenvector
Angular frequency
Abbreviations
API Application Programming Interface; A set routines, protocols, and tools that
makes it easier to develop a software application.
CAA V5 Component Application Architecture; An open middleware for product life cycle
management from Dassault Systèmes.
CAD Computer Aided Design; The use of software or other tools to create 2D/3D
geometries.
CAx Computer Aided technologies; Referrer Computer Aided applications like CAD,
CAE and CAM.
CFD Computational Fluid Dynamics; A branch of fluid mechanics that uses numerical
methods and algorithms to solve and analyze problems that involve fluid .
CSV Comma-separated values; The simple file format stores tabular data (numbers
and text) in plain-text form.
DTD Document Type Definition; A set of markup declarations that define a document
type for SGML-family markup languages (SGML, XML, HTML). DTDs were
precursor to XML schema and have a similar function, although different
capabilities.
EssUP Essential Unified Process; An improvement for the Rational Unified Process.
FMBS Flexible Multi Body Simulation; A multibody system with flexible bodies. Gives
more accurate results from displacement and forces than MBS.
GUI Graphical User Interface; An interface between the user and the program.
IGES Initial Graphics Exchange Specification; A file format which defines a vendor
neutral data format that allows the digital exchange of information among
Computer-aided design systems.
JACAX Just Another Computer Aided X; A Backend solution for automatically execute
CAE processes.
MATML Materials Markup Languge; MATML is an XML standard intended primarily for
the exchange of materials property information.
MBS Multi Body Simulation; MBS is used to model the dynamic behavior of
interconnected rigids each of which may undergo large translational and
rotational displacements.
MNF Modal Neutral File; A file which contains flexibility information for parts from
FEA code. The flexibility information is used in a dynamic analysis for example in
MSC.ADAMS.
OpenUP Open Unified Process; A part of the Eclipse Process Framework and an open
source process framework develop within the Eclipse Foundation.
SAX Simple API for XML; An event based sequential access parser API developed by
the XML-DEV mailing list for XML documents.
SBD Simulation Based Design; The Simulation Based can be realized through
implementation and integration of new computer technologies and tools.
Components of SBD are: modeling methods and computational tools, virtual
reality environment, an infrastructure for collaborative engineering and
integration technologies and tools.
SDM Simulation Data Management; The management of simulation data and the
various relationships to related data, including product data and different
design variants.
SGML The Standard Generalized Markup Language (ISO 8879:1986 SGML); is an ISO-
standard technology for defining generalized markup languages for documents.
STEP Standard for the Exchange of Product model data; An ISO standard (IS0 10303)
for the computer-interpretable representation and exchange of product design
and manufacturing information.
VBS Visual Basic Scripting; An active scripting language developed by Microsoft that
is modeled on Visual Basic
VRML Virtual Reality Modeling Language; A standard file format for representing 3D
dimensional interactive vector graphics, designed particularly with the World
Wide Web.
XML Extensible Markup Language; A set of rules for encoding document in machine-
readable form. It is defined in the XML 1.0 Specification produced by the W3C.
1 Introduction
1.1 Background
The use of engineering simulation techniques to understand and predict the real world
behavior of physical phenomena is widespread across a number of diverse industries. This is
true for simulations involving product performance attributes, manufacturing processes or
fundamental research. These techniques, when used effectively, provide a distinct business
advantage to product manufactures. Techniques replace costly, time-consuming physical
prototyping and testing. While simulation technology is constantly evolving to meet the
demands of designers and engineers, there remains a wide difference in the effectiveness of
simulations to impact product design decisions. [1]
Increasing demands from customers, tightening legislation for better products and demand for
better productivity are creating pressure for experts and designers to automate simulation
tasks, to integrate different Computer Aided Engineering (CAE) programs and to make CAE
simulations more re-usable.
Designers, engineers and CAE experts still spend most of their time and effort on manual, labor
intensive tasks [3; 4; 5]:
An expert usually needs to collect all necessary inputs from different sources in order to
perform his/her task. Thus, simple translators from application A to B (Figure 1) are not
enough to fulfill new requirements for CAE simulation processes. Neutral geometry formats,
for example IGES and STEP, are great formats to transfer a model shape in the term of its
geometry and topology [6;7]. However, these formats are not suited to transfer information
and knowledge, because there is a drop in metadata accessibility level as a result from the
transfer [6; 7].
1
Figure 1: Traditional integration to transfer information between different applications. Neutral and
native geometry formats are used to transfer geometry between programs.
Table 1: Applications to integrate different CAx programs. All the solutions are application integrators
at some level and are used to integrate different CAE processes or CAE programs and to move data
between those programs and on some level, to provide a Graphical User Interface (GUI). The table in
the alphabetical order. [8;3;9;10;11;4;12;13;14;15;5;16]
Abaqus Multiphysics
Pro/Engineer CAD
SimXpert CAD
SolidWorks CAD
The Silicom project is interested in application integration solutions, whose philosophical idea
is to integrate different CAE programs together and from those programs that are able to build
and manage simulation processes.
Commercial solutions are offering answers to new requirements. However, these application
integration solutions force experts and companies to use specific CAE programs. These CAE
programs are usually from the same vendor, for example SimXpert from MSC.Software
2
supports mainly CAE applications from MSC.Software [17]. The application integrations
programs which fulfill the initial needs of the Silicom project are:
Altair HyperWorks,
Ansys Workbench,
Comet Solution Workspace,
ModeFrontier, and
SimXpert.
The main idea of these solutions is that, the user is able to build simulation process
automation and design optimization solutions more easily, and the manual process of entering
the required data is reduced. These solutions offer ways to create simulation process flows in
order to automate the exploration of design alternatives and to identify optimal performance
parameters [3; 5; 9; 12].
JACAX (Just Another Computer Aided X) application framework arose from the need to have an
application and vendor independent environment to run a digital design user case: a diesel
engine with wanted CAE/CAD applications. The used Applications were Pro/Engineer for the
Computer Aided Design (CAD), Abaqus for the Finite Element analysis (FEA) and ADAMS for the
Multi Body Simulation (MBS). The available integration solutions from CAE vendors would have
restricted the usability of the available CAE applications.
JACAX is a method for application integration and a back end for building CAE processes.
JACAX originates from the Aalto University School of Engineering, Department of Engineering
Design and Production, CAE-group. The main idea of JACAX is to make it possible to run an
automated simulation loop with multi-vendor CAE-programs. It is also possible to integrate
JACAX with Simulation Lifecycle Management (SLM) and Simulation Data Management (SDM)
applications.
The philosophy of JACAX framework is to use neutral standard formats, which are supported in
CAE applications, for example, native and neutral geometry formats to move the model
geometry from CAD to CAE applications. If it is not possible to transfer some data with
standardized formats, this data is transferred by a “sidecar” (Figure 2).
The format of the sidecar is a human and computer readable Extensible Markup Language
(XML). The JACAX´s way to transfer data differs from the traditional integration.
3
The Silicom project is about simulation life cycle management and how simulation processes
are improved. The project had three fields of research, which are Simulation Data
Management (SDM), application integration and production simulation.
The digital design user case was developed as a test bed for SDM and application integration.
The user case is a realistic study environment for developing application integration and to
produce realistic simulation data for SDM. The user case is presented in Figure 3.
Figure 3: The process of the design user case. Excel calculates parameter for the diesel engine.
Pro/Engineering generates geometry and XML for Adams and Abaqus. Abaqus generates MNF files for
Adams and calculated structural analysis from load from Adams.
The Silicom project had a requirement to have an application, a procedure and a vendor
independent solution to automate FEA. The research problem of this thesis is to find a good
way to integrate and automate FEA application independently.
1.3 Aims
This thesis investigates ways to integrate finite element analysis (FEA) application into the
digital design and automate FEA application. The main object of this thesis is to integrate and
automate finite element analysis application independently. To accomplish the main object
and avoiding data losses during the translation from CAD to FEA, XML vocabulary for the
sidecar is needed. This vocabulary is meant for the finite element analysis purposes. The digital
design user case is used for research, demonstration and validation purposes.
4
1.4 Scope of the Research
The research for the application independent FEA and the demonstration is restricted to one
FEA application and one software version, which is Abaqus 6.10. Different FEA applications are
using different programming languages and a time period which is reserved for the master
thesis is too short to research all high end FEA applications and automate them. The same
developed principles and methodologies can be used for other FEA applications as well. The
automation research is restricted to two different tasks from the digital design user case.
These tasks are:
A literature study is done to find a solution to solve the data loses of the neutral formats. This
problem occurs during the translation of data from one CAE program to another. The problem
is solved by using XML and for this the literature study is also done to develop the XML
vocabulary for the sidecar, which is represented as the solution of the data loses.
The developing of the scripts for the automated FEA is started by gathering user stories from
the members of the project. User stories are short descriptions of features the customers
would like to see in the software.
The test environment is developed for testing and validating scripts and processes. XP from
Agile method and the digital design user case are used to develop scripts to automate FEA. The
scripts are tested and validated by using automated unit testing. Unit tests are small, method-
level tests developers write every time they make a change to software to prove the changes
work as expected. [19, p. 206; 20, p. 90]
The literature study is done also to find a solution to the problem of a CAD user. The problem
is about how the CAD user should mark surfaces, points etc. in a way the finite element
analysis application is able to find them and use them. This literature study was done only with
the Abaqus application programming interface.
5
2 State of the Art Review
2.1 Neutral formats
Engineering products are often developed by geographically and temporally distributed design
team using heterogeneous CAx software. The main problems associated with all
computationally assisted data exchange and integration activities can be approached from
multiple points of view depending on the need at hand. Data interpretation varies from a data
source to a data source and this destroys the robustness of interoperability between
applications and data receptacles in general. Integration of CAx system is a major issue for
industry. [22, p. 1; 23, p. 1]. Neutral formats are presented as a solution to reduce
interoperability problems. CAD applications have neutral formats for transferring geometry,
but CAE applications don’t have a similar neutral format [2]. Examples of neutral formats are
IGES, STEP, VDA-FS, STL and ACIS, and examples of native CAD formats are CATIA V5 (.CATpart,
.CATproduct), Parasolid (.x_t, .x_b, .xmt), I-DEAS and PRO/ENGINEER. The complex nature of
engineering data may hinder the vertical integration of engineering applications. The major
problems that prevent the effective integration of CAx systems are [22, p. 3]:
Current CAx systems have been designed for input and output data rather than
information.
Current CAx systems tools operate on different levels of abstraction of the mechanical
product.
Many standards such as Standard for the Exchange of Product model data (STEP), the Initial
Graphics Exchange Specification (IGES) and Parasolid have been successful in the transfer of
model shape in terms of its geometry and topology. They are advantageous in geometry data
transformation. Nevertheless these standards are not suited to transfer the context in which it
was generated (information and knowledge). As a result there is a drop in the metadata
(knowledge) accessibility level, even the information level, when transferring from CAD to FEA
(Figure 4). The successful integration cannot be achieved since human interaction is necessary
to rebuild information/knowledge lost in the transfer. [6,7]
Figure 4: Drop in knowledge accessibility level due to the incapability of the data formats, used to
transfer from one process to another, to capture information and knowledge [6].
6
According to [6, 7] data is understood as discrete; data items no inherent structure of
necessary relationship between them. In contrast to data, information is data that is
structured and put into context, so that it is transferable. The immediate value of information
depends on the potential of the user to sort, interpret and integrate it with their experience.
Knowledge goes one step further and implies the combination of information with the user’s
own experiences to create to a capacity for action.
Initial graphics exchange specification (IGES) is a typical example of this standard mainly for 2D
drawing layouts, and supports only data level exchange. The format is the oldest and most
widely used standard for exchanging geometric data [6]. The solid or shell geometry is
presented in an IGES file by a series of surfaces [24, p. 25]. IGES have different appropriate
tailored formats or flavors. Those flavors are [25]:
Standard,
MSBO (Manifold Solid B-rep Objects),
AutoCAD,
SolidWorks, and
JAMA (Japanese Automotive Manufacturer´s Association).
Standard for the exchange of the product model data (STEP, ISO 10303-1 1994) is a standard
for the computer-interpretable representation and an exchange of product data, and is
successful in the transfer of product shape in terms of its geometry and topology [7]. However,
ISO 10303 focuses on the translation of terminologies from one CAD system to another. It does
not attempt to translate the meaning associated with the design from one context to another
[7].
The STEP is a complex standard with huge-sized documents, and was developed as if it was a
database itself, adopting the scalable processor architecture (SPARC) architecture for database
systems. The standard is comprehensive and is made out from very extensive but well-
structured document series. [22, p. 3]
The massive specifications, custom and proprietary related tool availability are its two greatest
disadvantages [22, p. 4]. The portion of ISO 10303 that is used to present three-dimensional
product data are known as AP203 and AP214. These use a boundary representation to
represent a solid, as well other data such as parts and assemblies information [24, p. 27]. Step
is a complete framework for the standard development and implementation. STEP is
composed by a series of standards, called parts, grouped in three main categories [2, p. 7].
Description methods (ISO 10303-10 series) provide a mechanism for defining data models. Part
11 describes an object-oriented data modeling language called EXPRESS. Implementation
methods (ISO 10303-20 series) provide standard implementation techniques for the data
models defined using STEP.
Part 21 describes the STEP file exchange structure, and parts 22 to 29 specify several language
interfaces (C, C++, IDL, JAVA, etc…) to read, write and manipulate data. A few STEP
development tools are available in the market. They can transform EXPRESS data models into a
variety of useful forms, such as C++ code able to read, write, validate and manipulate EXPRESS-
7
defined data stored in Part 21 text files. Data specifications are the data models defined by
STEP, called application protocols. STEP provides data models for different engineering
application: CAD, FEA and CNC. Currently, 25 applications are under development and 13 of
them have reached the status of ISO standard. AP203 “Configuration controlled design”,
dedicated to model CAD data, is widely available in commercial tools. [2, p. 7]
The demand for application integration is driven by the move to process orientation in many
companies. Presently, there is also a trend toward increased inter-organizational cooperation,
exemplified by virtual enterprises and extended supply chain (Figure 5). [27, p.3]
Figure 5: A supply chains that integrates the vendors and customers of a company. [27]
Supporting cross-functional and inter-organized processes put new requirements on the IT-
system. Traditionally, IT-systems have been built up around departments or functions in the
companies. The result has been a “stovepipe like” relation between the functions and the IT-
system (Figure 6).
Every function in the company is supported by its own system or application. When an
increasing number of companies have begun to transform their organization towards a
horizontal and process-oriented way of working, an integration of the IT-system becomes
essential (Figure 6). [27, p.3]
Figure 6: The traditional functional oriented structure with the stovepipe like relation between the
business function ant the IT-systems (left). The process oriented organization also requires integration
of the IT-system (right). [26; 27]
8
Companies that react quickly according to the constantly changing demands of the customers
will have an advantage in the hardening competition. It is essential the IT-systems support
such changes. This means that IT-systems not only have to be integrated, they also need to be
flexible. The integration of distinct IT-systems gives rise to more complex systems. If a system
also has to be flexible, complexity increases even more. Thus, there is a need for methods,
technologies and tools that can handle the complexity. [27]
The main problem here is to make a complex IT-system understandable for different
categories of stakeholders, such as business managers, technical designers, business
operators, and other users. The efficiency and effectiveness of simulation within a workgroup
or enterprise is driven by several factors, including [1]:
The application integration framework is an architectural model and an integrated group that
provide access and integration. The idea of the application integration is to integrate and
automate different CAE applications and make simulation data more re-usable. To handle this
integration of applications in an efficient way, technologies, tools and methodologies are
required.
This application solution could work for a small number of applications, but as the number of
applications increases, the number of connections quickly becomes overwhelming. If the
applications, for example, differ in data formats and communication protocols, the translation
9
and transformation of the messages between the applications will be very complex. The
maintenance problem becomes hard if any of the application changes its format. [27, p.4]
The main idea of the message broker (Figure 9) is to reduce the number of interfaces by
introducing a central message broker and thereby make it easier to support the interfaces. If
one of the applications changes format, only one connection has to be changed. The message
broker also makes the coordination between different applications easier compared to
forward a message from one application to another. Furthermore, the message broker can
decide what application a message should be sent depending on the content of the message.
The message broker lacks a central mechanism to handle and visualize the whole flow of
processes. For that reason, it is also difficult to automate the processes and change them
swiftly. [26, p. 3; 27, p. 5]
The process broker (Figure 10) is an extension of the message broker. In addition to handling
the format conversion, the process broker also encapsulates the process logic for connecting
applications. When all process logic resides in one place, it becomes possible to study, analyze,
and change the processes using a graphical interface. This visualization reduces the complexity
and enables different categories of CAx programs to be used in the process. Traditionally the
process logic is spread and embedded in different application, but by separating process and
application logic and collecting all logic in a process broker, all process logic can reside in one
single place. This separation of concerns will provide easier maintenance and greater
flexibility. It will be possible to modify the processes in an easy and dynamic way that is to
change the order of contact between the different applications or to add new application to
the processes. [26, p.4; 27, p.6]
10
Figure 10: The Process broker strategy to integrate applications. [26, p.4; 27, p.6]
The different methods have different benefits and disadvantages and they are suited for
different situations. Red Oak Software Company has identified requirements for application
integration and those are [28]:
Ubiquitous access to application data means that data resides on many different platforms.
With data currently residing in host-based applications, client-server applications, PC-based
application, Linux-based applications, and web-based applications, integration needs to run
across all of these platforms. In addition, on each of these platforms, the application being
integrated can be an off-the-shelf application, in-house application, or a combination that falls
somewhere in between. Integration efforts need to take all of these into account. In many
cases, there is no easy way to tap directly into the data or logic of the application. There are
many reasons that application may require a non-intrusive access. In some cases, the
technology does not exist or may not be easily available to easily access the underlying logic of
the application. In other cases, advanced resources required to access the underlying logic or
data may not be available or may be too complex or expensive to implement. [28]
11
Table 2: Applications to integrate different CAE programs. All the solution are application integrators
at some level and are used to integrate different CAE processes or CAE programs and to move data
between those programs and on some level, to provide a Graphical User Interface (GUI). The available
tools depend on version of the program. The basic version of CATIA provides only CAD.
[8,3,9,10,11,4,13,14,17,16].
The team of the Silicom project is interested in more from application integrations whose
philosophical idea is integrated different programs together and from programs that are able
to build processes and manage those.
Altair HyperWorks,
Ansys Workbench,
Comet Solution Workspace,
modeFrontier, and
SimXpert.
The research in this thesis carried out using the programs, which the author had used and
researched during this thesis. Those programs are:
12
The Ansys Workbench Platform is a commercial example from the application integration
framework for an engineering simulation. The disadvantage of this solution is that the platform
supports only products from Ansys. The platform supports integration between Computational
Fluid Dynamics (CFD) and FEM.
The main idea of this solution is a schematic view of the project, which ties together the entire
simulation processes. Projects are represented graphically as connected system in a flow-like
diagram. The advantages of this is that a user can easily understand engineering intent, data
relationships and the state of the simulation [29]. In Figure 11, there is an example of Ansys
Workbench.
The idea is simple; the user just drags the wanted simulation into the project schematic and
connects wanted simulations to together. The entire process is persistent, changes can be
made to any portion of the analysis and the workbench will manage the execution of the
required applications to update the project automatically [9;29].
Ansys Workbench scripting is based on Python scripting language and it is also integrated with
the .NET Framework, which provides for example Microsoft Excel to access workbench
parameters [29]. Ansys workbench offers the ability to record the actions that the user
performs via the GUI.
From the Project Schematic, the user can interact with applications that are native to Ansys
Workbench, and the user can launch applications that are data-integrated. Data-integrated
applications are created independently of the Ansys workbench framework but have been
extended so they can be driven by the Project Schematic and share key data and parameters
with Ansys Workbench and Ansys Workbench-enabled applications. Data integrated
applications do not fully support ANSYS Workbench scripting, most of those have their own
native scripting language which is accessible through the Ansys Workbench scripting interface
(Table 3).
13
Table 3: Ansys scripting supports for data-integrated application. [29]
SimXpert is a similar product like Ansys Workbench platform; it also integrates CAD programs
CATIA and Pro/Engineer [17]. Another application integration program is LMS Virtual.Lab. The
LMS Virtual.Lab is an integrated suite of 3D FE and multibody modeling software which
simulates and optimizes the performance of mechanical systems for structural integrity, noise
and vibration, system dynamics and durability [13]. It is based on Component Application
Architecture (CAA V5), the open middleware for product life cycle management from Dassault
Systèmes. [30]
The LMS Virtual.Lab program offers modeling environment, which integrate all the required
model creation, meshing and multidisciplinary simulation capabilities. This solution offers
interfaces with CAD programs and makes it possible to exchange models, data and results
between different simulation and testing disciplines. It also eliminates unnecessary data
transfer and file translation. LMS Virtual.Lab removes the barrier between CAD, CAE and real-
life testing. The example of the GUI of the LMS Virtual.Lab is presented in Figure 12. LMS
Virtual.Lab has automation and customization capabilities, such as: journaling, macros and
scripting. [30]
14
Figure 12: LMS Virtual.Lab. The program is simulating combustion loads, hydrodynamic bearings and
Flexible engine block is modeled in this simulation. [31]
XML is a modern system for annotating a text in a way that is syntactically distinguishable from
that text, for example structural markers such as XML tags. XML was developed by the Word
Wide Web Consortium and this consortium has recommended that XML is used as a
representation of the electronic information [33]. Several schema languages are available to
define the structure of XML files. The most used are document type definition (DTD) and XML
schema. XML standards are presented at the Table 4.
Nowadays many application programming interfaces (APIs) have been developed to process
XML data and several schema systems exist to aid the definition of XML-based languages [34].
The main purpose of XML was to simplify Standard Generalized Markup Language (SGML) by
focusing on documents on the internet. XML is based on SGML-language, but it is still simpler
15
and have stricter rules. XML remains a meta-language like SGML, allowing users to create any
tags needed (hence "extensible" and then describing those tags and their permitted uses). [33]
XML is designed to make it easy to interchange data over the Internet Local Area Networks
(LAN). The current XML specification is 36 pages long of which 26 pages are important, others
include the list of contributors. [22, p. 7]. XML has many advantages [35, p. 7; 36, p. 7-8, 52-
53]:
The basic rules of XML are easily defined. A logical document component either begins with a
start tag and ends with a matching end tag or consists of only of an empty element tag. The
characters between the start and the end tags, if any, are the element's content, and may
contain markup, including other elements, which are called child elements. An example of an
element is:
A markup construct consisting of a name/value pair that exists within a start tag or an empty
element tag. The attribute is a key value which clarifies the element. An example of an
attribute is:
<JACAX version=”0.0”></JACAX>
XML documents may begin by declaring some information about themselves, as in the
following example:
16
Material models and material databases are very complex, this means that there is a
need for to easily expand or decrease the file of the materials.
Easily human readable. The simplicity is based on the finite sets of tags, whose names
are common material terminology.
XML enables communities, such as material scientists and engineers, to define
domain-specific tags (FEM, MBS, CFD) and document structure easily.
Materials can be represented independent of definitions of different domains and
applications, therefore every program has a different way how material data is
represented and how the program uses it.
The Matweb online databases for example provides and supports material data on the XML
format. At this point, the officially supported programs are [38, 39, 40, 41]:
SpaceClaim,
Autodesk´s simulation,
ETBX, and
Ansys.
An XML-language is available for transferring material data to finite element programs. This
language is MatML. The current version of MatML is 3.0. The most important attribute of the
MatML development effort was the inclusion of a broad range of input from the materials
community. These individuals and groups represented private industry, and government
laboratories. [42, 43]
Many material database applications are using MatML language to move material data from
database to the FEM program for example from Matweb to Ansys. Commercial Ansys is one of
the major programs in FEM-domain which uses MatML. There are many applications that use
MatML to deliver material information, for example [42]:
The femML is developed by members of the Composite Materials and Structures group at the
Naval Research Laboratory and the International Science and Technology Outreach Society in
the year 2000. There are two version available (1.02 and version 2.99b. [44]
17
The main aspects of the finite element definition have been used as archetypes for defining
the XML element taxonomy definitions. Namely, the geometry, the material, and the loading
aspects of a structural component specification are used to define the first level elements of
the associated Document Type Definition (DTD). The element list has been amended with a
behavior element specification that represents the solution data to be exchanged or visualized
[22, p. 16]. The Unified Modeling Language (UML) of the femML is presented in Figure 13.
Figure 13: UML representation of the two levels of femML DTD structure. [22, p.16]
The header element ensures the transport mechanism of the meta-data. The material element
is responsible for the material properties. The nodeset is the element that carries the nodal
geometry information of the model and the elementset carries the elemental information of
the model from the 3D geometrical point of view. The loadcase element carries the loads and
boundary conditions on a nodal basis. The resultcase includes results data (i.e. displacement,
stresses, strain, energies and other scalar, vector or tensor component quantities associated
with the nodes) [22, p. 16].
file sizes are smaller than in normal results file formats, and
it is possible to open the results almost everywhere and they can be used in common
business applications, such as email messages, web pages, word processing
documents, and presentations.
X3D is developed by the Web3D Consortium as a major upgrade from VRML (the Virtual
Reality Modeling Language). The basic of the X3D run-time environment is a scene graph. The
scene graph consists of several nodes in a hierarchical structure, with shape nodes
representing the objects themselves, and transforms nodes describing the spatial positions of
the objects. The nodes in X3D are represented using XML so as to take the full advantages of
18
the potential of XML on the internet. X3D has become a free, ISO-ratified format to provide
long-term stability for Web3D content and application. [45, p.2]
3D XML is a lightweight and standard XML-based format developed by Dassault Systèmes for
encoding three-dimensional images and data. The format is open and extendable, allowing
three-dimensional graphics to be easily shared and integrated into existing applications and
processes. 3D XML files can be many times smaller than typical model database files. The 3D
XML Player from Dassault Systèmes is required to view 3D XML files or to integrate them into
other business applications. [46, p.3, 45]
3D XML uses open XML schematics to commutate the product geometry, the product
structure, and graphical display properties. Thus, it can be read, written and enriched by
standard tools. 3D XML Player extends 3D XML beyond traditional Product Lifecycle
Management applications, offering integration with Microsoft Office applications and the
internet Explorer browser, or working as a standalone application. [46, p.3]
2.4 Substructuring
In order to provide a concrete example of the application integration strategy proposed in this
thesis; a substructuring script has been implemented and used as example for the exchange of
data between CAD, FEA and MBS domain.
ADAMS uses Modal Neutral Files (MNF) for the Flexible Multibody Simulation (FMBS) and one
part of the MNF file generation process is substructure generation. In this processes Abaqus
models are created for flexible components of the MSC.ADAMS model, and each component is
modeled as an Abaqus substructures [47, p. 11, 48].
Substructuring is a method to divide the geometry to a partitioned block, where the master
features represent the interface nodes. The slave nodes inside partition can be as linear
presentation of the master modes behavior. By this the system can be reduced. This means
that for example connecting rod is implemented as a flexible body that can interact with the
rest of the model via the interface nodes (Figure 14).[47, p.5; 48, 49, p.8]
19
Figure 14: Example of interface nodes and inner nodes of the connection rod. Interface nodes are
coupled to inner nodes.
In the Finite Element literature substructures are also referred to as superelements and both
terms are used interchangeably [48]. Substructures have many advantages [47, p. 9; 48; 49, p.
12-24]:
Efficiency is improved when the same substructure is used multiple times. The
stiffness calculation and substructure reduction are done only once; however, the
substructure itself can be used many times, resulting in a significant savings in
computational effort.
Substructuring can isolate possible changes outside substructures to save time during
reanalysis. During the design process large portions of the structure will often remain
unchanged; these portions can be isolated in a substructure to save the computational
effort involved in forming the stiffness of that part of the structure.
In a problem with local nonlinearities, such as a model that includes interfaces with a
possible separation or a contact, the iterations to resolve these local nonlinearities can
be made on a very much reduced number of degrees of freedom if the substructure
capability is used to condense the model down to just those degrees of freedom
involved in the local nonlinearity.
20
Substructure libraries allow analysts to share substructures. In large design projects
large groups of engineers must often conduct analyses using the same structures.
Substructure libraries provide a clean and simple way of sharing structural information
Many practical structures are so large and complex that a finite element model of the
complete structure places excessive demands on available computational resources.
Such a large linear problem can be solved by building the model, substructure by
substructure, and stacking these level by level until the whole structure is complete
and then recovering the displacements and stresses locally, as required.
The theory of the substructuring analysis in this thesis is based on Abaqus 6.11 Theory Manual
chapter 2.14.1 Substructuring and substructure analysis. [50]
[ ]{ }, and [1]
[ ]{ }, [2]
where and are linear transformations between the retained degrees of freedom of the
substructure and the component of displacement or stress under consideration. The
substructure must be in a self-equilibrating state when it is made into a substructure. Since the
purpose of the substructuring technique is to have the substructure contributes terms only to
the retained degrees of freedom. Thus, is external load vector ̅ formed from the nonzero
substructure load cases and internal force ̅ as a sum of linear translations of the retained
variables and their velocities and accelerations (equations). ̅ is the reduced mass matrix for
the substructure, ̅ is its reduced damping matrix and ̅ is its reduced stiffness. These
matrices connect the retained degrees of freedom only
{ ̅ } [ ̅ ]{ ̈ } [ ̅ ]{ ̇ } [ ̅ ]{ }. [3]
The reduced stiffness matrix is easily derived when only static response is considered. Since
the response of a substructure is entirely linear, its contribution to the virtual work equation
for the model of which it is a part is presented
[ ] { } [ ]{ } , [4]
where and are consistent nodal forces applied to the substructure during its loading
as a substructure and its K tangent stiffness matrix
[ ] [ ] [5]
21
Since the internal degrees of freedom in the substructure
, appear only within the substructure, the equilibrium equations conjugate to in the
contribution to the virtual work equation
{ } [ ]{ } [ ]{ } . [6]
{ } [ ] { } [ ]{ } . [7]
[ ] { } [ ][ ] { } [ ] [ ][ ] [ ] { } [8]
Thus, for static analysis the substructure’s reduced stiffness is presented at equation 9.
[ ̅] [ ] [ ][ ] [ ] [9]
and the contribution of the substructure load cases applied to the substructure is the load
vector
{̅ } { } [ ][ ] { } . [10]
The static modes defined in an equation may not be sufficient to define the dynamic response
of the substructure accurately. To substructure is augmented some generalized degree of
freedom, associated with natural modes of the substructure. The simplest such approach is
to extract some natural modes from the substructure with all retained degrees of freedom
constrained, so that equation is augmented in equation 11.
The basic idea of the dynamic mode addition is that substructures eigenmode amplitudes
become additional degrees of freedom at the usage level. Dynamic modes retained in the
substructures can be calculated in the frequency extraction procedure with any reasonable
boundary conditions. The used method is Craig-Bampton method (fixed-interface eigenmodes)
[48, p. 72]. In the fixed-interface eigenmodes dynamic modes are generated with all retained
degrees of freedom constrained. The Craig-Bampton method is also known as the component
mode synthesis method [50, p. 1].
{ } [ ] { } [ ]{ } { } [11]
{ } [ ] [ ]{ } { } [12]
{ ̇ } [ ] [ ]{ ̇ } { } ̇ [13]
{ ̈ } [ ] [ ]{ ̈ } { } ̈ . [14]
22
The eigenmodes of the substructure of are { } , obtained with all retained degrees of
freedom constrained, and are the generalized displacements.The contribution of the
substructure to the virtual work equation for the dynamic case is
{ } { } [ ]{ ̇ } [ ]{ ̇ } [ ]{ } [15]
̈ ̇
[ ] [ ] , [16]
C is damping matrix
[ ] [ ] , and [17]
{ } { } . [18]
With the assumed dynamic response within the substructure, the internal degrees of freedom
in this contribution ( and its time derivatives) can be transformed to the retained degrees
of freedom and the normal mode amplitudes, reducing to the system to equation 19.
̈ ̇
[ ] [ ] { } [ ] [ ][ ] { } [ ] [ ][ ] { } [ ] [ ][ ] { } [19]
̈ ̇
where T is
[ ] [ ]
[ ] [ ] . [20]
[ ] [ ] [ ]
Models are modeled as Abaqus substructure at Abaqus and converted to the MNF file for
ADAMS by using the Abaqus Interface for MSC.ADAMS. The raw Craig-Bampton modal basis
has certain deficiencies that make it unsuitable for direct use in dynamic system simulation.
[51] These are:
Embedded in the Craig-Bampton constraing modes are six rigig degrees of freedom
(DOF) which must be eliminated before the Adams analysis because used multibody-
simulation program Adams provides its own large-motion rigid body DOF
The Craig-Bampton constrain modes are the results of the static condensation; these
modes do not advertise the dynamic frequency content.
23
Craig-Bampton constraint modes cannot be disabled because it would be equivalent to
applying a constrain on the system.
Natural frequency extraction is needed for MNF file generation. The frequency
extraction performs an eigenvalue extraction to calculate the natural frequencies and
the corresponding mode shapes of a system. The eigenvalue problem for the natural
frequencies of an undamped finite element model (Equation 21) [52]. Where is
the mass matrix, is the stiffness matrix and is the eigenvector (the mode of
vibration).M and N are degrees of freedom. When is positive definite, all
eigenvalues are positive. Rigid body modes and instabilities cause to be
indefinite. Rigid body modes produce zero eigenvalues.
[21]
24
ADAMS program requires that the user define the units used in the component model, while
Abaqus does not. Therefore, during the creation of the modal neutral file the user must
declare explicitly the units used in the model. The default units system is mks. The valid units
system for the units option are in Table 6 [48].
Units Systen Length Units Mass Units Force Units Time Units
There are two approaches to create mesh. The bottom-up approach is a traditional approach is
to construct mesh to create geometry; other approach is top-down; where mesh is done
directly on the geometry. Bottom-up meshing is a manual, incremental meshing process that
allows you to build a hexahedral mesh in any solid region.[24]
The used meshing methodology is top-down. Top-down meshing generates mesh by working
down from the geometry of the part or region to the individual mesh nodes and elements. The
resulting mesh exactly conforms to the original geometry. The rigid conformance to geometry
makes top-down meshing predominantly an automated process. In some cases top-down
methods may not allow you to mesh portions of a complex part with the desired type of
elements. [24]
The degrees of freedom (DOF) are the fundamental variables calculated during the analysis.
Displacements of other degrees of freedom are calculated at the nodes of the element. At any
other point in the element, the displacements are obtained by interpolating from the nodal
displacements. Usually, the interpolation order is determined by the number of nodes used in
the element. The available element shape for one-dimensional geometry is presented In Figure
15 [54].
25
Figure 15: Elements that have nodes only at their corners, such as the left line, use linear interpolation
in each direction and are often called linear element or first-oder elements. [54]
One-dimensional elements are used in structural analysis for example. These elements can be
used in two- or three-dimensional space to transmit loads or fluxes along the length of the
element. Two-dimensional elements are used for example in structural analysis (Figure 16).
[54]
Figure 16: Two-dimensional elements; Elements with midside nodes, such as the right triangle or
quadrilateral, use quadratic interpolation and are often called quadratic elements or second-order
elements. [54, 55]
The element shapes for three-dimensional elements are defined in the global X, Y, and Z space.
These elements are used when the geometry and/or the applied loading are too complex for
any other element type with fewer spatial dimensions. The three-dimensional elements are
used in this thesis (Figure 17). [54]
26
2.7.1 Python
Python is an open source, general-purpose and high-level programming language (scripting
language). The reference implementation of Python (CPython) is free and open source
software and has a community-based development model, as do all or nearly all of its
alternative implementations. CPython is managed by the non-profit Python Software
Foundation. The mainstream Python implementation, known as CPython, is written in C. [57]
The high-level programming language means a programming language with strong abstraction
from the details of the computer. Scripting languages are designed for the effective integration
of components written in other computer languages. A scripting language is a high level
language that executes more operations per language statement that a language such as C++.
A scripting language does not require compilation leading to fast prototyping. Differences
between a scripting language and a programming language are compared in the table 7. [58, p.
24-25]
The high-level programming language means a programming language with strong abstraction
from the details of the computer. High-level programming languages use natural language
elements, are easier to use and are more portable across platforms. Different computer
languages are compared in Figure 18.
27
2.7.2 Agile
Agile software development is a group of software development methodologies based on
iterative and incremental development. There are many specific agile methods, which are [59]:
Agile modeling,
Agile Unified Process (AUP),
Dynamic Systems Development Method (DSDM),
Essential Unified Process (EssUP),
Extreme Programming (XP),
Feature Driven Development (FDD),
Open Unified Process (OpenUP),
Scrum, and
Velocity tracking.
programming in pairs,
doing extensive code review,
unit test of all code,
avoiding programming of features until they are actually needed, and
simplicity and clarity in code.
coding,
testing,
listening, and
designing.
The XP argue that the only truly important of the good system development process is
workable code, without the code there is no working product (Figure 19). Coding can also be
used to figure the most suitable solution. The code is used as a way to transfer information
and solution to the problems between programmers.
28
Figure 19: Extreme programming project flow chart. User Stories defines requirements and
requirements for the acceptance test. After required is a release plan released. After this starts coding
and iteration for the better code. When the code is ready, is have to pass the acceptance test, this
means the code get a customer approval and the customer starts to use the code. [62]
The XP approach to testing is that a little testing can eliminate a few flaws; a lot of testing can
eliminate many more flaws. A unit test determines whether a given feature works as intended.
A programmer writes as many automated tests as they can think of that might “break” the
code. If all test run successfully,the coding is complete. Every piece of code that is written is
tested before moving on to the next feature. Acceptance test verifies that the requirements as
understood by the programmers satisfy the customer´s actual requirements. Acceptance test
are run often and the results are published.
XP has been described as having 12 practices, grouped into five areas [63] shown in Table 8 :
29
3 Methods
3.1 Development software
Abaqus FEA was chosen for the development software in this thesis. The chosen development
software defines used programming language, which is Python. The other programs use
different programming languages (Table 9).
30
analysis jobs. Abaqus/Viewer is a subset of Abaqus/CAE that contains the postprocessing
capabilities of the Visualization module. [57]
The Abaqus/CAE, Abaqus interface for MSC.ADAMS and Abaqus/Viewer are the automated
products in this thesis. When a model is created by the user in the Abaqus/CAE graphical user
interface (GUI), commands are issued internally by Abaqus/CAE after every operation. GUI
generates commands in an object-oriented programming language called Python. The
commands issued by the GUI are sent to the Abaqus/CAE kernel. The kernel is the brains
behind Abaqus/CAE. The GUI is the interface between the user and the kernel (Figure 21). [57]
The Abaqus Scripting Interface allows the user to bypass the Abaqus/CAE GUI and
communicate directly with the kernel. A file containing Abaqus Scripting Interface commands
is called a script.
Figure 21: Abaqus architecture. Abaqus has three processes kernel, GUI, and analysis. The GUI and
command line interpreter execute commands in different namespaces of the kernel interpreter. This
avoids a user overwriting a variable required the application. Messages from the Abaqus analysis are
processed using the Job Monitoring API. The Abaqus GUI uses an internal Python interpreter. This is
not exposed to the user but can be used for GUI customization. [57]
The Abaqus Scripting Interface (ASI) is an Application Programming Interface (API) to the
models and data used by Abaqus and it is an extension of the Python object-oriented
programming language. The ASI can access the Abaqus/CAE and Abaqus/Viewer and it can be
used to [57]:
create and modify the components of an Abaqus model, such as part, material, loads
and steps,
create, modify, and submit Abaqus analysis jobs,
read from and write to an Abaqus output database,
view the results of an analysis,.
customize Abaqus environment via the Version 6 environment file (abaqus_v6.env),
perform parameter studies, and
create Abaqus Plug-ins.
31
3.1.2 Abaqus Python integrated development environment
Abaqus PDE is a built-in Python integrated development environment (IDE) in Figure 22. PDE
provides an alternative to using a shell command line and a text editor for developing and/or
running code. PDE also provides text editing (syntax coloring), debugger and more IDE tools.
Abaqus PDE is accessible from within Abaqus/CAE or start the program independently.
The Abaqus PDE is used as the main integrated development environment, because Abaqus
PDE can only IDE which is capable to run Abaqus scripts and debug those when Abaqus is
running.
32
Figure 23: The Graphical User interface of The Eclipse.
In practice this means that the developer should write clean and good code. Only those
features that the customer really need should be included. According to [19] 64 % of the
features are seldom or never used as shown in Figure 24 [19, p. 142]. Unused features are a
33
waste of money and away from the quality of the code. Unused features make the
development time longer than necessary.
13% Sometimes
Always
19%
7% 64% Often
45%
16%
Rarely
Never used
Figure 24: Research of how much Microsoft Word functionality is used. [19, p. 142]
JACAX framework philosophy is based on the manifesto for Agile software development. The
idea of JACAX is to use standardized format (for example neutral geometry formats) as much
as possible and XML-sidecar as a middleware to reduce data losses and remove manual
repairing of the model (Figure 25). When the sidecar is used, there is no drop in data during
translation between different programs.
Figure 25: All information that is available at the end of the geometry definition process is transferred
to CAE processes. This further enables automation of the simulation, since no human interaction is
necessary to rebuild the information that is lost in the transfer. [6, p. 6]
XP is the used Agile method in this thesis. The basic of Agile methods is to break a program
development project into smaller task. For example the automated MNF generation task is
divided into five smaller tasks (Figure 26).
34
Figure 26: Break big task down into smaller ones. Days are presenting estimated time for coding. [19,
p. 17]
These tasks include small steps with minimal planning, and do not directly involve long-term
planning. Iterations are short time frames which typically last from one to four weeks. Each
iteration involves a full software development cycle. Stakeholders produce documentation as
required. An iteration may not add enough functionality to warrant a market release, but the
goal is to have an available release with minimal errors at the end of each iteration. Multiple
iterations may be required to release a product or new features. The engine for getting stuff
done in agile project is the iteration. A one to two week period where you take your
customers’ most important stories and transform them into running, tested software. [19]
In Agile, the master story list is the projects to-do list. It contains all the high-level features
(user stories), what the customer will want to see in their software. Heavy documentation as a
means of capturing requirements has seldom really worked for software projects. Customers
seldom get what they want. Agile user stories are short descriptions of features what
customers like see in their software [19, p. 20].
A user story is one or more sentences in the everyday language of the end user. Each user
story is limited, and it should fit on a small paper note to ensure that it does not grow too
large. The user stories should be written by or for the customers for a software project and are
their main instrument to influence the development of the software. User stories could also be
written by developers to express non-functional requirements. [19, p. 98-113]
User stories are used to capture what the user wants to achieve and what kind of basis
features can be implemented. User stories are a quick way of handling customer requirements
without having to create formalized requirement documents and without performing
administrative tasks related to maintaining them. The intention of the user story is to be able
to respond faster and with less overhead to rapidly changing real-world requirements. [19, p.
98-113]. Advantages of the user stories:
Being very short. They represent small chunks of business value that can be
implemented in a period of days to weeks.
Allowing a developer and the client representative to discuss requirements throughout
the project lifetime,
Needing very little maintenance.
Only being considered at the time of use.
Maintaining a close customer contact.
Allowing projects to be broken into small increments.
35
Being suited to projects where the requirements are volatile or poorly understood.
Iterations of discovery drive the refinement process.
Making it easier to estimate development effort.
The XP uses really short development cycles to incrementally design you software. Unit test
are written before the eventual code is written. Unit test are automated test that test the
functionality of pieces of the code. This approach is intended to stimulate the programmer to
think about conditions in which the code could fail. This means that the programmer is
finished with a certain piece of code when the code cannot fail any situations. [19, p. 225-235;
21]
Tests are supposed to fail; there’s no code to make them pass. A good test framework helps
TDD cycle; the less time and work it takes to run the test and interpret the results, the quicker
the test-driven cycle. The idea is explained in Figure 27.
Figure 27: In first the phase (red) a failing unit test is written to show what the new code would do. In
the second phase (green) the prototype of the code is written and to phase. In the final phase (blue)
the code is refactored, that means that the code is cleaned from for example duplication and the code
is lean and as clear as possible. [19, p. 226]
Unit tests are small, method-level tests that developers write and run. A unit test is updated
every time changes are made to the software to prove the changes they made work as
expected. The unit tests are invaluable because once developers automated and made them
easy to run, we can run them every time we make a change to our software and know
instantly whether we broke something. Typically agile projects will have hundreds if not
thousands of unit tests. The benefits of writing lots of these against your code base are many
[64]:
36
supports collective ownership, as a test serves as both documentation and a safety net
for future development.
Tests fall into two categories. A unit test explores the behavior of individual pieces of code and
check implementations. Acceptance test (or customer test) verify that the requested features
match the business requirements and expectations of the customer. For every request, work
with the customer to write automated acceptance test to prove that the request has been
implemented successfully. When all of the acceptance tests pass, the work is complete [65].
The example of the unit test is presented in Appendix I
A digital design user case is developed to simulate industry needs in a SBD. In this thesis a
diesel engine is chosen for a virtually developed product. Diesel engines are complex multi-
physical designs and, therefore, numerous parameters are linked to each other [71]. A realistic
simulation of a diesel engine needs multidisciplinary knowledge and use of different CAE
programs. This makes the user case an ideal test bench for SDM and application integration.
The use of multiple multidisciplinary programs makes it challenging to transfer data between
different programs and store it. The digital user case is represented in Figure 28.
37
Figure 28: The process diagram of the digital design case.
Excel is used to start the digital user case. Excel does the optimization of numerous linked
parameters. It tries to find the key engine calculation parameters and logical calculation
processes that can be used for engine design optimization [72]. Excel is also used to
preliminary check of engine functionality (Figure 29).
Figure 29: The GUI of the Digital design in Excel. The process design is launched using the spreadsheet
calculator.
Results of Excel calculation are used in CAD, where a CAD program (Pro Engineer) reads values
from a spreadsheet. The CAD program (Pro Engineer) generates 3D geometry from the
calculated parameters and saves the modeled geometry to IGES format. Because neutral
formats are mainly designed for geometry transfer and to avoid a drop at metadata level, Pro
Engineer also produce XML sidecar for FEA and MBS (Abaqus and ADAMS). IGES and XML are
transferred to ADAMS and Abaqus. Pro Engineers uses its external analysis feature for reading
the parameters from Excel spreadsheet.
Abaqus and Adams generate models from IGES and XML sidecar. The XML sidecar contains
information such as:
38
the coordinates of the inner nodes,
the type of the entities,
the coordinates of the entities,
joint type, and
the coordinates of the joint.
Abaqus generates modal neutral files which are needed in the flexible multibody simulation.
Adams imports MNF-files and finalizes the model. Adams exports the loads and the forces into
the Abaqus input-file. Abaqus merges the Adams input file with its input-file and calculates
stress and strain for the part of the diesel engine. Abaqus creates report from simulation and
exports the results to the XML-sidecar.
In this user case study Abaqus generates MNF files for Adams. As shown in Figure 30.
Figure 30: Flexible parts of the diesel engine; a piston, connectin grod and a crankshaft.
model definition,
perturbation step generation (for each retained nodal DOF) to generate the
constrained modes,
eigengfrequency analysis to generate the normal modes (the retained nodal DOFS are
fixed),
generation of an Abaqus substructure (A flexible body is a substructure. It is generated
using the component mode synthesis and saved in a library file so that it can be
attached to the other parts of a FE model via the retained nodal DOFs ),
run the Abaqus analysis, and
39
MNF file generation with modal stress and modal strain or without modal stress and
modal stress by using the Abaqus Interface for MSC.ADAMS. The interface reads the
Abaqus results files to create the modal neutral file.
Abaqus/CAE uses ACIS as kernel for geometry [24, p. 24]. The solid geometry of the diesel
engine´s part is represented in an IGES file by a series of surfaces and Abaqus/CAE has to stitch
these surfaces into a solid (Figure 31). Abaqus/CAE checks that the geometry is valid; the valid
geometry means that the geometry has no gaps between edges etc. Imported geometry is
generally made valid during import.
Figure 31: To stich gaps between intersecting edges, Abaqus/CAE adjusts the underlying surfaces until
A1 = A2. [24, p. 25]
Thus, IGES tolerance limit is bigger than the tolerance limit in Abaqus/CAE (The ACIS tolerance
is 1e-6 [24, p. 30]) and that for the imported geometry is imprecise (Figure 32). The imprecise
geometry might cause that quad or hex meshing using a medial axis algorithm might fail. It
might also be that algorithm is not able to produce good mesh. A good mesh is very important
in order to minimize the errors in the solvers leading to numerical diffusion and incorrect or
inaccurate results.
Figure 32: An imported connecting rod at IGES-format. As a result from the tolarence of IGES, the part
is imprecise.
To successfully import a solid defined by trimmed surfaced or B-reps, the tolerance of the
original file and the tolerance of Abaqus/CAE must match within an acceptable limit. After the
user imported a part into Abaqus/CAE, the healing process is designed to improve the part’s
40
accuracy. The Abaqus/CAE provides the following additional options when IGES is imported.
Those processes are:
Abaqus/CAE tries to change the neighboring entities so that their geometry matches exactly.
After geometry repairing Abaqus assigns material to the geometry of the part. This is essential
part for the simulation. After that Abaqus searches surfaces and points by using information
from the XML sidecar. These points and surfaces are used to define interface and inner nodes.
The nodes coupled each other’s by using Abaqus coupling method. Abaqus also reads
information for the boundary conditions and the retained dofs from the sidecar.
A frequency simulation is needed to calculate the fixed-interface normal modes. Element mass
matrices and eigenvectors are written in a results file [48]. For each element the mass at a
node is computed by summing all terms in the row of the element mass matrix corresponding
to the first degree of freedom at that node. A displacement written in the results file will be
used to update the nodal coordinates written is the modal neutral file. After that there is a
substructure is generated. Abaqus generates mesh for the part and starts solving the
simulation. When the simulation is finished, Abaqus starts the Abaqus interface for
MSC.ADAMS to generate the MNF files.
41
Figure 33: FEA loads from Adams. Every time increment in Adams presented as steps in Abaqus input-
file.
Abaqus uses the same procedures which are presented in the previous chapter, but there are
some exceptions, Abaqus does not define boundary conditions, frequency and substructure
generation steps. In this script, Abaqus defines:
mesh,
material properties,
the first structural analysis step,
couplings between “interface nodes” and surfaces. In this case those are normal nodes
where loads are affecting, and
solver parameters.
The boundary condition and loads are still missing and these are needed to solve the structural
analysis. The input file from Adams contains only loads for parts. To avoid negative eigenvalues
and that the result is converging, there is a need to define boundary conditions at the
simulation. These boundary conditions are defined by the CAD user by using XM sidecar or
Abaqus searches three/four the farthest points from the gravity center of the part. These
points are used for boundary conditions. When the boundary conditions are defined Abaqus
solves the simulation. The script reads the results from the simulation and writes the results in
the sidecar.
42
3.5 MNF file verification
When the modal neutral file is generated, there are usually two questions about the MNF file.
The first question is, was the translation process of the FEA model successful? The second
question is how many modes must be included in the flexible multibody simulation? With
fixed-interface modes it can be difficult to determine how many modes are needed to provide
a sufficiently accurate solution; the constrained model can have higher natural frequencies
than the target global model [74].
To answer these questions, the natural frequencies of the flexible bodies are recorded in
Adams/Linear and compared with those that the FEA program Abaqus predicted for the same
set of constraints. Unless the FEA translation process failed in some way (for example, units
were misrepresented) or there is an inadequate number of modes, the natural frequencies
should match [53]. Other possible reasons to that the frequencies are not the same:
boundary conditions and retained nodal DOFS (degrees of freedom) are set wrongly in
Abaqus,
interface node is coupled with wrong inner nodes in Abaqus, and
interface node located at wrong place in Abaqus.
For comparing natural frequencies, a paired t-test is used. The paired t-test is a statistical
hypothesis test, which the test statistics follows a Student’s t distribution. The correct testing
method is following. [75]
[22]
[23]
[24]
[25]
[26]
[27]
̅ is an arithmetic mean. The Arithmetic mean is presented in equation 28 and n is the count
of the observation.
̅ ∑ [28]
43
sample variance is defined by equation
∑ ̅ [29]
̅
[30]
√
Null hypothesis is
[31]
If the null hypothesis is true, the paired t-test follows the Students’t distribution by
. The natural frequencies of Abaqus and Adams are compared at Chapter
4.4.1.
[32]]
44
4 Results
The results chapter consists of five parts:
user stories,
Cube development and test environment,
workflows for FEA integration,
architecture for FEA integration framework, and
digital design user case.
4.1 User stories for developing FEA integration for digital design
A master story list contains all the high-level features (user stories). Gathered user stories for
this thesis are showed in Figure 34.
Heavy documentation never works in software projects because customers seldom get what
they want. Gathering heavy requirements is vast amounts of time and energy, instead of doing
what needs to be done. Agile user stories are short descriptions of features what customers
would like to like to see in their software [19, p. 20]. From the user stories are built a heavier
to-do-list to fulfill the user stories (See appendix II). This to-do-list is used to research principles
FEA integration into digital design and coding scripts for Abaqus.
45
The result to Excel user story is used to generate technical requirements and more user stories
for example. Generated requirements and user stories are:
From these user stories and requirements is generated the heavier to-do-list for the coding.
Abaqus is able to search entities by using the codes of the color, but that means the geometry
is modeled at Abaqus or it is transferred by using ACIS format. The CAD user specifies wanted
entities by a color. This method is not useful because it supports only one file format.
The second method is to search entities by its ID number. This number is defined in a CAD of a
FEM program, but this method is not reliable because the ID of the entities can change during
translation between different programs, during geometry repair or when new feature is added
or old one is deleted.
The third method is to search entities by using search areas and coordinates. The CAD user for
example wants to define the inner surfaces of the connecting rod; the user gives the
coordinates of the center, radius for ends and length which is in this case the length of the
bearing. Other similar search methods are also available in Abaqus [76; 77]:
46
The chosen method uses Abaqus findAt(..) command. This is not the general method for all
finite element programs but for the digital design user case this is the most general and the
easiest for the CAD user. The script search entities by using coordinates, in the first phase
Abaqus searches entities and returns the ID of the entities. This ID is used for generating a set
and this set is used for either region coupling, boundary condition or load. Now this ID is
reliable because we point to Abaqus data structure of the imported geometry and this phase is
done after importing the geometry and the geometry repair. The script is presented at Figure
35.
Figure 35: The example of search script. This script also generates a set from wanted entities.
The test bench is also useful for continuous iterations. This supports developing the code,
finding key factors which are needed for automated finite element analysis and research of
different ways to tag entities and find the tagged entities.
47
Table 9: Grouped workflows for FEA integration.
Group Task
A geometry import
B geometry repair
C Mesh generation
E material import
F simulation automation
The geometry import group A is the most essential for integration, because this group enable
the transfer geometry, from CAD to FEM program or from finite element pre-processor to FEA
( for example Altair HyperMesh).The Part geometry can be defined in three ways in finite
element domain and that why the task of this group A are:
Group B, the Imported geometry usually requires some repairing or defeaturing to obtain high
quality mesh. Small edges and faces (holes, chamfers, fillets, and slivers) limit the user´s ability
to generate mesh successfully on both solid and shell geometries. An unwanted detail
removing is essential because excessive details will influence the mesh and dominate the time
taken to perform the analysis. According [78; 79] Abaqus and Ansys are able to perform
automated virtual topology. The tasks of the group B are:
The Mesh generating group C is also essential for automation for FEA automation and
integration. Mesh affects the accuracy and reliability of results of FEA. Principles of this group
are:
48
automated top down meshing, and
automated verify tool for native mesh.
The accuracy and reliability of the results depend heavily on the quality of the decision made
during the analysis process and the quality of the mesh. Good mesh is important in order to
minimize the errors in the solvers leading to numerical diffusion and incorrect or inaccurate
results. Good mesh has three components:
good resolution
appropriate mesh distribution, and
good mesh quality.
To fulfill the demands of the good mesh a script was to it linearly iterates suitable mesh for the
part and trying to find good mesh for it. The workflow of this script is presented in Figure 37.
First, the script iterates linearly the best suitable element shape for the geometry and the
order for this is:
hexahedron
hexahedron dominated, and
tetrahedron.
When the script founds the suitable element shape according to predicted criteria, it starts
refining the global seed size of the geometry until it fulfills the requirements for mesh (Figure
36).
The group D is essential for automation because finite element program is able to read the
boundary conditions and the loads from CAD. Which are defined in XML sidecar. The tasks are:
The group E is essential for material properties. The Finite Element program has able to import
also material properties from material databanks or from the CAD and that why the tasks are:
49
automated material import, and
automated properties assign tools.
The last group F of the key factors is the simulation automation. This group affects the solver
and the results. The tasks are:
This group is useful if there are a lot of parameters and different models which have to be
checked and compared. If these are used well, there is no need for human check the results of
the simulation. An example of the unit test for the simulation is presented in Figure 37. The
user can check only the results and don`t have to spend time analyzing the results. The
automated unit test is adopted from the coding tools. In computer programming, the goal of
unit testing is to isolate each part of the program and the show that individual part.
Figure 37: An example of unit test for simulation. Where are eigenvalues from Abaqus and Adams are
tested to be the same. If they are the same the mnf-file is passed to Adams and if not Abaqus is
launched again and changes mesh parameters.
The front end is responsible for collecting input data in various forms from the user and
processing the data to conform the specifications set by the back. The front end is program
type dependent.
A front adaptor is to protect other parts from the changes in the front end. The adaptor also
enables to code the front end for different stakeholders’ needs. The reader reads XML or
another used file format and uses the read information to fulfill task variants. The expert
knowledge is a store for a task. The tasks are automated FEA processes or simulations defined
and written by experts depending on the stakeholders’ needs. The tasks are FEA application
but if the FEA application changes indepedent, some tasks need a middleware between the
task and the expert application interface. The main idea of a task is to enable the change of the
used FEA application.
50
Figure 38 The architecture of the FEA integration framework
The expert application interface task is to protect from version changes of the FEA application
and changes the API changes of the FEA application. The FEA application and the expert
application interface are application dependent.
51
Figure 39: An example of the sidecar. The XML contains information from the parts and it generates
the boundary conditions for the simulation.
Because the needed vocabulary for fulfilling the needs of the automation task is minor for the
structural analysis, the vocabulary is extended. This extended vocabulary is presented in
Appendix III and it contains tags for a normal structural analysis. In Figure 40 is presented the
example from Figure 39 as a tree structure.
52
Figure 40: The XML-file presented as tree structure.
For every flexible component of the diesel engine18 modes are calculated, only frequencies
under 10 000 Hz are taken into account. The natural frequencies are exported from both
Abaqus and Adams.
53
The idea of this comparison is to check it the MNF file is transferred correctly, and to check
that eigenvalues are exactly right. The comparison of the natural frequencies of the connection
rod is presented in Figure 42.
Figure 42: The comparison between interpolated frequencies from connecting rod from Abaqus and
Adams.
The comparison is done by using a paired t-test. The test is safe to use when the number of
observation is bigger than 15. The comparison is done with frequencies under 10 000Hz and
frequencies are interpolated until 10 000 Hz is reached; this is done because the number of
observations is too low with original modes. The connecting rod has four orginal modes under
10 00 HZ and The natural frequencies of the connecting rod (0 - 10 000Hz) are split into four
areas:
1227,6 – 4203,8 Hz
4203,8 – 4277,1 Hz
4277,1 – 9164,8 Hz
9164,8 – 9607,2 Hz
By using Microsoft Excel trendline tool is possible to get equation to interpolate natural
frequencies and grow up the count of observations (Figure 43).
54
Figure 43: Natural frequencies are growing up linearly in area 1227, 6 – 4203, 8 Hz. By using the
trendline we get equation to interpolate frequencies.
By interpolating the count of observation of the connecting rod is raised from 4 to 35. The
crankshaft does not need interpolation because it has 18 modes under 10 000 Hz. The
comparison of the natural frequencies of the piston is not done because the first natural
frequency exceeds the limit.
[30]
Is natural frequency from MSC.Adams and I is the mode number (equation 31).
[31]
[32]
[33]
̅ ∑ [34]
(∑ ̅ ) [35]
Using equations [34] and [35] the paired t-test is defined using equation.
̅
[36]
√
55
. [82]. Using the significance level of 1 %.
[37]
Critical values of the significance level now are presented equations 38 and 39 for the
connecting rod.
[38]
[39]
The calculated result is not in rejection area meaning the null hypothesis is valid and all
frequencies are the same in Abaqus and Adams. This is presented in Equation 40. The
calculated result is compared value from Ilkka Mellin`s statistical tables [80].
2,724 [40]
The boundary conditions are defined by the CAD user (The XML sidecar) or by using a script.
This script searches the center of gravity of the part and searches three or four of the farthest
points. To the farthest point, the script sets boundary conditions. Boundary conditions are
given in Abaqus/CAE as zero values for displacements at boundary condition nodes.
56
Figure 45: Results from the Abaqus result file. In this case the numerical singularity is by from the rigid
body movement.
These boundary conditions might cause inaccurate results. Thus, the elements are connected
to the farthest points are removed from the result. The comparison of the result is presented
in Figure 46.
Figure 46: The comparison between cleaned and uncleaned results. On the left is the result where all
elements which are connected to the boundary condition node are removed. On the right is the result
where all elements are kept. The maximum stress of the uncleaned results over two times bigger
than the cleaned result.
The scripts search the maximum stress and strain from the steps and write the results to the
XML-sidecar (Figure 47). These results are transferred to Excel.
57
Figure 47: An example of the results at an XML-format.
The main idea of JACAX is the integration of the programs’ data systems. In the CAx, the CAD is
the corner stone because the simulations are mainly based on the model geometry. For
manufacturing simulation and finite element simulation variations of CAD geometry are
generated. Because the data systems are presented as feature trees in a CA system, it possible
to say, that JACAX aims to integrate different programs’ feature trees. JACAX extends a feature
tree of a CAD by integrating other programs into it.
This integration is realized by using standardized supported formats, for example neutral
formats STEP and IGES and native geometry formats. However, these formats are not able to
transfer all needed information for the simulation. Therefore, a sidecar is used to eliminate a
drop of metadata and the information level. The sidecar is based on extensible markup
language (XML). The user defines the content of the sidecar. In Figure 48 the idea is presented,
how should be the information transferred between different programs.
Figure 48: The JACAX is a software solution to solve the information transfer from CAE software A to
CAE software B. [18]
JACAX gives freedom the user to selected arrange information to transfer that way which suits
the best to the user. JACAX don’t define any grammar and vocabulary for the XML, it only gives
examples and guidelines to write XML.
58
The JACAX uses a hybrid method to handle application integration. It is a combination of a
point-to-point strategy and a process broker. JACAX uses the point-to-point method when it
transfers geometry by using neutral geometry formats. In the digital design user case (Figure
49) the information is moved directly from Excel to Pro Engineer by Excel’s own file format and
directly from Pro Engineer to Abaqus and Adams by IGES-format. However, this arrangement
has problems. Data is lost at metadata level, the process logic is spread and embedded in
different applications, and the maintenance and the extension of the process is not easily
arranged.
Figure 49: A point-to-point strategy is the base layer in a hybrid method. Pro/Engineer provides only
geometry for Abaqus and Adams at this point (left). In the hybrid method the XML-based sidecar
works as a process broker and handles the process and embeds the results. Pro/Engineer provides
XML-file which contains metadata information for Abaqus and Adams (right).
To solve problems the point-to-point combined is with the process broker (Figure 51). In the
process broker the process logic is encapsulated in one place. In the JACAX´s case, the process
logic is encapsulated in the XML-based sidecar. The batch scripts are used to launch the
simulation and Pro Engineer is used to generate the sidecar.
This combination is called a “lightweight hybrid broker”. The solution is lightweight because it
uses neutral and native geometry formats and the sidecar encapsulates only needed logic and
it does not try to work with all existing CAE applications. The JACAX fulfills the requirements of
the application integration. These requirements for the application integration are defined by
Red Oak software company [28]. Those requirements are:
JACAX differs from studied commercial application because it does not enforce to use specific
CAE programs in the digital design process.
59
The functionalities of the JACAX and its levels are presented in Figure 50. A meta level can be
called knowledge level, because it consists of the knowledge of the enterprise or the expert.
During the process model and data are transformed, but also metadata e.g. information about
CAD and simulation model, product specification, and simulation results, are transformed and
transferred. Therefore in the digital design it is necessary to manage not only the data
transformations but also the flow of the metadata. Experts and designers are interested in the
history of a data. Metadata in the digital design can be divided into five categories [83;8 ]:
structural metadata,
workflow metadata,
descriptive metadata,
lineage metadata and
technical metadata.
Structural metadata is classified into the description of tool and domain specific data models,
description of the structures of local data as well as integration information. The information
can be distinguished into different levels [83]:
Description of the local data model in every domain using a common notation.
Description of the structure of local data and model of every domain using the local
data models.
For example, the data model is a CAD data model consisting of parts, assemblies, and features.
The structural metadata describes the structure of actual models. Such as a class parameter or
the assembly hierarchy of a CAD model with part names and parameter values [83].
Integration metadata represents the correspondences between different domains and a model
which describe semantic dependencies between structural elements, the material parameter
of a CAD model for example [83].
Workflow metadata allows the explicit definition of activities comprising a digital design. In the
context of the digital design, workflows are used to track the data and its transformations
60
made by different systems and one individual or a small group of individuals. Parts of
workflows can be reused and recombined.
Descriptive metadata helps users and system to find, to document, and to connect resources.
The metadata is defined as free text of term of a pre-defined ontology. Typically, metadata is
either stored in a metadata repository or as annotation together with the data [83].
Data lineage metadata comprises all information about a process that was used to develop a
product (Figure 51). Data lineage information explains and documents the history of design
decision based on the collected metadata about transformation and data.
The metadata from the metadata level is used to populate a process level and script level. The
processes level contains enterprises’, experts’ or CAE applications procedures, for example
MNF file generation. This level consists of the different simulation processes.
Script level is supporting the processes level. It contains scripts or macros, which are meant to
do desired processes. The scripts or macros are written at the API of CAE applications. This
level contains also writers and readers which are needed to convert the XML sidecar metadata
for the scripts or macros. The application level contains CAE applications.
61
5 Discussion
The main results of the thesis can be summarized as:
5.1 User stories for developing FEA integration for digital design
Heavy documentation seldom works for requirements in software projects because customers
usually don`t what they want. It is impossible to gather all requirements at the beginning of
the project and whatever requirements you gather are guaranteed to change. The heavy
documentation don´t work also for the documentation of the code and for the application
programming interface (API) because it makes the documentation difficult to read and hard to
assimilate new information.
The user cases, unit tests, the to-do-list and the code work as documentation. There is no need
for heavy documentation which describes every small detail in such a way that every member
at the development team member understands the document. That is usually a waste of time.
The documentation is meant for finite element experts and for coders and this makes it easier
to expand the code, because a new member has “API” for the automation and examples from
the script.
The chosen method enables a CAD user to mark entities in the CAD and move information
from entities to FEA. The chosen method does not need so much coding from the CAD user
when it is compared with the other found methods.
Initially, some small structural analysis tasks for different finite element programs were
planned to be developed in the beginning, but this excluded because of refocusing the topic.
The vocabulary could be even better if the research and scripting would have been done with
many programs, for example with Abaqus, Ansys and Patran. However, in the future
62
integration and automation needs to be done for other for other programs also. What is done
at this point is a good base for further steps and other automated Finite Element tasks,
because the scripting is done well and it is easily extended. Also data losses of the translation
are avoided by using the developed XML-sidecar.
The Architecture for FEA integration framework makes it possible to keep the maintenance of
the framework as easy as possible and to make the extension of the framework easy to
expand. This has been proven during this thesis and in the Silicom project. The framework
makes it easier to code different programs and different simulations. This is what users and
experts want from the programs. The easy usability of the programs is more import than
having lots of features.
SIR-111299: MNF files created on Windows 64-bit platform may have incorrect
eigenvalues. These incorrect values are obvious as the eigenvalues are extremely large
(of orders of magnitude 10^100) and the model itself is unseen in Adams/View. The
workaround is to use Windows 32-bit platform for translation. [84]
This bug means the Abaqus interface for MSC.ADAMS at the Windows 64-bit platform was not
used. The Workability for scripts is proven by running the script at CSC in a Linux platform. The
part of Abaqus works as it was planned.
The paired T-pair test results show that the natural frequencies of the connecting rod and
crankshaft were in good accordance. The used limit frequency (10 000 Hz) was too high
because in the real world natural frequencies of the diesel engine are under 1 000 Hz. The
unrealistic limits were used because calculated natural frequencies start above the realistic
limit and the real number of observations of the parts of the diesel engine is too for use the T-
pair test. The test is not done for the piston because the first frequency is presented at 9829
Hz. This means that boundary conditions might be faulty at Abaqus. The automated boundary
condition might cause inaccurate results and even cleaned results are not exactly right. This
area needs more research in the future. Nevertheless, these are not major shortcome because
the digital user case in this study is mainly used for producing data for SDM and research
automation and integration, not to design a real diesel engine.
63
Most of the objects of this thesis are fulfilled. Now we are able to integrate and automate FEA
as a part of bigger simulation loop in the digital design. This is proven by fulfilling the tasks of
the digital design user case and by solving tricky problems, such as; how the CAD should point
the surfaces and how to automate time-consuming tasks like the automated boundary
conditions for the structural analysis, for instance.
64
6 Bibliography
1. Simulia, a Dassault Systemes Brand. The Case for Simulation Lifecycle Management. [PDF]. 2011.
[cited 2011 11 27]. Available from:
http://www.simulia.com/download/pdf/SIMULIA_SLM_WhitePaper_Complete.pdf .
3. Altair Engineering. HyperWorks A Platform for Innnovation. [PDF]. 2011. [cited 2011 211 22].
Available from:
http://www.altairhyperworks.com/Solutions,1,23,HyperWorks%20Enterprise.aspx .
4. Comet Solution. The Comet Workspace. [PDF]. 2011. [cited 2011 11 22]. Available from:
http://cometsolutions.com/products/workspace/ .
5. MSC.Software. SimXpert for Integrate Simulation Environment. [PDF]. 2011. [cited 2011 11 22].
Available from: http://www.mscsoftware.com/Products/CAE-Tools/SimXpert.aspx .
6. Nawijn M, van Tooren M, Berend J. Automated Finite Element Analysis in a Knowledge Based
Engineering Environment. [PDF]. [cited 2011 11 21]. Available from:
http://academics.ewi.tudelft.nl/live/binaries/f1030549-cee5-4197-a4b0-
2197fe671949/doc/Mesh-Papers-v2.pdf .
7. Sun W, Ma Q, Cheng S. A Framework for automated finite element analysis with an ontology-
based approach. Journal of Mechanical Science and Technology. [Journal] Volume 23.
2009.[cited 2011 11 27]. Available from: http://dx.doi.org/10.1007/s12206-009-1005-0.
8. Simulia, a Dassault Systemes Brand. Abaqus Multiphysics. [Webpage]. 2011. [cited 2011 12 20].
Available from: http://www.simulia.com/products/abaqus_multiphysics.html .
9. Ansys. Ansys Workbench Platform. [Webpage]; 2011. [cited 2011 11 22]. Available from:
http://www.altairhyperworks.com/HWTemp1.aspx?top_nav_name=HyperWorks
Overview&item_name=About .
10. Dassault Systemes. CATIA V5R21 drives higher Design excellence. [Webpage]. 2011. [cited 2011
12 3]. Available from: http://www.3ds.com/products/catia/portfolio/catia-v5/all-
products/domain/Analysis/?cHash=ce1ba86eb5d34c3b86ce1bbef9839952 .
11. Dassault Systemes. CATIA V6R2011 strengthens Virtual Design on the collaborative platform.
[Wepage]. 2011 [cited 2011 12 3]. Available from:
http://www.3ds.com/products/catia/portfolio/catia-v6/v6-portfolio/d/virtual-
design/s/mechanical/p/mechanism-simulation/?cHash=74e864052b04ce3c23811cdc5ec0a3fe .
12. Simulia, a Dassault Systemes Brand. Isight. [Webpage]. 2011 [cited 2011 11 22]. Available from:
http://www.simulia.com/products/isight2.html .
13. LMS. LMS Virtual.Lab. [Webpage]. 2011. [cited 2011 12 3]. Available from:
http://www.lmsintl.com/virtuallab .
65
14. Esteco. Process integration. [WebPage]. 2011. [cited 2011 12 3].
http://www.esteco.com/home/mode_frontier/Integration.html .
15. PTC. Creao Parametric. [Webpage]. 2011. [cited 2011 12 3]. Available from:
http://www.ptc.com/product/pro-engineer .
16. Solidworks. Solidworks-tuotteet. [Webpage]. 2011. [cited 2011 12 3]. Available from:
http://www.solidworks.fi/sw/6449_SVF_HTML.htm .
17. MSC.Software. SimXpert Integrated Multidiscipline Enterprise Simulation Solution for the CAE
Analyst. [Webpage]. 2011. [cited 2011 11 22]. Available from:
http://www.mscsoftware.com/Submitted-Content/Resources//ds_simxpert_a4_w.pdf .
18. Buda A. Silicom Project Summary-Simulation Lifecycle Management SLM. [Powerpoint]. 2011.
[cited 2012 01 01].
20. Janzen D, Saiedian H. Test-Driven development concepts, taxonomy, and future direction.
Computer.[PDF]. Volume 38. 2005. [cited 2012 01 01] . Available from:
http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1510569
21. Chromatic. Extreme Programming Pocket Guide (Ebook). O’Reilly Media. 2009. ISBN-10: 0-596-
55622-5
22. Michopoulos J, Mast P, Chwastyk T, Gause L, Badaliance R. FemML for Data Exchange between
FEA Codes. [PDF]. [cited 2012 02 01]. Available from:
http://femml.sourceforge.net/download/femMLPaperScr12.pdf.
23. Michopoulos J. Development of the Finite Element Modeling Markup Languge. [PDF]. 2002.
[cited 2012 01. 01.]. Available from:
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.196.2067&rep=rep1&type=pdf .
24. Simulia, a Dassault Systemes Brand. Abaqus/CAE:Geometry Import and Meshing. [Training
material].
25. Simulia, a Dassault Systemes Brand .Abaqus/CAE User´s Manual. 10.4.4 Exporting to an IGES file.
2011.
26. Johannnesson P, Perjons E. Design Principles for Application Integration. Advanced Information
Systems Engineering. [PDF]. 2000 .[cited 2012 02 01]. Available from:
http://dx.doi.org/10.1007/3-540-45140-4_15
27. Kungliska Tekniska Högskolan,Viewlocity. A Process Broker Architecture for System Integration.
[PDF]. [cited 2012 02 01]. Available from: http://people.dsv.su.se/~perjons/whitepaper.pdf
28. Red Oak Sofware. Red Oak Softeware´s Application Integration Framework FAQ. [Webpage].
2011 [cited 2011 11 27]. Available from:
http://www.redoaksw.com/whitepapers/appframefaq.html
66
29. Ansys. ANSYS Workbench Platform. [PDF].2011.[cited 2011 12 26]. Available from:
http://www.ansys.com/staticassets/ANSYS/staticassets/resourcelibrary/brochure/workbench-
platform-12.1.pdf .
30. LMS. Virtual.Lab online help. Main Concepts and Features.[Online material]. 2011.
31. LMS. Powertrain simulation. [Webpage]. 2011. [cited 2011 12 26]. Available from:
http://www.lmsintl.com/simulation/powertrain-motion .
32. Simulia, a Dassault Systemes Brand. Abaqus 6.11, Abaqus Interface for Moldflow User´s Manual.
[Online material]. 2011.
34. Wikipedia. XML. [Webpage]. 2011. [cited 2011 12 21]. Available from:
http://en.wikipedia.org/wiki/XML .
35. Schneider P, Huck E, Reitz S, Parodat S, Schneider A, Schwarz P. A modular approach for
simulation-based optimization of MEMS. Design, Modeling, and Simulation in
Microelectronics.[PDF]. 2000. [cited 2012 01 01]. Available from:
http://www.sciencedirect.com/science/article/pii/S002626920100101X
36. Brown M. XML processing with Perl, Python, and PHP. Sybex. 2002. ISBN: 0-7821-4021-1
37. MatML. A Data Interchange Markup Language.[PDF]. [cited 2012 12 21]. Available from:
http://www.matml.org/downloads/matml_03.pdf
38. MatWeb. ANSYS Data Downloads. [Webpage].2011 [cited 2011 12 21]. Available from:
http://www.matweb.com/help/ansys_intro.aspx .
39. MathWeb. SpaceClaim Data Downloads. [Webpage]. 2011 [cited 2011 12 21]. Available from:
http://www.matweb.com/help/spaceclaim_intro.aspx .
40. MatWeb. ETBX Data Downloads. [Webpage].2011. [cited 2011 12 21]. Available from:
http://www.matweb.com/help/etbx_intro.aspx .
42. MatMl. MatML A Data Interchange Markup Language. [PDF]. [cited 2011 12 21]. Available from:
http://www.matml.org/downloads/matml_03.pdf .
43. MatML. About MatML. [Webpage]. [cited 2011 12 21]. Available from:
http://www.matml.org/overview.htm .
44. FemML. FemMl about. [Webpage]. [cited 2011 12 21]. Available from:
http://femml.sourceforge.net/about.htm .
67
45. Ding L, Ball A, Matthews J, McMahon C, Patel M. Product Representation in Lightweight
Formarts for Product Lifecycle Management (PLM).[PDF].2007. [cited 2011 12 21]. Available
from: http://opus.bath.ac.uk/12768/
46. Dassault Systemes. Download the 3D XML Player.[Webpage]. 2011. [cited 2011 12 219].
Available from: http://www.3ds.com/products/3dvia/3d-xml/1/ .
47. Dannbauer, Meindi, Steinbat. Fatigue Analysis of Dynamically Loaded Structures with
ABAQUS,ADAMS and FEMFAT.[PDF].2004. [cited 2011 12 21].Available from:
http://www.femfat.com/Papers.3632.0.html?&showUID=415
48. Simulia, a Dassault Systemes Brand. Abaqus 6.11.,Abaqus Interface for MSC.ADAMS User´s
Manual.
49. Simulia, a Dassault Systemes Brand. Substructures and Submodeling With Abaqus.[Training
Material]. 2010.
50. Simulia, a Dassault Systemes Brand. Abaqus 6.11, Theory Manual Chapter 2.14.1 Substructuring
and substructure analysis.
51. Msc.Software. MD Adams 2011, Building Flex Body Model. Verifying Flexible Bodies. [Online
Material]. 2011.
52. Simulia, a Dassault Systemes Brand. Abaqus 6.11 Theory Manual, 2.5.1 Eigenvalue extraction.
[Online Material]. 2011.
53. Pinfold M, Chapman C. The application of KBE technigues to the FE model creation of an
automotive body structure. Computers in Industry.[PDF]. 2001. Available from:
http://www.sciencedirect.com/science/article/pii/S0166361500000798
53. Msc.Software. Building Flex Body Model, Verifying Flexible Bodies, Using Adams/Linear to verify
Flexible Bodies. [Online Material]. 2011.
54. Simulia, a Dassault Systemes Brand. Abaqus 6.11. Analysis User´s Manual, Volume IV: Elements.
Element Library.[Online Material]. 2011
55. Ansys. Introduction to Ansys Meshing. Meshing Methods for 2D Geometry.[Online Material].
2011.
56. Ansys. Introduction to Ansys Meshing. Meshing Methods for 3D Geometry.[Online Material].
2011.
57. Simulia, a Dassault Systemes Brand. Abaqus 6.11 Getting started with Abaqus: The Abaqus
products. [Online Material].2011
58. Simulia, a Dassault Systemes Brand. [Introduction to Python and Scripting in Abaqus, Abaqus
Architechture.[Training Material]. 2011.
59. Wikipedia. Agile software development. [Webpage]. [cited 2011 12 26]. Available from:
http://en.wikipedia.org/wiki/Agile_software_development .
68
60. Extreme Programming, A gentle introduction. [Webpage]. [cited 2011 12 27]. Available from:
http://www.extremeprogramming.org/ .
61. Extreme Programming, What we have learned About Extreme programming. [Webpage]. [cited
2011 12 27]. Available from: http://www.extremeprogramming.org/lessons.html .
62. Extreme programming, The values of Extreme programming. [Webpage]. [cited 2011 12 27].
Available from:http://www.extremeprogramming.org/values.html .
63. Extreme programmin, The Rules of Extreme Programming. [Webpage]. [cited 2012 12 27].
Available from: http://www.extremeprogramming.org/rules.html .
64. Extreme Programming, Unit Test. [Webpage]. [cited 2012 12 27]. Available from:
http://www.extremeprogramming.org/rules/unittests.html .
65. Extreme Programming, Acceptance Test. [Webpage]. [cited 2012 12 27]. Available from:
http://www.extremeprogramming.org/rules/functionaltests.html .
66. Bylund N. Simulation Driven Product Development Applied to Car Body Design,Doctoral
Thesis.[PDF].2004. [cited 2012 01 02]. Available from: http://epubl.ltu.se/1402-
1544/2004/33/LTU-DT-0433-SE.pdf
67. Lehtonen M. Simulation-Based Design Process of Smart Machines: VTT Research.[PDF] 2006.
[cited 2012 01 02]. Available from: http://www.vtt.fi/inf/pdf/tiedotteet/2006/T2349.pdf
68. Sinha R,Paredis C,Liang V,Khosla P. Modeling and simulation methods for design of engineering
systems. Journal of Computing and Information Science in Engineering. [PDF]. 2001.[cited 2012
01 02]. Available from: http://dl.acm.org/citation.cfm?id=381736
69. Murphy C, Perera T. The Definition of Simulation and its Role within an Aerospace
Company.[PDF]. 2002. [cited 2012 01 02]. Available from:
http://www.sciencedirect.com/science/article/pii/S0928486901000453
70. Jenkins B. Best Practices for Implementing Digital Simulation and Analysis: Five Lessons from
Savvy Automotive Powertrain Program Managers.[PDF]. 2005.[cited 2012 01 02]. Available
from:
http://www.plm.automation.siemens.com/en_in/Images/best_practice_automotive_2_tcm641-
24342.pdf
72. Valkonen A. Diesel engine early computational design.[Project report draft]. 2010. Aalto
University
74. Msc.Software. MD adams 2011,Export. FEA Loads. [Online Material]. 2011. [cited 2011 12 27].
69
75. Mellin I. Mat-1.2620 Sovellettu todennäköisyyslaskenta B. [Course material].
76. Simulia, a Dassault Systemes Brand. Abaqus 6.11 Scripting Reference Manual. [Online Material].
2011.
77. Simulia, a Dassault Systemes Brand. Abaqus 6.11, Scripting User´s Manual. [Online Material
2011.
78. Simulia, a Dassault Systemes Brand.Abaqus Data sheet.[PDF].2011.[cited 2012 01 01]. Available:
http://www.simulia.com/download/datasheet/Abaqus-CAE-6-11.pdf
81. Makkonen P. JACAX: Silicom Engine Demo Model WP 3.2 Concept Verification .[Project report
draft].2011.
82. Aalto University. Silicom, Simulation Lifecycle Management SLM Leading Group Meeting nr.
6.[Powerpoint].2011.
83. Geist I, Vornholt S. Metadata Repositories for Virtual Engineering.[PDF].2008.[cited 2012 01 01].
Available: http://wwwiti.cs.uni-magdeburg.de/~geist/publications/iff_wita2008.pdf
70
Appendix I Example of the unit test.
Appendix II To-do-list from user stories.
Appendix III Extend vocabulary for FEA XML.