FELIPE Home | Demonstration | Download | Licence | Manual

Educational Rationale

---

The educational rationale behind FELIPE is as follows:

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

• 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.

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.

Structure of the package

The FELIPE package consists of three independent sections:

• A graphics-based preprocessor PREFEL;
• A suite of finite element "main engine" programs;
• A graphics-based post-processor FELVUE.

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:

• stiffness matrices for additional element types
• new applications
• new quadrature rules
• new equation-solution algorithms
• stress-smoothing algorithms, etc.

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

Contents of the package

• 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.

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!

To see the FELIPE package in action, and to download a free version for evaluation, click here!

ACKNOWLEDGEMENTS: I am very grateful to Dr Mike Warby for providing some basic graphics code, and to Brunel University's Enterprise project and to Prof John Whiteman for their support and encouragement in developing FELIPE.

FELIPE Home | Demonstration | Download | Licence | Manual