FELIPE Online Manual
The following table provides links to webpages for various chapters of the
User Manual. The full manual can be accessed as a pdf file
here.
Introduction
FELIPE (Finite Element Learning Package) is a software package whose
primary objective is to help students understand the finite element method
in mathematics and engineering, and develop their own f.e. programs. Its advantage
over the f.e. textbooks which provide their example programs printed or on ftp
or cd-rom, is that it combines full, commented and documented source code
(in standard Fortran77) for the f.e. `main engines', with powerful interactive
graphics pre- and post-processors capable of generating complex, detailed meshes.
Because of this, it is also very suitable
for practising engineers and researchers as a low-cost alternative to the
many commercial ``black box'' packages on the market (which do not provide
source code).
The principal components of FELIPE are:
- PREFEL, a pre-processor, used to create the input data file
which defines the finite element mesh, boundary conditions, material
properties, loading, etc. The resulting data file is given a .dat filename
extension. The pre-processor is provided as the executable
file PREFEL.EXE;
- Three Basic-level Fortran77 `main engines' (for the 2D Poisson's equation,
plane elasticity, and beam/frame analyses), the theory for which is summarized
in this Manual. Each `main engine' reads an input file such as prob1.dat (created by the PREFEL pre-processor) and produces an output
file prob1.out (for use with the post-processor) and a results file prob1.prt in printable format;
- Six further Advanced-level Fortran77 `main engines' for analysing a range of
mathematics and engineering applications (e.g. viscoplasticity, thermoelasticity),
which illustrate the main practical aspects of
finite element programming. In particular, a wide range of 1D and 2D finite and
infinite element types are used, and coding is provided for all the most important
algorithms for equation solution (from Gaussian elimination to conjugate gradients
with Incomplete Choleski preconditioning). The individual `main engines' are
summarized below. There is also a file of input/output subroutines common to all
the `main engines'. Each `engine' is provided in source code .for and
executable .exe form;
- linking files ( .inf) for each of the `main engines' if they are to be
compiled, linked and run using the Salford FTN77 compiler;
- FELVUE, a post-processor which reads in a .out file
and displays the results graphically. Displays include contouring, stress crosses,
displacement vectors, deformed mesh, etc.
This processor is also provided in executable form, namely in the file FELVUE.EXE.
It is possible to produce PostScript files (with a .ps extension)
of the graphical displays, for later printing;
- SALFLIBC.DLL. The Salford Fortran library needed to allow
the programs to run on any PC;
- Sample .dat and .out files, for one or more example problems for
each `main engine', also documented in this Manual and shown on
the FELIPE website.
By this means, users of FELIPE have the interactive graphics
processing power of a commercial finite element package, combined with
fully-documented source code which they can modify and extend for their own
purposes. The package is completely self-standing; the only supporting
software needed is a Fortran compiler if the user wishes to modify the
source code and re-compile it. Since the pre- and post-processors
communicate with the main f.e. programs through formatted ASCII data files,
they can also be interfaced with other finite element programs, whether in
Fortran or another language.
The pre- and post-processors are compiled under FTN77 (as are the executable
versions of the `main engines'), which includes
a memory extender; thus, large meshes can thus be created,
and problems of real mathematical and engineering significance solved.
(The processors are dimensioned to handle a maximum of 900 elements,
and 3,000 nodes.)
They make extensive use of the graphics and mouse routines available
with the FTN77 compiler, and can also produce PostScript graphics files for
subsequent processing by, for example, GhostScript software (available
from www.hensa.ac.uk by ftp) and printing on LaserJet or DeskJet printers.
The `main engines' can also be compiled
and run using FTN77 (which is available for personal use free from the Salford
software website), but if this is not available any other Fortran
compiler can be used, as they are written in standard Fortran77.
The nine `main engines'
The three Basic-level `main engines', and their principal features, are now listed:
- POISS.FOR
Application: solves Poisson's equation -a_x u_{xx} - a_y u_{yy} = f(x,y)
on an arbitrary 2D domain.
Material properties: diffusion coefficients a_x, a_y
Primary nodal unknown: potentials U
Secondary unknowns: flow rates U_x, U_y
Elements used: 3-noded linear triangles.
Boundary conditions: reflecting, radiating and Dirichlet boundaries
File size: 25.8KB
Analysis type: linear
Matrix storage: symmetric band
Solution algorithm: Choleski (L.L^T) decomposition
- ELAST.FOR
Application: solves plane strain, plane stress or axisymmetric linear elasticity problems
Material properties: Young's modulus E, Poisson's ratio \nu, thickness t,
tensile strength \sigma_{\mbox{ten}}
Primary nodal unknown: displacements u,v
Secondary unknowns: stresses \sigma_x, \sigma_y, \tau_{xy}
Elements used: 8-noded `serendipity' quadrilaterals
Boundary conditions: fixities in x or y planes
Loading: point loads, surface tractions
File size: 34.8KB
Analysis type: linear
Matrix storage: symmetric band
Solution algorithm: Choleski (L.L^T) decomposition
- FRAME.FOR
Application: analyses plane frames comprising elastic beams.
Material properties: Young's modulus E, Moment of Inertia I,
cross-sectional area A
Primary nodal unknown: displacements x,y and rotations \theta
Elements used: 2-noded cubic beam elements.
Boundary conditions: displacement and rotation fixities
Loading: point loads, surface tractions
File size: 24.4KB
Analysis type: linear
Matrix storage: element-by-element matrices on scratch file
Solution algorithm: preconditioned conjugate gradients, with diagonal preconditioning
The six Advanced-level `main engines' are:
- ELADV.FOR
Application: Large-scale 2D elasticity analyses
Material properties: Young's modulus E, Poisson's ratio \nu, thickness t,
tensile strength \sigma_{\mbox{ten}}
Primary nodal unknown: displacements u,v
Secondary unknowns: stresses \sigma_x, \sigma_y, \tau_{xy}
Elements used: 3- and 6-noded triangles, 4- and 8-noded quadrilaterals, mapped infinite
elements, 2- and 3- noded (cubic and quartic) beam elements
Boundary conditions: fixities in x or y planes
Loading: point loads, specified displacements, surface tractions, body forces,
excavation loading
File size: 91.9KB
Analysis type: linear
Solution algorithm: symmetric frontal algorithm
- PLAST.FOR
Application: plane strain associated-flow Mohr-Coulomb elasto-plasticity analyses
Material properties: Young's modulus E, Poisson's ratio \nu, triaxial stress
factor k, strength \sigma_c
Primary nodal unknown: displacements u,v
Secondary unknowns: stresses \sigma_x, \sigma_y, \tau_{xy}
Elements used: 8-noded `serendipity' quadrilaterals
Boundary conditions: fixities in x or y planes
Loading: point loads, surface tractions
File size: 50.3KB
Analysis type: nonlinear, iterative, incremental
Matrix storage: symmetric band
Solution algorithm: Choleski (L.L^T) decomposition
- VPLAS.FOR
Application: plane strain Mohr-Coulomb elasto-viscoplasticity analyses, with
non-associated flow
Material properties: Young's modulus E, Poisson's ratio \nu, triaxial stress
factor k, strength \sigma_c, fluidity \gamma, dilation factor l
Primary nodal unknown: displacements u,v
Secondary unknowns: stresses \sigma_x, \sigma_y, \tau_{xy}
Elements used: 8-noded `serendipity' quadrilaterals
Boundary conditions: fixities in x or y planes
Loading: point loads, surface tractions
File size: 75.5KB
Analysis type: nonlinear, incremental, time-dependent
Solution algorithm: Frontal algorithm, for non-symmetric matrices
- PLADV.FOR
Application: as PLAST, but with a range of solution algorithms
Material properties: Young's modulus E, Poisson's ratio \nu, triaxial stress
factor k, strength \sigma_c
Primary nodal unknown: displacements u,v
Secondary unknowns: stresses \sigma_x, \sigma_y, \tau_{xy}
Elements used: 8-noded `serendipity' quadrilaterals
Boundary conditions: fixities in x or y planes
Loading: point loads, surface tractions
File size: 67.7KB
Analysis type: nonlinear, iterative, incremental
Matrix storage: symmetric skyline, element-by-element
Solution algorithms: Choleski (L.L^T) and L.D.L^T decomposition,
conjugate gradients with diagonal or Incomplete Choleski preconditioning
- THERM.FOR
Application: plane stress/strain thermoelasticity
Material properties: Young's modulus E, Poisson's ratio \nu, thickness t,
conductivity coefficient k, coefficient of thermal expansion \alpha
Primary nodal unknown: displacements u,v, temperatures T
Secondary unknowns: stresses \sigma_x, \sigma_y, \tau_{xy}
Elements used: 4-noded (linear) and 8-noded (serendipity) quadrilaterals with
(u,v,T) degrees of freedom at all nodes
Boundary conditions: fixities in x or y planes, reflecting and Dirichlet
temperature boundaries
Loading: point loads, surface tractions
File size: 44.2KB
Analysis type: linear, coupled
Matrix storage: nonsymmetric band
Solution algorithm: Gauss elimination for non-symmetric matrices
- CONSL.FOR
Application: plane strain soil consolidation (poroelasticity)
Material properties: Young's modulus E, Poisson's ratio \nu,
effective permeabilities \frac{k_x}{\gamma_w}, \frac{k_y}{\gamma_w},
effective porosity \frac{\eta}{K_f}
Primary nodal unknown: displacements u,v, pore-pressures p
Secondary unknowns: effective stresses \sigma_x, \sigma_y, \tau_{xy}
Elements used: 8-noded `serendipity' quadrilaterals with pore-pressure d.o.f.s at
corner nodes only
Boundary conditions: fixities in x or y planes, impermeable or
permeable boundaries
Loading: point loads, surface tractions
File size: 53.4KB
Analysis type: linear, coupled, time-dependent
Matrix storage: symmetric band
Solution algorithm: L.D.L^T decomposition
Installation
To install the package from the floppy disk, run the self-extracting zip
file FELIPE.EXE which is on the disk. You can do this by locating
the file on your disk drive (normally the A: drive) using My Computer
or Windows Explorer, and double-clicking on it. Alternatively,
type a:\felipe.exe into the command line copy using the Run...
utility
from the Start menu. You will be prompted to nominate a directory into which the
FELIPE files should be unzipped; the default is C:\FELIPE.
If you have already downloaded the evaluation version of FELIPE from the
website into the C:\FELIPE directory, you can still use the
same
directory; the demonstration versions of the files will be overwritten by the
full versions, and new files added.
The installation process does not alter any Windows settings on your PC.
To uninstall FELIPE, simply delete the directory containing the
files.
\vspace{1cm}
In this manual, Chapter 2 describes how to use the PREFEL pre-processor.
The next three chapters describe the three Basic-level `main engines':
Chapter 3 covers the theory and programming of the Poisson solver,
while Chapter 4 describes the solver for elasticity problems, and Chapter 5 deals with
beam theory.
Chapter 6 describes the use of the FELVUE post-processor. Then
Chapter 7 summarizes the operation and use of the other six, Advanced-level
`main engines'. Chapter 8 covers the various algorithms used for equation solution.
Chapter 9 documents the sample datafiles provided in the FELIPE package.
The final Chapter suggests ways in which the `main engines' may be
modified, and new `main engines' written, and gives recommendations for textbooks for
further reading about the finite element method.
Acknowledgements:
I am very grateful to Prof. J.R. Whiteman and
Dr. M.K. Warby for permission to use in FELIPE some of the
basic graphics and PostScript subroutines developed by Dr. Warby, and to
Dr. T.-Y. Chao for working with me on the programming and documentation of
the elasticity module. I also acknowledge the support of the Enterprise in
Higher Education Unit at Brunel University, in enabling me to work on this
project. The Fortran coding of the elasticity 'main engines' is based on the
FINEPACK program developed at the Dept. of Civil Engineering, University
College Swansea, and I am grateful to Dr. D.J. Naylor for permission to
use this.
Back to top