- The
*traditional approach*is to expect students to write their own f.e. programs from scratch, using previously-acquired programming experience. Nowadays this approach can be supplemented through use of a textbook which includes the source code of sample programs. The advantages of this approach are:- To get a program to work, the student must understand the theory behind the f.e.m.
- Students will get an appreciation of the limitations of the numerical output produced
- Students can modify and develop the source code, e.g. adding new types of element
- The lecturer can choose the programming language (though reliance on a textbook restricts this. The excellent text by Smith and Griffiths, "Programming the Finite Element Method" uses Fortran90, for example)
- Programs can be specialised for particular applications.

There are strong disadvantages with this approach, however:

- Output consists of a stream of numbers, difficult to interpret and impossible to visualize
- Data input is tedious and error-prone
- In practice, only input data files for very simple meshes can be used
- Programming and debugging a 2D finite element program is a time-consuming and difficult process, and it is easy for the student to become discouraged and demotivated.

- The
*commercial*approach involves taking a commercial finite element package such as Lusas, and teaching the students to use it to perform f.e. analyses. The advantages of this approach are:- Powerful graphics in pre- and post-processing are available
- It is easy for the student to get started
- It is easy to get meaningful results
- Real-life problems can be analysed
- Knowledge of such a package will be an advantage in later career.

The disadvantages of this approach are:

- The package behaves as a
*black box*; students cannot see the operations involved - Students gain no experience of what a f.e. program actually looks like
- Input is inflexible, e.g. "midside nodes" have to be midside
- Results are automatically processed, e.g. stresses are smoothed
- The source code is unavailable
- It is difficult or impossible to modify, e.g. by adding a new element type.

- A graphics-based preprocessor PREFEL;
- A suite of finite element "main engine" programs;
- A graphics-based post-processor FELVUE.
- stiffness matrices for additional element types
- new applications
- new quadrature rules
- new equation-solution algorithms
- stress-smoothing algorithms, etc.
- The pre-processor
*prefel.exe*; - The post-processor
*felvue.exe*; - The following "main engines" for particular applications, both as source code (
*.for*) and compiled executable (*.exe*) files:*poiss.for, poiss.exe*for solving Poisson's equation over a 2D region using linear triangle elements;*elast.for, elast.exe*for plane strain elasticity analyses using 8-noded serendipity elements;*plast.for, plast.exe*for plane strain elasto-plasticity analyses;*vplast.for, vplast.exe*for plane strain elasto-viscoplasticity analyses.

Up until recently, there have been two approaches to introducing software into courses about the finite element method:

Most recently, a "best of both worlds" solution to this dilemma has been made possible through the MATLAB software package. Programs can be written from scratch in MATLAB, which then have access to the graphics capabilities of the package. Learning to program in MATLAB is a separate and non-trivial task, however. In addition, the licensing cost for the package is considerable. The FELIPE package is intended to be a self-standing, low-cost, easy-to-use alternative, offering a "best of both worlds" solution with maximum flexibility.

The FELIPE package consists of three independent sections:

The pre-processor and post-processor are provided as executable files, while the "main engines" (for
applications such as solving Poisson's equation on a domain, or plane strain elasticity) are provided
as documented Fortran77 source code.

The three sections communicate with one another via formatted ASCII data files. That is, the output
from the pre-processor is a data file - *test.dat*, say - which is read as input by the "main engine". That program produces
a new data-file - *test.out* - which echoes the input data, and appends the numerical results (e.g. nodal displacements)
from the f.e. analysis. The post-processor reads this file and displays the results graphically.

Both the pre- and post-processors can produce hard-copy output as formatted text (*test.prt*) and PostScript graphics
(*testa.ps*, etc.).

Because the "main engine" programs are provided in source code, students can modify them to program:

The "main engine" programs can even be translated into another more convenient programming language
without affecting the use of the pre- and post-processors!

There is also a comprehensive user manual, not only describing the pre- and post-processors but also explaining the theory of the finite element method applied to 2D Poisson and Laplace problems, and elasticity analyses, as embodied in the "main engines".

It must be emphasised that, although the "main engines" are restricted in the type of element they use, in order to maintain their simplicity, the pre- and post-processors are capable of creating and displaying meshes with a wide range of 2D element types, including beam elements and mapped infinite elements. They are in fact very powerful, and the package is an excellent starting point for research projects.

Note: click here for details of the new features in version 2!