The Finite Element Machine (FEM) was a late 1970s-early 1980s NASA project to build and evaluate the performance of a parallel computer for structural analysis. The FEM was completed and successfully tested at the NASA Langley Research Center in Hampton, Virginia.[1] The motivation for FEM arose from the merger of two concepts: the finite element method of structural analysis and the introduction of relatively low-cost microprocessors.
- Finite Element Model
- Finite Element Programming Fortran
- Fortran Programmer Jobs
- Finite Element Fortran Programmers
In the finite element method, the behavior (stresses, strains and displacements resulting from load conditions) of large-scale structures is approximated by a FE model consisting of structural elements (members) connected at structural node points. Calculations on traditional computers are performed at each node point and results communicated to adjacent node points until the behavior of the entire structure is computed. On the Finite Element Machine, microprocessors located at each node point perform these nodal computations in parallel. If there are more node points (N) than microprocessors (P), then each microprocessor performs N/P computations. The Finite Element Machine contained 32 processor boards each with a Texas Instruments TMS9900 processor, 32 Input/Output (IO) boards and a TMS99/4 controller. The FEM was conceived, designed and fabricated at NASA Langley Research Center. The TI 9900 processor chip was selected by the NASA team as it was the first 16-bit processor available on the market which until then was limited to less powerful 8-bit processors. The FEM concept was first successfully tested to solve beam bending equations on a Langley FEM prototype (4 IMSAI 8080s). This led to full-scale FEM fabrication & testing by the FEM hardware-software-applications team led by Dr. Olaf Storaasli formerly of NASA Langley Research Center and Oak Ridge National Laboratory (currently at USEC).The first significant Finite Element Machine results are documented in: The Finite Element Machine: An experiment in parallel processing (NASA TM 84514).[1]
Fortran has been used to program two-dimensional finite element analysis and the same code is then modified for use in a parallel computing environment. The performance of the serial and parallelized code is then studied on computers of varying specifications.
Based on the Finite Element Machine's success in demonstrating Parallel Computing viability, (alongside ILLIAC IV and Goodyear MPP), commercial parallel computers soon were sold. NASA Langley subsequently purchased a Flex/32 Multicomputer (and later Intel iPSC and Intel Paragon) to continue parallel finite element algorithmR&D. In 1989, the parallel equation solver code, first prototyped on FEM, and tested on FLEX was ported to NASA's first Cray YMP via Force[2] (Fortran for Concurrent Execution) to reduce the structural analysis computation time for the space shuttle Challenger Solid Rocket Booster resdesign with 54,870 equations from 14 hours to 6 seconds. This research accomplishment was awarded the first Cray GigaFLOP Performance Award at Supercomputing '89. This code evolved into NASA's General-Purpose Solver (GPS) for Matrix Equations used in numerous finite element codes to speed solution time. GPS sped up AlphaStar Corporation's Genoa code 10X, allowing 10X larger applications for which the team received NASA's 1999 Software of the Year Award and a 2000 R&D100 Award.
- Which Compiler is faster when dealing with large matrices and arrays? Intel Fortran or C++? If you are about to develop a Finite Element Analysis Solver that will handle a large number of calculations performed through the use of matrices and arrays then is C++ going to perform similarly with Fortran or is Fortran still the best way to go.
- Three different FORTRAN programs which use the finite element method were converted into C and Java. The performances of those three programs are compared based on the execution time. Mesh points are changed in the programs and checked the execution times.
- Component-Based Design from Finite Element Software Written in the FORTRAN Language. Problem is given to a programmer, first suitable components have to be decided by the programmer. If a component for a. Convert finite element programs written in FORTRAN and C programming languages into programs in an object oriented language.
References[edit]
Impact Finite Element Program. 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. Object-Oriented Finite Element Programming for Engineering Analysis in C++. Have been widely used and procedural programming languages such as FORTRAN, pascal etc. Of design patterns to capture best practices in object-oriented finite element programming.
- ^ abO.O. Storaasli; S.W. Peebles; T.W. Crockett; J.D. Knott (1982). The finite element machine: An experiment in parallel processing(PDF) (Report). NASA. Retrieved May 9, 2016.
- ^Harry F. Jordan (1986). The Force on the Flex: global parallelism and portability(PDF) (Report). NASA. Retrieved May 9, 2016.
- Further reading
- Three Parallel Computation Methods for Structural Vibration Analysis.
- Solution of Structural Analysis Problems on a Parallel Computer.
See Also[edit]
Introduction
There is a good deal of discussion in the scientific computation circles regarding the 'ideal' language for developing efficient finite element codes. A cursory view of open source finite element software reveals that the dominant languages are C/C++, Fortran and Python. Each of these languages have their pros and cons: C/C++ is fast and powerful but very difficult to work with (for the typical scientific researcher who does not have an extensive background in programming), Fortran is quite outdated inspite of its amazing speed, Python is incredibly flexible and powerful for testing new ideas but does not fare well when it comes to speed. A typical compromise is to develop and test prototypes in Python and either partially or fully re-implement the computational hotspots using high performance languages like Fortran or C/C++. However mixed language programming brings its own share of difficulties. Moreover, developing efficient finite element code is crucially dependent on fast and robust linear algebra libraries and it is a non-trivial task to identify and integrate such libraries with a finite element code. From the point of view of a researcher, what is required is a language that is as easy to use as Python and as fast as C/C++ so that the major focus would be on testing new scientific ideas as against learning difficult programming paradigms and code optimization techniques. While no single language meets this requirement, a very interesting contender that comes close to the golden ratio is Julia. This article explores the utility of Julia for developing robust and efficient finite element codes.
A simple finite element code in Julia for solving the 2D Poisson equation over the unit square is presented in this article. The code uses only Julia's standard library and thus does not have any external dependencies. It solves the partial differential equation u,xx + u,yy = -6 over the unit square with the Dirichlet boundary condition u = 1 + x^2 + 2y^2 on the sides of the unit square. The code can however be easily modified to study other instances of the Poisson equation. The unit square is discretized with linear triangular finite elements and the stiffness matrix and load vectors are calculated using a one-point quadrature rule.
Background
Details of the finite element formulation for the Poisson equation and the type of mesh used can be found here. The performance of the code is compared with that of two good open source finite element software: FEniCS and FreeFem++. FEniCS is a collection of software for high level finite element code development written in Python and C++. FreeFem++ is a partial differential equations solver written in C++ and uses its own DSL (Domain Specific Language) with a C++ like syntax. There are many other excellent software which are not considered here.
About the code
Thanks to Julia's elegant syntax the code is largely self-explanatory. The finite element algorithm is presented in three files: poisson_fem.jl, finite_element.jl, mesh.jl. The implementation of a simple triangular mesh over the unit square, the mesh data types and other helper functions are provided in mesh.jl. Details of the finite element implementation for a given weak form, external load and boundary conditions are provided in finite_element.jl. The top level code that specifies the details of the problem to be solved is presented in poisson_fem.jl.
The Dirichlet boundary, the boundary condition and the external load are speficied in poisson_fem.jl using the functions on_boundary, dbc and f_ext respectively. The kernel of the 'stiffness' term for the Poisson equation is obtained from the variational formulation as grad(u).grad(v). This is specified in the function poisson_stiffness, as shown below, in terms of the shape function vector N and the matrix containing the partial derivatives of the shape functions dN where dN[i,j] = dN_i/dx_j.
A triangular mesh over the unit square is generated using
The argument of UnitSquare denotes the number of uniform divisions into which each edge of the unit square is divided. The linear triangular finite element space over the mesh is initialized as
Finally, the solution of the finite element problem is obtained as:
Functions dealing with the finite element implementation are gathered in finite_element.jl. Linear shape functions over a triangle with a one-point quadrature rule are used for the formulation of the finite element matrices. The crucial part of the code that determines the efficiency of the entire analysis is the specific way in which the stiffness matrix is handled. Three strategies, referred henceforth as methods 1, 2 and 3, are explored in the function solve_fe:
Finite Element Model
Method 1 uses a full matrix representation of the stiffness matrix. This is almost never used in practise since finite element stiffness matrices are sparse and algorithms that exploit this are significantly faster. A nice feature of Julia is its support for sparse matrices as part of its standard library. For cases when the number of non-zero elements of the sparse matrix is unknown, an empty sparse matrix can be initialized as shown in Method 2. The syntax for handling sparse matrices is identical to that of a regular dense matrix. However, inserting elements into a sparse matrix can be costly as the number of such operations increases. A further optimization can be effected by using an approximate estimate of the number of non-zero entries in a sparse matrix K to initialized three vectors I,J and V such that K[I[n],J[n]] = V[n], as illustrated in method 3. Further details regarding the implementation of method 3 can be found in the function fe_matrices.
Performance
The code execution time (in seconds), as a function of the total number of nodes (N), for the three strategies implemented in the Julia code are compared with Poisson solvers implemented in FEniCS and FreeFem++ in the table below. The FEniCS and FreeFem++ codes can be found in the references provided earlier. The values given below are averages over a few runs and would be different depending on the machines on which the codes are run.
Finite Element Programming Fortran
| N | Julia | FEniCS | FreeFem++ | ||
| Method 1 | Method 2 | Method 3 | |||
| 121 | 0.78 | 0.64 | 0.99 | 0.67 | 0.01 |
| 2601 | 1.77 | 0.74 | 1.07 | 0.76 | 0.05 |
| 10201 | 44.98 | 1.43 | 1.37 | 1.00 | 0.23 |
| 40401 | - | 10.68 | 2.63 | 2.09 | 1.05 |
| 123201 | - | 87.86 | 6.29 | 5.88 | 4.03 |
| 251001 | - | - | 12.28 | 12.16 | 9.09 |
A few observations regarding the three strategies used in the Julia code are due here. The performance results highlight the reason why it is almost always a bad idea to use a full matrix representation of the stiffness matrix (method 1). Initializing the sparse stiffness matrix as in method 2 works fine for small N, but the cost of inserting new elements into the stiffness matrix is significant as the number of nodes increases. The most efficient strategy for large N is method 3 which initializes the sparse matrix with a (guessed) number of non-zero elements. The performance of method 3 in comparison with that of the FEniCS and FreeFem++ codes for much larger values of N is shown below:
It can be seen that the performance of the Julia code is as good as FEniCS' and close to that of FreeFem++ for N ranging from 10^2 to 10^6. This is quite impressive considering the ease with which the finite element solver can be implemented in Julia.
Fortran Programmer Jobs
Final thoughts
The code presented here is quite elementary in comparsion to what is actually used in research. But what is really interesting about Julia is the relative ease with which various strategies can be implemented and tested without leading to code swell, while at the same time resulting in high performance code. As a preliminary assessment based on the results given here, Julia appears to be a very good choice for developing research oriented finite element software that is both fast and easy to develop. Julia does not support object-orientation, but its type system, use of multiple dispatch etc. provide a very clean and easier alternative that suits all practical needs for finite element computations. Its native support of dense and sparse matrices along with fast linear algebra solvers as part of the standard library are very attractive for finite element programming. The primary disadvantage of Julia is the absence of a large ecosystem of external libraries that other languages like Python or C++ have. This is likely to be a short term phenomenon since the language is quite new.
Finite Element Fortran Programmers
Trivia: the surface plot at the beginning of the article is the solution of the Poisson equation over the unit square with zero Dirichlet boundary condition on all its edges and an external load f(x,y) = 2sin(2pi*x)sin(2pi*y). Gnuplot was used to produce all the graphs in this article.