| Previous | TableOfContents | Next |
Welcome to the Impact Finite Element Program.
This program was designed to be a free and SIMPLE alternative to the advanced commercial Finite Element codes available today. The guideline during the development of the program has been to keep things clear and simple in design.
Impact has been designed to be easily extendible and modular to enable programmers a way to easy add features to the program without having to enter other parts of the code. Impact has been written in Java. This choice of language may seem strange at first, but with the recent development of Java engines, speed penalty is not that significant. On the other hand, the Object Oriented features and the high portability of Java is a clear advantage for the future.
Impact is a Finite Element Code which is based on an Explicit Time stepping algorithm. These kind of codes are used to simulate dynamic phenomena such as car crashes and similar, usually involving large deformations.
There are quite few explicit codes around which might seem strange since the other cousin (implicit finite element) are quite common. The implicit codes are used to simulate static loads in structures. Something that explicit codes does not manage very well.
The explicit code is based on the simple formula of F=M*A where F represents a force, M is the mass of a body and A is the resulting acceleration of that body.
All the code does is to calculate the acceleration for the body, use a small step in time to translate this acceleration into a little displacement of the body. This displacement is then used to calculate a responding force since the body is elastic and can be stretched (thus creating a reaction force). This force is then used to calculate an acceleration and then the process is repeated again from the beginning.
As long as the timestep is sufficiently small, the results are accurate.
Impact is written in Java for two reasons:
On the other hand, Java might seem like
a strange choice since this is a high performance number crunching type
of software and Java is not known to be competitive to ex. Fortran or C++
in this area.
True, it is slower but with the new interpreters
from IBM and Sun, the built in runtime compiling actually gets the speed
up quite a bit so this is not such an issue after all.
Any simulation (like a car that will be crashed) is made by a finite element model. The car is chopped up into numerous small pieces called elements. The elements are connected with each other at connection points called nodes. The model is described in an indata file which is basically a list of all the nodes and their coordinates in space, followed by a list of all the elements and which nodes each element is connected to.
Each element can stretch and move according to a formula. This formula is specific to every different type of element (there can be many different types), but the important thing is that the formula accurately can predict how the element should behave. Since each element knows how to behave, the whole model will also behave correctly.
At the moment, Impact can only handle dynamic INCOMPRESSIBLE problems. Examples of problems with this kind of limitation is basically most real world dynamic problems. The following is a list of problems that Impact will be able to solve in the future.
Impact is currently in alpha state. It is not validated against any other program or test results which means that results should be treated with care
Here is a picture of the Impact_Logo model included as an example problem
The model consists of rod and solid elements. A constant force is pulling the lower corner of the T while the upper corner of I is kept fixed in space.
There are a large number of books available on Finite Element Theory. Most of them describe Finite Element from a static point of view and is therefore of limited interest to the potential Impact programmer.
On the other hand, the theory of element formulation is often usable to a large extent and having that in mind, here are a few proposals:
The first book is recommended to beginners and engineers in general since it deals with most issues from a linear algebra perspective. This makes the code writing quite close to the Impact format. It is also a very good book and the one I have had best feedback from.
Ted Belytschko's book is the "bible" in this field. The man behind explicit codes have finally written a compendium on the theory and some principle algorithms are also shown. However, for an engineers perspective, this book is quite deep in its places and is more suitable as a reference than as a learning book for beginners.
There are also some papers written which are of interest:
These papers form the basis of coming shell element extension to Impact.
To understand the concept behind object orientation, inheritance etc, the following book is a pleasure to read:
| Previous | TableOfContents | Next |