0% found this document useful (0 votes)
599 viewsProgramming The Finite Element Method-Wiley (1988)
Programming the finite element method
Uploaded by
hanlamphamCopyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF or read online on Scribd
0% found this document useful (0 votes)
599 viewsProgramming The Finite Element Method-Wiley (1988)
Programming the finite element method
Uploaded by
hanlamphamCopyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF or read online on Scribd
/ 478
PROGRAMMING THE
FINITE ELEMENT METHOD
2ND EDITION PROGRAMMING THE
FINITE ELEMENT METHOD
SECOND EDITION
LM. Smith
and
D. V. Griffiths
University of Manchester, UK
JOHN WILEY & SONS
Chichester . New York . Brisbane . Toronto . Singapore Copyright © 1982, 1988 by John Wiley & Sons Ltd.
All rights reserved.
No part of this book may be reproduced by any means,
or transmitted, or translated into a machine language
without the written permission of the publisher.
Library of Congress Cataloging-in-Publication Data:
Smith, I. M.
Programming the finite element method.
Includes bibliographies and indexes.
1. Finite element method— Computer programs.
2. Engineering Data processing. 3. Soil mechanics—Data processing.
1. Griffiths, DV, M1. Title
TA347.F5864 1988 620.001'S15353 87-8123
ISBN 0 471 91552 1 (cloth) :
ISBN 0 471 91553 X (paper)
British Library Cataloguing in Publication Data:
Smith, 1. M. (lan Moffat)
Programming the finite element method.
—2nd ed.
1, Finite clement method—Data processing
I, Title I. Griffiths, D. V.
515.3'53 TAMMTFS
ISBN 0 471 91552 1 (cloth)
ISBN 0 471 91553 X (paper),
‘Typeset at Thomson Press (India) Limited, New Delhi.
Printed and bound in Great Britain by Anchor Brendon Ltd, Tiptree, Essex Contents
Preface to Second Edition.
Chapter 1 Preliminaries: Computer Strategies
1,0 Introduction SH
1.1 Computer Hardware. 1...
1.2 Store Management .
1.3 Vector and Array Processors 1...
14 Software. . oe
1.5 Portability of “Subroutines? or 1 ‘Procedures’.
1.6 Libraries. wee
1.7. Structured Programming .
18 Other Languages . Se
19 Conclusions. © 2 2. ee
1.10 References .
Chapter 2 Spatial Discretisation »
2.0 Introduction _-
2.1 Rod Element .
2.2 Rod Inertia Matrix .
2.3. The Eigenvalue Equation .
2.4 Beam Element.
2.5 Beam Inertia Matrix.
2.6 Beam with an Axial Force
2.7 Beam on Elastic Foundation .
2.8 General Remarks on the Discretisation Process .
2.9 Alternative Derivation of Element Stiffness .
2.10 Two-dimensional Elements; Plane Stress and Strain
2.11 Energy Approach. .
2.12 Plane Element Inertia Matrix
2.13 Axisymmetric Stress and Strain .
2.14 Three-dimensional Stress and Strain .
2.15 Plate Bending Element .
2.16 Summary of Element Equations for Solids |
2.17 Flow of Fluids: Navier-Stokes Equations .
2.18 Simplified Flow Equations Lo
2.19 Simplified Fluid Flow: Steady State
Coneavneee F 2.20 Simplified Fluid Flow: Transient State
2.21 Simplified Fluid Flow with Advection :
2.22 Further Coupled Equations Biot Consolidation .
2.23 Conclusions.
2.24 References .
Chapter 3. Programming Finite Element Computations
Introduction
3.0
31
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
Local Coordinates for Quadrilateral Elements.
Numerical Integration for Quadrilaterals toe
Local Coordinates for Triangular Elements... . 1. +
Numerical Integration for Triangles . . 2... 0 eee
Element Assembly _. :
Incorporation of Boundary Conditions .
Programming Using Building Blocks . woe
Black Box Routines. . . . see ee ee
Special Purpose Routine. == =. st tts
3.10 Solution of Equilibrium Equations. .
3.11 Evaluation of Eigenvalues and Eigenvectors :
3.12 Solution of First Order Time-dependent Problems .
3.13 Solution of Coupled Navier-Stokes Problems.
3.14 Solution of Coupled Transient Problems :
3.15 Solution of Second Order Time-dependent Problems :
3.16 Conclusions see
3.17 References .
Chapter 4 Static Equilibrium of Structures
4.0 Introduction
Program
Program
Program
Program
Program
Program
Program
Program
Program
Program
40:
41:
4.2:
43:
44:
45:
46:
47:
48
Equilibrium of Uniform Beams . :
Equilibrium of Stepped Beams Incorporating |
Prescribed Displacement Boundary
Conditions . .
Beam on Elastic Foundation with Numerically
Integrated Stiffness and Mass Matrices .
Equilibrium of Two-dimensional Rigid: ined
Frames .
Equilibrium of Three- dimensional Rigi
jointed Frames.
Equilibrium of Two- imensional Pi
Trusses .
Equilibrium of ee
Trusses . .
Plastic Analysis of Two -dimensional Frames '
: Stability Analysis of Two-dimensional Frames
Equilibrium of Rectangular Plates in Bending .
4.
41
42
45
121
124
127
134
138 41 Conclusions. ©... 1 ee ee
4.2 References .
Chapter 5 Static Equilibrium of Linear Elastic Solids
5.0 Introduction
Program
Program
Program
Program
Program
Program
Program
Program
Program
Program
Program
5.1. References .
5.0 : Plane Stress Analysis Using Three-node
Triangles .
5.1 : Plane Stress Analysis Using Six-node
Triangles .
5.2 : Plane Strain Analysis Using Fifteen-node
Triangles...
53 : Plane Strain Analysis Using Four-node
Quadrilaterals .
54: Plane Strain Analysis Using Eight-node
Quadrilaterals :
5.5 : Plane Strain Analysis Using Nine-node
Quadrilaterals .
$6 : Axisymmetric Strain Analysis Using Four-
node Quadrilaterals .
5.7 : Non-axisymmetric Strain of Axisymmetic
Solids Using Eight-node Quadrilaterals .
5.8 : Three-dimensional Analysis Using Four-noded
Tetrahedra .
59 : Three-dimensional Analysis Using Eight-
noded Brick Elements .
5.10: Three-dimensional Analysis Using Twenty
noded Brick Elements . .
Chapter 6 Material Non-linearity
6.0 Introduction wee ee we ee
6.1 Stress—Strain Behaviour ry
6.2 Stress Invariants .
63 Failure Criteria
64 Generation of Body-loads..
6.5 Visco-plasticity .
6.6 Initial Stress :
6.7 Corners on the Failure and Potential ‘Surfaces:
Program
Program
60 : Plane Strain Bearing Capacity Analysis
Visco-plastie Method Using the Von Mises
Criterion . .
6.1 : Plane Strain Slope Stability Analysis—Visco-
plastic Method Using the Mohr-Coulomb
Criterion . : :
» 200
vii
141
142
143
143
150
154
157
161
165
169
172
178
182
186
191
192
192
194
195
197
199
201
202
203
« 211 Program 6.2 : Plane Strain Passive Earth Pressure
Analysis—Initial Stress Method Using the
Mohr-Coulomb Criterion. . » 218
Program 6,3 : Axisymmetric ‘Undrained’ Analysis —Visco-
plastic Method Using the Mohr-Coulomb
Criterion . . 204
Program 6.4 : Three-dimensional Elasto-plastic Analysis—
Visco-plastic Method Using the Mohr-
Coulomb Criterion... : oe 232
68 Reems. a
Chapter 7 Steady State Flow . . . 239
Program 7.0 : Solution of Laplace's Equation Over a Plane
Area Using Four-node Quadrilaterals. . . . 239
Program 7.1 : Analysis of Planar Free Surface Flow Using
Four-node Quadrilaterals. . 245
TW Reference 2... 289
Chapter 8 Transient Problems: First Order (Uncoupled) . . . . . 250
8.0 Introduction... ... 2... soe ee ee 250
Program 80 : Solution of the Conduction Equation over a
Rectangular Area. . . . + + 250
Program 8.1 : Solution of the Conduction Equation ¢ over a
Cylinder. 2. . 256
Program 82 : Solution of the Conduction Equation over @
Rectangular Area Using an Explicit Method . 259
Program 8,3 : Solution of the Conduction Equation over a
Rectangle using an EBE Product Algorithm . 262
8.1 Comparison of Programs 80,82 and83 ...... . . 266
Program 8.4 : Diffusion-Convection Problem over a
Rectangle—Transformed Analysis. . . . . 267
Program 85 : Diffusion-Convection Problem over a
Rectangle—Untransformed Analysis. . . . 271
8.2 References. . 2... 28
Chapter9 ‘Coupled’ Problems . ............. 277
9.0 Introduction . . . . 27
Program 9.0 : Solution of the ‘Steady- state Navier-Stokes
Equations over a Rectangle . . . . . . . 278
9.1 Analysis of Soil Consolidation using Biot’s Theory. . . + 286
Program 9.1 : Biot Consolidation of a Rectangle in Plane
Strain (Four-node Elements)... 286
Program 9.2 : Biot Consolidation of a Rectangle in Plane.
Strain (Eight-node/Four-node Elements}. . . 294
9.2 References. 2 2 6 ee ee ee ee ee 299 Chapter 10 Eigenvalue
10.0 Introduction
Program 10.0 :
Program 10.1 :
Program 10.2 :
Program 10.3 :
Program 10.4
10.1 References
Problems .
Eigenvalues and Eigenvectors of a Two-
dimensional Frame of Beam-Column
Elements—Consistent Mass...
Eigenvalues of a Rectangular Solid in ‘Plane
Strain—Four-node Quadrilaterals with
Lumped Mass .
Eigenvalues and Eigenvectors of a
Rectangular Solid in Plane Strain—Eight-
node Quadrilaterals with Lumped Mass .
Eigenvalues and Eigenvectors of a
Rectangular Solid in Plane Stress—Eight-
node Quadrilaterals with Consistent Mass .
: Eigenvalues and Eigenvectors of a
Rectangular Solid in Plane Strain—Four-
node Quadrilaterals with Consistent Mass .
Chapter 11 Forced Vibrations.
11.0 Introduction
Program 11.0 :
Program 1.1 :
Program 11.2 :
Program 11.3 :
Program 11.4 :
Program 11.5
11.1 References .
Forced Vibration of a Rectangular Solid in
Plane Strain Using Eight-node Quadrilaterals,
Lumped Mass, Modal Superposition Method .
Forced Vibration of a Rectangular Solid in
Plane Strain Using Eight-node
Quadrilaterals—Lumped or Consistent Mass,
Implicit Integration by Theta Method . . .
Forced Vibration of a Rectangular Elastic
Solid in Plane Strain Using Eight-node
Quadrilaterals—Lumped or Consistent Mass,
Implicit Integration by Wilson Theta Method .
Forced Vibration of a Rectangular Solid in
Plane Strain Using Eight-node
Quadrilaterals—Lumped Mass, Complex
Response Method. . .
Forced Vibration of a Rectangular Blasto-
plastic Solid in Plane Strain Using Eight-node
Quadrilaterals—Lumped Mass, Explicit
Integration .
: Forced Vibration ofa an Elastic Solid in Plane
Strain Using Four-node Quadrilaterals—
Lumped or Consistent Mass, Mixed
Explicit/Implicit Integration .
<
300
315
319
320
320
320
325
330
333
337
345
350 x
Chapter 12 Analysis of Piles and Pile Groups .
12.0 Introduction Se ee
Program 12.0 : t-z Analysis of Axially Loaded Piles Using
Two-noded Line Elements
Program 12.1%: p-y Analysis of Laterally Loaded Piles Using
Two-noded Beam Elements .
Program 122 : Analysis of Vertically Loaded Pile Groups
Using Two-noded Line Elements—t-z
-Springs for the Soil and Mindlin’s Equation
for the Interactions
Program 123 : Pile Drivability by Wave Equation—Two- |
node Line Elements—Implicit Integration in
Time . Se
121 References .
Appendix 1 Consistent Nodal Loads .
Appendix 2 Plastic Stress-Strain Matrioes and Plastic Potential
Derivatives
Appendix 3. Geometry Subroutines
Appendix 4 Alphabetic List of Building Block Subroutines
Appendix 5 Listings of Special Purpose Routines
Author Index
Subject Index
. 351
. 351
359
365
372
378
. 379
382
386
401
415
464
466 Preface to Second Edition
Following the success of the First Edition, considerable modifications and
improvements have been made. In retrospect it was probably a mistake to
combine in one book a programming philosophy and a survey of other workers’
applications to geomechanics, so the latter has been dropped. However, the
geomechanics flavour remains, particularly in Chapters 6, 7, 8, 9 and 12.
Although the programming philosophy remains intact, Chapter 1 reflects the
rapid developments in the hardware and (to a lesser extent) software fields.
Emphasis is given to what are generally known today as ‘micro’ computers while
the programming language has been updated from FORTRAN IV (FORTRAN
66) to FORTRAN V (FORTRAN 77).
Chapter 2 has been extended to give a fuller treatment of structural applic-
ations and the equations of fluid flow including the Navier-Stokes equations.
Inthe original Chapter 3, choice of storage strategy was rather limited, so more
versatility has been introduced, in the form of a ‘profile’ (‘skyline’) option.
Chapter 4 has been extended to embrace elastic, elasto-plastic and elastic
stability analyses of ali commonly encountered skeletal structures, while in
Chapter 5 a much greater range of plane and solid finite elements is provided.
In Chapter 6 more realistic examples of analyses of geotechnical problems —
involving walls, foundations and slopes—have been incorporated.
The original Chapter 7 dealt both with steady state and with transient flow
problems. In the present edition, transient problems are removed to Chapter 8
while the steady state confined and unconfined flow problems analysed in
Chapter 7 are more typical of those encountered in geotechnical engineering
Practice.
Chapter 8 also includes relatively recent developments of element-by-element
algorithms for first order transient problems.
The original Chapter 8, now Chapter 9, has been extended to deal with two
typical ‘coupled’ problems—those arising from the (steady state) Navier-Stokes
€quations and those arising from Biot’s equations for transient analysis of porous
elastic solids.
The original Chapter 9 has been subdivided, so that eigenvalue analysis (new
Chapter 10) is divorced from the solution of second order transient problems
(new Chapter 11). In the new Chapter 10 a solver based on the Lanczos method
for large eigenvalue problems is demonstrated. In the new Chapter |1 second
xi xii
order differential equations are integrated by a greater range of methods, for
example mixed integration operators.
The final chapter (new Chapter 12) has been expanded to embrace the analysis
of pile groups as well as of single piles.
COMPUTER PROGRAMS
All software (libraries-and programs) described in this book are available from:
Numerical Algorithms Group Ltd,
NAG Central Office,
Mayfield House,
256 Banbury Road,
Oxford OX2 7DE,
UK
Specify the medium (tape, disc) and format when applying. A small handling
charge is made. CHAPTER 1
Preliminaries: Computer Strategies
1.0 INTRODUCTION
Many textbooks exist which describe the principles of the finite element method
of analysis and the wide scope of its applications to the solution of practical
engineering problems. Usually, little attention is devoted to the construction of
the computer programs by which the numerical results are actually produced. It
is presumed that readers have access to pre-written programs (perhaps to rather
complicated ‘packages’) or can write their own. However, the gulf between
understanding in principle what to do, and actually doing it, can still be large for
those without years of experience in this field.
The present book attempts to bridge this gulf. Its intention is to help readers
assemble their own computer programs to solve particular engineering problems
by using a ‘building block’ strategy specifically designed for computations via the
finite element technique. At the heart of what will be described is not a ‘program’
‘ora set of programs but rather a collection (library) of procedures or subroutines
which perform certain functions analogous to the standard functions (SIN,
SQRT, ABS, etc.) provided in permanent library form in all useful scientific
computer languages. Because of the matrix structure of finite element formula-
tions, most of the building block routines are concerned with manipulation of
matrices.
The aim of the present book is to teach the reader to write intelligible programs
and to use them. Super-efficiency has not been paramount in program
construction. However, all building block routines (numbering over 100) and all
test programs (numbering over 50) have been verified on a wide range of
computers. Their efficiency is also believed to be reasonable, given a tolerably
well written compiler. In order to justify the choice of high level language used
(FORTRAN 77) and the way in whichit is asserted programs should be written, it
is necessary briefly to review the development of computer ‘architecture’ and its
Telationship to program writing.
1.1. COMPUTER HARDWARE
In principle, any computing machine capable of compiling and running
FORTRAN programs can execute the finite clement analyses described in this Table 1.1
Approximate
Wordlength Core storage cost 1985
Designation Example (bits) (words) Virtual memory? (UK)
Micro 1BM PC 16 128K, No 2K
Super micro ICL PERQ 32 64K Yes 20K
Mini VAX 11/780 32 64K Yes 100K
Mainframe CDC 7600 4 100K, No 1000K,
Super mainframe CDC 10GF 4 46,000K, Yes 10,000K
book. In practice, hardware will range from ‘micro’ computers for small analyses
and teaching purposes to ‘super’ computers for very large (especially non-linear)
analyses. It is a powerful (eature of the programming strategy proposed that the
same software will run on all machine ranges. The special features of vector and
array processors are described in a separate section (1.3).
Table 1.1 shows that, in very general terms, five categories of useful hardware
can be distinguished at the time of writing, graded using an ‘order of magnitude’
rule with respect to cost. While the trend in costs, certainly for ‘minis’ and below,
is downwards some such cost-based tabulation will always apply.
At the lower end of the cost range, it is of course possible to code finite element
analysis algorithms for very cheap machines, by employing machine code or an
interpreter such as BASIC. The complete lack of portability of the former and the
lack of a true subroutine structure in the latter leads the authors to exclude such
hardware from consideration.
The user’s choice of hardware is a matter of accessibility and of cost. For
example, in very rough terms, a ‘mini’ computer (Table 1.1) has a processing
speed about 30 times slower than that of a ‘mainframe’. Thus a job taking two
minutes on the mainframe takes one hour on the mini. Which hardware is ‘better’
clearly depends on individual circumstances. The main advice that can be
tendered is against using hardware that is too weak for the task; that is the user is
advised not to operate at the extremes of the hardware’s capability.
1.2 STORE MANAGEMENT
In the programs in this book it will be assumed that sufficient main random
access core store is available for the storage of data and the execution of
programs. However, the arrays processed in very large finite element calculations
can be of size, say, 10,000 by 200. Thus a computer would have to have a main
store of 2 x 10° words to hold this information, and while some such computers
exist, they are still comparatively rare. A much more typical core size is still of the
order of 1 x 105 words.
Two distinct strategies are used by computer manufacturers to get round the
problem of limited random access core. In the first (simplest and earliest) 3
technique different ‘levels’ of store are provided with transfer of data to core from
various secondary storage devices such as discs and tape being organized by
the programmer. The CDC 7600 is a computer that used this strategy.
Programs are executed in a small fast store while data can be stored in a medium-
fast ‘large core memory’, Further back-up storage is available on a big disc but of
course when the programmer decides to transfer information to and from disc the
central processor would be idle. A job calling for disc transfers is therefore
automatically swapped out of fast memory, and is replaced by the next job
waiting in the queue.
The second strategy removes store management from the user’s control and
vests it in the system hardware and software. The programmer sees only a single
level of store of very large capacity and his information is moved from backing
store to core and out again by the supervisor or executive program which
schedules the flow of work through the machine. This concept, namely of a very
large ‘virtual’ core, was first introduced onthe ICL ATLAS in 1961. It can be seen
from Table 1.1 that this strategy of store management is now very common. The
ATLAS and most subsequent machines of this type also permit multi-
programming in that there can be several partly completed programs in the core
at any one time. The aim in any such system is to keep the hardware (CPU,
peripherals, etc.) fully utilised.
Clearly it is necessary for the system to be able to translate the virtual address
of variables into a real address in core. This translation usually involves a
complicated bit-pattern matching called ‘paging’. The virtual store is split into
segments or pages of fixed or variable size referenced by page tables, and the
supervisor program tries to ‘learn’ from the way in which the user accesses
data in order to manage the store in a predictive way. However, store
management can never be totally removed from the user’s control. It must always
be assumed that the programmer is acting in a reasonably logical manner,
accessing array elements in sequence (by rows or columns as organised by the
compiler). If the user accesses a virtual store of 10° words in a random fashion the
paging requests will readily ensure that very little execution of the program can
take place.
13 VECTOR AND ARRAY PROCESSORS
In later chapters it will be shown that finite element computations consist largely
of handling matrices and vectors—multiplying them together, adding, transpos-
ing, inverting and so on, It has seemed appropriate to computer manufacturers,
therefore, to provide special hardware capable of doing vector or matrix
operations at high speed. This hardware can be in the form of central processing
vector registers such as on the Cray and CDC Cyber 205 or in peripheral form
such as the ICL 2900 DAP concept. Other array processors can also be
connected as peripherals, one such being the Floating Point Systems FPS264,
and this is a very likely future development.
The drawback associated with specialised hardware of this kind is that 4
specialised programs usually have to be written to exploit it. This detracts from
such important software considerations as program portability and machine
independence. However, at the very least, software can be written to pre-process
standard high level language code to see if it can be re-organised to make best use
of a particular machine’s vector capabilities.
Future trends in this direction are difficult to anticipate. It may be that,
ultimately, array processing will become so fast and cheap, even for very large
arrays, that much of the special purpose software which has been written to date,
for example to process arrays with various sparsity patterns, will become
redundant. However, such a trend would be entirely consistent with the
philosophy of the present book, and would merely necessitate a change of
emphasis. At present, though, only standard, completely portable high level
languages will be considered in the following sections on software.
1.4 SOFTWARE
Since all computers have different hardware (instruction formats, vector
capability, etc) and different store management strategies, programs that would
make the most effective use of these varying facilities would of course differ in
structure from machine to machine. However, for excellent reasons of program
portability and programmer training, engineering computations on all machines
are usually programmed in ‘high level’ languages which are intended to be
machine-independent. The high level language (FORTRAN, ALGOL, etc, is
translated into the machine order code by a program called a ‘compiler’.
It is convenient to group the major high level languages into those which are
FORTRAN-like (for example PASCAL) and those which are ALGOL-like (for
example ADA). The major difference between these groups is that the latter allow
dynamic management of storage at run-time whereas the former do not. This
difference has immediate implications for store management strategy because it is
clear that unless a computer permits genuine multi-programming and a one-level
store in which programs are dynamically expanding and contracting there is not
much point in having a language that allows these facilities. Thus, on CDC 7600
machines, FORTRAN was an obvious choice of language whereas on other
computers there is greater room for manoeuvre. Dynamic store management
seems to be a uniform trend for the future, so one would expect ALGOL-like
languages to become more and more attractive.
There are many texts describing and comparing computer languages, often
from the point of view of computer scientists, e.g. Barron (1977). What matters
in the context of the present book is not syntax, which is really remarkably
constant among the various languages, but program structure. The following
example illustrates the two crucial differences between ALGOL-like and
FORTRAN-like languages as far as the engineer-programmer is concerned.
Suppose we want to write a program to multiply two matrices together, a task
that occurs hundreds of times during execution of a typical finite element program. In ALGOL 60 the program might read as follows:
begin integer J, m,n;
statements which read or compute I, m, n;
begin array a[1:l,1:m], b[1:m,1:n], c[1:1,1:n];
integer i, j, k; real x;
statements which initialise a, b;
for i:= 1 step 1 until | do
step / until n do
1 step / until m do
+ afi, k}*b(k A:
cli, fs=x
statements which do something with ¢
end
end
while in FORTRAN 77 it might be written:
INTEGER I, J, K, L, M,N
REAL X
REAL A(20, 20), B(20, 20), C(20,20)
Statements which read or compute L, M, N
Statements which initialise A, B
DOII=14,L
DO1J=1,N
X=.0
DO2K=1,M
2 X=X+A(LK)*BK,J)
C.J) =X
1 CONTINUE
Statements which do something with C
END
Note that the declarations of the simple integers and the real in lines 1 and 2 of
this program are unnecessary.
Comparison of the two codes will easily show that the syntaxes of the two
languages are very similar, e.g, compare the ALGOL
for i:=1 step | until | do
with the corresponding FORTRAN
DO11=1,L
or the assignment statements
x=x-+ali,k]*b[k, jy 6
and
X=X+A(LK)*B(K, J).
Therefore, anyone familiar with one syntax can learn the other in a very short
time.
However, consider the program structures. The main difference is that in
ALGOL, the array dimensions /, m,n do not need to be known at compile time
whereasin FORTRAN they do. Indeed, our FORTRAN program is useless if we
want to multiply together arrays with dimension greater than 20, It is this lack of
‘dynamic’ storage which is FORTRAN’s major limitation. It can partially be
alleviated by various devices such as allocating all storage to a large vector and
keeping track of the starting addresses of the various arrays held in the vector, but
one can never get away without a dimensioning statement of some kind within a
FORTRAN program.
This has various bad effects, among which is a tendency for FORTRAN users
to declare their arrays to have the maximum size that will ever be encountered,
subject to the limitation of the core size of the machine, Since most large machines
allow multi-programming this can be inefficient.
1.5 PORTABILITY OF ‘SUBROUTINES’ OR ‘PROCEDURES’
The second major deficiency of FORTRAN becomes apparent when we wish to
construct a program to multiply together matrices of varying size within the same
program, This sort of activity occurs very frequently in finite element programs.
To avoid the repetition of sections of code within a program, most languages
allow these sections to be hived off into self-contained sub-programs which are
then ‘called’ by the main program. These are termed ‘procedures’ in ALGOL and
‘subroutines’ in FORTRAN and their use is central to efficient and readable
programming, For example, it would be very tedious to include the code required
to compute the sine of an angle every time it is required, so ALGOL and
FORTRAN provide a special, completely portable routine (actually a function)
called SIN. This is held in a permanent library and is accessible to any user
program, Why not do the same thing with matrix multiplication?
In ALGOL the technique is straightforward and encouraged by the structure
of the language. For example, an ALGOL 60 matrix multiplication procedure
might be as follows:
procedure matmult (a,b, ¢,1m,n):
value /, m,n; array a, b, c; integer [, m,n:
begin integer i, j, k; real x:
step 1 until | do
step J until n do
step 1 until m do
=x +alik]+d[k jf]; end
efi, :=x
end
Suppose we now wish to multiply the (I x m) array a by the (m x n) array b to
give the (I x n) array c as before, and then to multiply c by the (n x J) array d to
yield the (I x I) array e. The ALGOL 60 program would be as follows:
begin integer |, m,n;
procedure matmult (a,b, c,1,m,n);
statements which read or compute |, m, n;
begin array a[ 1:1, 1:m], b[I:m,1:n],
eis ten), d(ten, 1:0, eC: 10;
statements which initialise a, b;
‘matmult (a,b, c,l,m,n);
matmult (c,d, e,l,n,;
statements which do something with e
end
end
In the above, the procedure matmult is assumed to be available ina user library
in exactly the same way as LOG, COS, etc., are available in the permanent
library. The program structure can be seen to be simple and logical, reflecting
exactly what the user wants to do and requiring a minimum of information about
array dimensions to do it.
Let us now try to do the same thing in FORTRAN 77. Reasoning from our
previous program we write:
SUBROUTINE MATMUL (A,B,C,L,M,N)
REAL A(20,20), B(20, 20), C(20,20), X
INTEGER I, J, K, L, M, N,
DO!I=1,L
DO1J=1,N
X=0
DO2K=1,M
2 X=X+AGLK)*BKD
C(I, )=X
1 CONTINUE
RETURN
END
Now the dimensioning statement in line 2 of this subroutine is merely a device
for passing the addresses in memory of the arrays locally called A, B, C back and
forth between the subroutine and the main program. Since the FORTRAN
subroutine only needs to know a starting address and a column size, we could as
well have written
REAL A(20, #), B(20, #), C(20,#), X 8
More importantly, since in FORTRAN the local A, B,C are mapped onto the
arrays of the main program, it can be seen that our subroutine is useless, unless
arrays processed by it have a first dimension of 20. This is an impossible
restriction akin to saying we can only work out the sines of angles less than 20°
using SIN.
‘A way round this deficiency in FORTRAN is to make the subroutine
completely portable at the expense of including extra parameters in the call,
associated with each array. These parameters, which are constants, contain on
entry to the subroutine the column sizes of the particular arrays to be multiplied
at that time as declared in the main program. Thus our portable FORTRAN
subroutine becomes:
SUBROUTINE MATMUL (A, IA, B, IB, C, IC, L, M, N)
REAL A(IA,#), B(IB,*), C(IC, #), X
INTEGER IA, IB, IC, L, M,N, 1, K
DOIT=1,L
DO 1J=
X=.0
DO2K=1,M
2 X=X+A(,K)sB(K,J)
c(.J)=X
1 CONTINUE
RETURN
END
We could now construct our general matrix multiplication program as follows,
assuming MATMUL to be available in a user library:
INTEGER L, M, N, IA, IB, IC, ID, IE
REAL A(20, 5}, B(5, 15), C(20, 15), D(15, 20), E(20,20)
DATA IA/20/, 1B/5/, IC/20/, ID/15/, 1E/20/
Statements which read or compute L, M, N
Statements which initialise A, B
CALL MATMUL (A, IA, B, IB, C, IC, L, M,N) -
CALL MATMUL (C,IC,D, ID, E, IE, L,N, L) ¥
Statements which do something with E
END
We have now succeeded in making FORTRAN look reasonably like ALGOL.
The differences lie only in the need to dimension arrays in the main program and
to pass the extra column size parameters in the subroutine calls. In fact we will
only be concerned in our finite element programs with adjusting the sizes ofa few
large arrays at run-time, and so the inconvenience can really be restricted to
changing a line at the beginning of the main program.
This is most easily done by the PARAMETER statement in FORTRAN 77.
Using this facility the second and third lines of the preceding program can be
replaced by: PARAMETER (IA = 20, JA =5, IB=5, JB =15, IC = 20, JC=15,
*ID = 15, JD= 20, IE = 20, JE = 20)
REAL A(IA, JA), B(IB, JB), C(IC, JC), D(ID, JD), E(IE, JE)
so that only the PARAMETER line need ever be changed. This is the method
used in this book.
1.6 LIBRARIES
The concept that will be described in subsequent chapters is one of having a user
library containing completely portable subroutines such as MATMUL, which
was described in the previous section, The idea is not new, of course, and many
such libraries already exist, notably the NAG mathematical subroutine library
(Ford and Sayers, 1976). The present library is completely compatible with the
NAG mathematical subroutine library and uses the same parameter passing
convention, but it differs from the NAG mathematical subroutine library in two
ways. First, it contains only routines used in finite element analysis, and second it
uses mnemonic names such as MATMUL to describe its operations (an
equivalent routine in the NAG mathematical subroutine library is called
FOICKF). This greatly enhances program readability.
The library routines which are the ‘building blocks’ from which the finite
element programs are constructed are described in Chapter 3. Some of them may
be considered as ‘black box’ routines, that is the user need not understand or see
them (how many users know how SIN(X) is computed”). Some of these routines
are not even listed in the book but the source code is available on tape or floppy
disc in all the usual formats. Other routines are, however, specifically related to
the descriptions of finite clement operations, and these routines are listed for
reference purposes in Appendix 5, and of course on tape also.
The test programs which are built up from the library routines are described in
Chapters 4 to 12 and also listed there, Interested readers can substitute their own
routines at any point, because of the modular nature of the whole system. Such
routines could be in machine code for greater efficiency or could be linked to the
use of an array processor. For example, the Floating Point Systems Array
Processor can look to the user like a set of library subroutine calls which could be
substituted for the FORTRAN subroutines if required.
The programs described in this book are all assumed to be processed ‘in core’.
Naturally, one could construct out of core versions of the library routines, which
Process large arrays for usc on non-virtual machines.
1.7. STRUCTURED PROGRAMMING
The finite element programs which will be described are strongly ‘structured’ in
the sense of Dijkstra (1976). The main feature exhibited by our programs will be
Seen to be a nested structure and we will use representations called ‘structure
charts’ (Lindsey, 1977) rather than flow charts to describe their actions. 10
The main features of these charts are:
( The Block
DOTHIS
DOTHAT
DOTHE OTHER
This will be used for the outermost level of each structure chart, Within a block,
the indicated actions are to be performed sequentially.
(ii) The Choice
QUESTION?
Answer2 | Answer3
‘Answer 1
ACTION1 | ACTION2 | ACTIONS
This corresponds to the if.,.then...else if...then...end if kind of cohstruct.
(iii) The Loop
This comes in various forms, but we shall usually be concerned with the‘DO' loop
ACTION
TOBE
REPEATED
n TIMES
In particular, the structure chart notation encourages the use only of those
GOTO statements that are safe in a structured program.
Using the notation, our matrix multiplication program would be represented
as follows: iW
Initialise variables and
arraysaandb
nullsum
sum = sum +
row x column products
(axb)
Do something with c
The nested nature of a typical program can be seen quite clearly.
18 OTHER LANGUAGES
‘New programming languages appear from time to time, usually at the instigation
of computer scientists rather than engineers. For example, PASCAL is popular as
a teaching language and has a simple structure enabling compact compilers to be
written. In PASCAL 3 our matrix multiply algorithm becomes:
TYPE ARR = ARRAY [INTEGER, INTEGER] OF REAL;
PROCEDURE MATMUL (VAR A, B, C: DYNAMIC ARR; L, M, N:
INTEGER)
VAR I, J, K: INTEGER; X:REAL;
BEGIN
FOR TOLDO
FOR J:=1 TON DO
BEGIN X:= 0.0; 12
FOR K:=1 TO M DO
X:=X+A(,K]*B[K, J},
CUJE=X
END;
END;
VAR L, M, N: INTEGER;
A:L1.10, 1.10] OF REAL;
[1..10, 1.10] OF REAL;
C:[1..10, 1.10] OF REAL;
BEGIN
Statements which read L, M, N, A, B,C
MATMUL (A, B,C, L, M,N);
Statements which do something with C
END.
‘Thus the language has some ALGOL-like features in that, within the procedure,
arrays A, B and C are quasi-dynamic and do not need to be dimensioned.
However, there is no real concept of a stack pointer and in the main program A, B
and C need to be assigned fixed dimensions. The PASCAL language does possess
the built-in procedures (functions) HIGH and LOW which enable bounds of
arrays to be inspected; e.g, HIGH(A, 1) would deliver the upper bound of the first
dimension of A. However, because of the lack of a truly dynamic structure, these
cannot be used to simplify the procedure call statements.
A language in which this is possible is ALGOL 68, It has an extremely flexible
structure and points the way towards the probable shape of future languages.
Our matrix multiply program becomes: .
(proc matmul =([,] real a, b, ref [,] real c) void;
(int |=1 upb a, m= upb b, n= 2 upb; b
loc int i, j, ks
for i to | do for j to n do
loc real x:=.0;
for k to m do
xt :=ali,k]*b[k, jlod;
cLi, j]:=x od od
loc int |, m,n;
read ((I,m,n));
oc (1:1, I:m] real a, loc [1:m, 1:n] real b, loc (1:1, 7:n] real c;
read ((a,b));
matmul (a,b,¢); print (c)
)
The procedure calling parameters have been reduced to three (compared with
FORTRAN’s nine) and the language has many more useful features. For 13
example, operations between matrices can be defined so that procedure calls can
be dispensed with and operation c=axb would implicitly mean matrix
multiply. One can therefore anticipate languages specially adapted for matrix
manipulation.
1.9 CONCLUSIONS
Computers on which finite element computations can be done vary widely in
their size and architecture. Because of its entrenched position FORTRAN is the
language in which computer programs for engineering applications had best be
written in order to assure maximum readership and portability. (There are
inevitably minor differences between machines, for example in their handling of
free format input which is used exclusively in the test programs, but these are not
overwhelming.) However, FORTRAN possesses fundamental limitations which
can only partially be overcome by writing a structure of FORTRAN which is as
close to ALGOL as can be achieved. This is particularly vital in subroutine
calling. Using this structure of FORTRAN, a library of subroutines can be
created which is then held in compiled form on backing store and accessed by
programs in just the way that a manufacturer's permanent library is.
Using this philosophy, a library of over 100 subroutines has been assembled,
together with some 50 example programs which access the library. These
programs are written in a reasonably ‘structured’ style, and tapes or discs of
library and programs will be supplied to readers on request. Versions are at
present available for all the common machine ranges.
The structure of the remainder of the book is as follows. Chapter 2 shows how
the differential equations governing the behaviour of solids and fluids are
programs are written in a reasonably ‘structured’ style, and tapes or discs of
library and programs will be supplied to readers on request. Versions are at
present available for all the common machine ranges.
Chapter 3 describes the sub-program library and the basic techniques by
which main programs are constructed to solve the equations listed in Chapter 2.
The remaining Chapters 4 to 12 are concerned with applications, partly in the
authors’ field of geomechanics. However, the methods and programs described
are equally applicable in many other fields such as structural mechanics, water
resources, electromagnetics and so on. Chapter 4 leads off with static analysis of
skeletal structures and plate problems. Chapter 5 deals with static analysis of
linear solids, whilst Chapter 6 discusses extensions to deal with material non-
linearity. Chapter 7 is concerned with problems of fluid flow in the steady state
while transient states with inclusion of transport phenomena (diffusion with
advection) are treated in Chapter 8. In Chapter 9, coupling between solid and
fluid phases is treated, with applications to consolidation processes. A second
type of ‘coupling’ involves the Navier-Stokes equations. Chapter 10 contains
programs for the solution of steady state vibration problems, involving the deter-
mination of natural modes, by various methods. Integration of the equations 4
of motion in time by direct integration, by modal superposition and by ‘complex
response’ is described in Chapter 11. Finally, Chapter 12 deals with problems of
pile capacity and driveability, for single piles and including group effects.
In every applications chapter, test programs are listed and described, together
with specimen input and output.
110 REFERENCES
Barron, D. W. (1977) An Introduction to the Study of Programming Languages. Cambridge
University Press.
Dijkstra, E. W. (1976) A Discipline of Programming. Prentice-Hall, Englewood Cliffs, New
Jersey.
Ford, B., and Sayers, D. K. (1976) Developing a single numerical algorithms library for
different machine ranges. ACM Trans. Math. Software, 2, 115.
Lindsey, C. H. (1977) Structure charts: a structured alternative to flow charts. SIGPLAN
Notices, 12, No. 11, 36. CHAPTER 2
Spatial Discretisation by Finite Elements
2.0 INTRODUCTION
The finite element method is a technique for solving partial differential equations
by first discretising these equations in their space dimensions. The discretisation
is carried out locally over small regions of simple but arbitrary shape (the finite
elements), This results in matrix equations relating the input at specified points
in the elements (the nodes) to the output at these same points. In order to solve
equations over large regions, the matrix equations for the smaller sub-regions are
usually summed node by node, resulting in global matrix equations. The method
is already described in many texts, for example Zienkiewicz (1977), Strang and
Fix (1973), Cook (1981), Connor and Brebbia (1976) and Rao (1982), but the
principles will briefly be described in this chapter in order to establish a notation
and to set the scene for the later descriptions of programming techniques.
21 ROD ELEMENT
Figure 2.1(a) shows the simplest solid element, namely an elastic rod, with end
nodes 1 and 2. The element has length L while u denotes the longitudinal
displacements of points on the rod which is subjected to axial loading only.
If Ps the axial force in the rod at a particular section and F is an applied body
force with units of force per unit length then
ou
P=0A=EAe= EA (21)
and for equilibrium from Figure 2.1(b),
Ferao 22)
Hence the differential equation to be solved is
FAn 4 F=0 (23)
dx?
15 16
displacement
x
body force
(a) =
Le
P=— S —~ p+ dP bx
tb) IIs +3
te — ae.
p Ky Pt ox
Figure 2.1 Equilibrium of a rod element
(Although this is an ordinary differential equation, future equations, for example
(2.13), preserve the same notation.)
In the finite element technique, the continuous variable u is approximated in
terms of its nodal values, u, and u2, through simple functions of the space variable
called ‘shape functions’. That is ’
ue Nyy + Nata
of
u~[Ny wafer} =Nu 24)
In simple examples the approximate equality in (2.4) could be made exact by
setting .
m=(t -3). N,=% es
if the true variation of u is linear. In general N and Nz will be of higher order or
more linear element subdivisions will be necessary.
When (2.4) is substituted in (2.3) we have
e uy
BASIN: nai{ttl era (2.6)
so that the partial differential equation has been replaced by an equation in the
discretised space variables u, and u,. The problem now reduces to one of finding
‘good’ values for u, and up.
Manv methads could be used to achieve this, and Crandall (1956) discusses 17
collocation, subdomain, Galerkin and least squares techniques. Of these,
Galerkin’s method, e.g. Finlayson (1972) is the most widely used in finite element
work. The method consists in multiplying equation (2.6) by the shape functions in
turn and integrating the resulting residual over the element. Thus
LIN, @ uy LN, _
[fest safe rues
Note that in the present example, double differentiation of the shape functions
would cause them to vanish and yet we know the correct shape may not be of
higher order than linear. This difficulty is resolved by applying Green’s theorem
(integration by parts) to yield typically
#N, ‘aN, ON; a.
J qi Ox = — [at gid + boundary terms which we ignore (2.8)
Hence (2.7) becomes
ON, ON, ON, ON,
tax Ox ax ax uy TEN,
zal’ aN, aN, ON; aN a(t -F IN. dx=0 (2.9)
Ox éx ax Ox
On evaluation of the integrals,
(2.10)
Nie Ne
u
“a
os
==
The above case is for a uniformly distributed force F acting along the rod. For
the case in Figure 2.1(a) where the loading is applied only at the nodes we have
tot
L L| fu F,
EA Mes : (2.11
Me eine ean
LoL
which are the familiar ‘stiffness’ equations for a uniform prismatic rod. In matrix
notation we may write
KMu=F (2.12)
where KM is called the ‘element stiffness matrix’.
2.2, ROD INERTIA MATRIX
Consider now the case of an unrestrained rod in longitudinal motion.
Figure 2.1(c) shows the equilibrium of a segment in which the body force is now 18
given by Newton’s law as mass times acceleration, If the mass per unit volume is
p, the differential equation becomes
(2.13)
On discretising u by finite elements as before, the first term in (2.13) clearly leads
again to KM. The second term takes the form
“IN, @ uy
[pease waite
or
“ENN, NiN,), 6 fu,
—pA oe “lexi : 2.15)
p {, a N,Na J ot lus (
Evaluation of integrals yields
$3) 8 fu
~eat|} 4 ar Yue 2.16
or in matrix notation
Ou
—-MM 3 t 3) i"
P 4L -3 -L| |6,
+5 % at], (232)
7 2
Symmetrical 4c| [a
If this matrix is designated by KP the equilibrium equation becomes
(KM-—KP)w =F (2.33)
Buckling of a member can be investigated by solving the eigenvalue problem
when F = 0, by increasing the compressive force on the element (corresponding to
KP in 2.33) until large deformations result or in simple cases by determinant
search, Program 12.1 uses the KP matrix to assess the effect of axial loading on the
response of laterally loaded piles. Equations (2.32) and (2.33) represent an
approximation of the approach to modifying the element stiffness involving
stability functions (Lundquist and Kroll, 1944; Horne and Merchant, 1965). The
accuracy of the approximation depends on the value of P/P; for each member,
where Pr is the Euler load. Over the range — 1
You might also like
