Computational

Framework for the Finite

Element Method in
MATLAB® and Python

Computational Framework for the Finite Element Method in MATLAB® and Python
aims to provide a programming framework for coding linear FEM using matrix-based
MATLAB® language and Python scripting language. It describes FEM algorithm imple-
mentation in the most generic formulation so that it is possible to apply this algorithm to
as many application problems as possible.

Readers can follow the step-by-step process of developing algorithms with clear explana-
tions of its underlying mathematics and how to put it into MATLAB and Python code.
The content is focused on aspects of numerical methods and coding FEM rather than
FEM mathematical analysis. However, basic mathematical formulations for numerical
techniques which are needed to implement FEM are provided. Particular attention is paid
to an efficient programming style using sparse matrices.

Features
• Contains ready-to-use coding recipes allowing fast prototyping and solving of math-
ematical problems using FEM
• Suitable for upper-level undergraduates and graduates in applied mathematics, science
or engineering
• Both MATLAB and Python programming codes are provided to give readers more
flexibility in the practical framework implementation

Pavel Sumets is a research and development software engineer from New Zealand whose
main interest and expertise are biomechanics, numerical methods and scientific program-
ming.
Taylor & Francis
Taylor & Francis Group
http://taylorandfrancis.com
 Computational
Framework for the Finite
Element Method in
MATLAB® and Python

Pavel Sumets
MATLAB® is a trademark of The MathWorks, Inc. and is used with permission. The MathWorks
does not warrant the accuracy of the text or exercises in this book. This book’s use or discussion of
MATLAB® software or related products does not constitute endorsement or sponsorship by The
MathWorks of a particular pedagogical approach or particular use of the MATLAB® software.

First edition published 2023

by CRC Press
6000 Broken Sound Parkway NW, Suite 300, Boca Raton, FL 33487-2742

and by CRC Press

4 Park Square, Milton Park, Abingdon, Oxon, OX14 4RN

© 2023 Taylor & Francis, LLC

CRC Press is an imprint of Taylor & Francis Group, LLC

Reasonable efforts have been made to publish reliable data and information, but the author and pub-
lisher cannot assume responsibility for the validity of all materials or the consequences of their use.
The authors and publishers have attempted to trace the copyright holders of all material reproduced
in this publication and apologize to copyright holders if permission to publish in this form has not
been obtained. If any copyright material has not been acknowledged please write and let us know so
we may rectify in any future reprint.

Except as permitted under U.S. Copyright Law, no part of this book may be reprinted, reproduced,
transmitted, or utilized in any form by any electronic, mechanical, or other means, now known or
hereafter invented, including photocopying, microfilming, and recording, or in any information stor-
age or retrieval system, without written permission from the publishers.

For permission to photocopy or use material electronically from this work, access www.copyright.
com or contact the Copyright Clearance Center, Inc. (CCC), 222 Rosewood Drive, Danvers, MA
01923, 978-750-8400. For works that are not available on CCC please contact mpkbookspermis-
[email protected]

Trademark notice: Product or corporate names may be trademarks or registered trademarks and are
used only for identification and explanation without intent to infringe.

ISBN: 978-1-032-20925-8 (hbk)

ISBN: 978-1-032-20927-2 (pbk)
ISBN: 978-1-003-26597-9 (ebk)

DOI: 10.1201/9781003265979

Typeset in LM Roman font

by KnowledgeWorks Global Ltd.

Publisher’s note: This book has been prepared from camera-ready copy provided by the authors.
Contents

Introduction ix

Background and Basic Concepts xiii

Chapter 1 ■ Finite Element Method for the One-Dimensional

Boundary Value Problem 1

1.1 FORMULATION OF THE PROBLEM 2

1.2 INTEGRAL EQUATION 5
1.3 LAGRANGE INTERPOLATING POLYNOMIALS 8
1.3.1 Global Interpolating Polynomial 8
1.3.2 Piecewise Polynomial Interpolation 12
1.3.3 Linear System of the FEM 14
1.4 ILLUSTRATIVE PROBLEM 17
1.5 ALGORITHMS OF THE FINITE ELEMENT METHOD 26
1.5.1 Composing Linear System of the FEM 26
1.5.2 Assembling Global Matrices 27
1.5.3 Calculating Elements of the Local Matrices 30
1.6 QUADRATURE RULES 34
1.7 DEFINING PARAMETERS OF THE FEM 36

Chapter 2 ■ Programming One-Dimensional Finite Element

Method 41

2.1 SPARSE MATRICES IN MATLAB⃝

R
42
2.2 INPUT DATA STRUCTURES 43

v
vi ■ Contents

2.3 CODING QUADRATURE RULES 44

2.4 INTERPOLATING AND DIFFERENTIATING MATRICES 46
2.5 CALCULATING AND ASSEMBLING FEM MATRICES 49
2.6 PYTHON IMPLEMENTATION 57

Chapter 3 ■ Finite Element Method for the Two-Dimensional

Boundary Value Problem 69

3.1 MODEL PROBLEM 70

3.2 FINITE ELEMENTS DEFINITION 71
3.3 TRIANGULATION EXAMPLES 72
3.4 LINEAR SYSTEM OF THE FEM 72
3.5 STIFFNESS MATRIX AND FORCING VECTOR 74
3.6 ALGORITHM OF SOLVING PROBLEM 76

Chapter 4 ■ Building Two-Dimensional Meshes 79

4.1 DEFINING GEOMETRY 80

4.2 REPRESENTING MESHES IN MATRIX FORM FOR LINEAR
INTERPOLATION FUNCTIONS 84
4.3 COMPLEMENTARY MESH 87
4.4 BUILDING MESHES IN MATLAB⃝
R
90
4.5 BUILDING MESHES IN PYTHON 94

Chapter 5 ■ Programming Two-Dimensional Finite Element

Method 101

5.1 ASSEMBLING GLOBAL STIFFNESS MATRIX 101

5.2 ASSEMBLING GLOBAL FORCING VECTOR 106
5.3 CALCULATING LOCAL STIFFNESS MATRICES 108
5.4 CALCULATING EQUATION COEFFICIENTS 113
5.5 CALCULATING GLOBAL MATRICES 113
5.6 CALCULATING BOUNDARY CONDITIONS 119
 Contents ■ vii

5.7 ASSEMBLING BOUNDARY CONDITIONS 121

5.8 SOLVING EXAMPLE PROBLEM 124

Chapter 6 ■ Nonlinear Basis Functions 129

6.1 LINEAR TRIANGULAR ELEMENTS 129

6.2 CURVILINEAR TRIANGULAR ELEMENTS 130
6.3 STIFFNESS MATRIX WITH QUADRATIC BASIS 131

Conclusion 137

Appendix A ■ Variational Formulation of a BVP 139

Appendix B ■ Discussion of Global Interpolation 141

Appendix C ■ Interpolatory Quadrature Formulas 145

Appendix D ■ Quadrature Rules and Orthogonal Polynomials 149

Appendix E ■ Computational Framework in Python 153

E.1 ASSEMBLING MATRICES 153

E.2 ASSEMBLING BOUNDARY CONDITIONS 155
E.3 SOLVING EXAMPLE PROBLEM 160

Bibliography 163

Index 165
Introduction

f you are studying or working in the area of engineering, applied

I mathematics or physics, it is very likely that you have already
heard about the finite element method (FEM). Probably, you have read
some literature on FEM and have tried to solve your particular problem
using some FEM software package. Based on my own experience of do-
ing so, it is not easy for the newcomer to get into the subject matter.
Things become more complicated if you are a researcher and try to solve
a nonstandard problem, which requires building customized program-
ming code. Apart from the underlying mathematics, implementing FEM
involves scientific programming, which includes coding various numerical
methods such as polynomial interpolation, integrating with quadrature
rules and a linear solver for matrix equations. Not to mention that build-
ing geometric representation for a particular customized problem is not
always a trivial problem, all these tasks form quite a complicated FEM
algorithm to be solved. Probably, implementing each individual compo-
nent of the algorithm does not represent a challenge, but combining them
all together in one interconnected system which should work efficiently
and correctly is what makes FEM implementation challenging.
When an engineer or researcher faces a need to solve a problem using
FEM, basically, there are three possible options: use existing standard
FEM software packages, rewrite and optimize some third-party FEM
library for particular needs or write everything from scratch. Obviously,
if someone writes everything from scratch, the subject knowledge should
cover all aspects of an underlying FEM algorithm. The advantage of hav-
ing comprehensive knowledge about how FEM works is that it allows us
to understand any existing FEM software packages as well. The con-
tent of this book is written with an idea to give necessary knowledge to
develop numerical coding skills and become flexible with solving FEM.
Who this book is intended for:
This book is for those who want to gain skills in scientific program-
ming numerical methods and better understand their advantages and

ix
x ■ Introduction

drawbacks. Although the pivot point of the book is the FEM algorithm,
various complementary tasks are considered. To be specific, the book
provides a programming framework for coding linear FEM algorithms
using the matrix-based MATLAB⃝ R
language and the Python scripting
language in application to solving ordinary and partial differential equa-
tions. Special attention is paid to building numerical algorithms and its
efficient implementation for both one- and two-dimensional problems. A
reader can follow a step-by-step process of developing algorithms with
explanations of their underlying mathematics and how to put them into
MATLAB and Python code with corresponding analysis of their effi-
ciency.
The content is focussed on aspects of numerical methods and cod-
ing FEM algorithms rather than FEM mathematical analysis; however,
basic mathematical formulations for numerical techniques needed to im-
plement FEM algorithms are provided.
Level of presentation:
The mathematical background is assumed to be covered by matrix
algebra, vector calculus and the basics of ordinary and partial differential
equations. It is going to be a demonstration of how the FEM works in
the one- and two-dimensional case, written as applied mathematicians
usually write it. The content throughout the book is not restricted to
either Laplace or Poisson equations but rather covers general linear el-
liptic boundary value problems. Unlike the majority of the books on the
FEM method which imply that a reader is familiar with structural me-
chanics, the current book is based on more generic formulations without
assuming any mechanics background. Structural finite elements are not
considered in examples and they are not discussed at all since, contrary
to expectations, the structural elements are much more complicated to
describe and use. They are left to an advanced FEM course. The book
has a number of appendices which contain more detailed explanations of
the numerical methods used in the main body of the book, so a reader
can refresh or enrich their corresponding knowledge.
We use MATLAB and Python as programming languages to code
the steps of the FEM algorithm. Throughout the book, the ideas of
coding are illustrated using MATLAB with complementary translation
to Python as well. Providing the code examples in both programming
languages is done to add flexibility in framework implementation.
In terms of programming background, it is expected that a reader is
familiar with basic matrix and vector manipulation using MATLAB and
the NumPy package in Python. Every code example given in the book
 Introduction ■ xi

is explained in detail so that even a programmer with little experience

could understand the underlying algorithm logic and implementation.
We pay attention to an efficient programming style using sparse matrices.
Distinctive features of the book:
There is a large number of books on FEM including FEM math-
ematical analysis, coding FEM and solving application problems using
FEM (mostly problems on mechanics). However, not many of them cover
both theory and numerical implementation with coding examples. Usu-
ally, the programming implementation comes as complementary to the
theoretical part just to illustrate implementation for basic simple cases.
Very often, programming implementation is provided for specific applica-
tion problems with tailored code, and the majority of these applications
comes from the structural mechanics.
The current book is designed with an idea to describe FEM algorithm
implementation itself and to do this in the most generic formulation so as
to make it possible to apply this algorithm to as many application prob-
lems as possible. Here, the theoretical part is given as much as needed
to implement the corresponding numerical methods which are part of
the FEM algorithm. The book pays attention to the important practical
details which arise when an engineer writes programming code. Overall,
the book considers the FEM method from the scientific programming
point of view.
Topics covered by the book content:
The content of the book is divided into six chapters and covers the
following subjects:

• Lagrange interpolating polynomials;

• quadrature rules for numerical integration;

• defining parameters of the FEM and its influence on solution er-

rors;

• calculating matrices of the FEM;

• assembling matrices of the FEM;

• incorporating boundary conditions into FEM matrices;

• FEM data structures;

• defining geometry and building two-dimensional triangular mesh;

xii ■ Introduction

• adaptation to curved boundaries (isoparametric finite elements);

• solving model problems using FEM.

We shall start with formulation of the model boundary value problem

for the linear one-dimensional ordinary differential equation. Then, by
introducing interpolating functions and finite elements, FEM algorithms
for solving model problems are derived. The two-dimensional problem
for a linear partial differential equation is considered afterwards and the
corresponding two-dimensional FEM algorithms are derived. Each step
of the algorithms is provided in detail with programming function imple-
mentations. We discuss data structures to represent mesh triangulation
and boundary conditions, and compare different approaches of the ma-
trices assembling process. Full programming code is given for an example
problem with validating computational efficiency.
The source code for listings in the book is downloadable and can be
found in the repository https://github.com/psumets/FEM_lib
Background and Basic
Concepts

he finite element method (FEM) is a numerical method to solve

T ordinary and partial differential equations arising in mathematical
modelling. Originally developed for solving problems in solid-state me-
chanics, it proved to be efficient and robust in various practical applica-
tions ranging from traditional fields of structural analysis, heat transfer,
fluid flow, mass transport and electromagnetic potential, to simulating
geometry deformation in computer character animation.
The fundamental idea of the FEM is subdividing the computational
domain into smaller and simpler parts that are called finite elements, and
finding local solutions within the boundary of these elements. By stitch-
ing the individual solutions on final elements back together, a global
solution can be obtained. Some of the FEM advantages are the ability
of accurate representation of complex geometry, capture of local effects
and easy solution representation.
The history of the method is quite instructive. FEM concepts were
initially introduced by Courant in 1943 in his work on solving the tor-
sion problem, but this work did not attract much attention. Later, in the
1950s, structural engineers put the FEM on the map as a practical tech-
nique for solving their elasticity problem. The method had now become
an important technique from both the practical and theoretical point of
view, and the number of the method’s applications began to increase at a
tremendous rate. In the 1970s, mathematicians gave a comprehensive ac-
count of the method and its underlying theory. By the current time, the
FEM has evolved into a universal tool for solving differential equations
numerically. Numerous software packages adapted FEM to use with ap-
plications in all areas of computational physics and engineering. ANSYS,
ADINA and LS-DYNA are examples of general-purpose computer codes
for industrial users of the FEM.

xiii
xiv ■ Background and Basic Concepts

Any numerical modelling of a phenomenon starts with formulating a

mathematical model to be solved. Then, a numerical model is constructed
that can be solved using computers. The final stage is development of a
computer model (computer code) to simulate behaviour of the system.
The FEM represents a numerical model, so it describes how to transform
model equations, geometry and boundary conditions into a discretized
form suitable to be consumed by numerical methods. An original math-
ematical model could have various forms and the resulting numerical
model varies as well, but the FEM approach dictates a certain tactic
of obtaining a numerical model and it follows certain basic concepts.
As such, algorithms of the FEM can be considered as universal tools to
approach numerical modelling. Finally, a computer model represents a
software package which usually has a form of library with computer im-
plementation of numerical methods that make up FEM algorithms (for
example, numerical integration or a linear solver). Building a library
code is an art of scientific programming which implies not only good
knowledge of the mathematics behind the numerical methods but good
programming skills as well. Choice of programming language affects all
of the development process as every language has its own unique features
and it could come with existing numerical libraries which can be reused
or tailored for use with the FEM. Also, very often the code should be
optimized to have good performance with the lowest possible calculation
error. In case of FEM, a numerical model is often modified slightly so as
to take shape of an optimized algorithm which is ready to be coded.
Let us outline the main steps of solving a problem using FEM. As
a starting point, we have a mathematical model formulated in terms of
a differential equation along with geometry and boundary conditions.
First, this model needs to be converted in the form of integral equa-
tions with integrals over a geometry domain (in some cases, the original
mathematical model is already expressed in an integral form). Once the
integral formulation is obtained, the next step is to perform discretiza-
tion when continuous variables or functions are transformed into discrete
counterparts. Discretization includes splitting the geometry domain into
individual small patches (final elements) and representing initially con-
tinuous functions and integrals as combinations of its interpolation over
finite elements. In other words, the solution is sought in the form of piece-
wise interpolation and coefficients of this interpolation are unknowns
which can be found from the discrete model representation. Usually, af-
ter discretization, the model transforms into a system of equations which
could be either linear or nonlinear, depending on the initial form of the
 Background and Basic Concepts ■ xv

differential equation. The final step is to solve the system and represent
the final solution through a piecewise interpolating polynomial.
Programming FEM involves coding various numerical methods and
binding them together into one pipeline. It is worth noting that every
piece of the pipeline matters as any error introduced at any stage prop-
agates further with accumulative effect which could invalidate the final
result. That is why coding numerical implementation is an important
part of numerical simulation which should not be underestimated. At a
high level, coding includes the following main stages: Firstly, an algo-
rithm of geometry discretization comes into play where final elements are
generated. Then, based on the shape and distribution of these elements,
implementation of particular numerical integration methods has to be
coded. The next important part is to define an algorithm of assembling
all these calculated values over individual finite elements into a matrix
which forms forming linear system to be solved numerically.
Once the FEM algorithm is coded, validation is carried out to make
sure that the implementation is correct. This is usually done against a
benchmark with a known analytical solution so that we can estimate
error and convergence of the method with various discretization param-
eters.
There are a large number of books on FEM including FEM math-
ematical analysis, coding FEM and solving application problems using
FEM which could be helpful for understanding FEM algorithms. For
example, a reader could find a comprehensive FEM analysis in [1] which
covers finite elements of different types. The book by [3] is focussed on
steady-state boundary value problems. It contains thorough theoretical
and practical aspects of implementing FEM and explains how to write
a finite element code from scratch. MATLAB implementation of FEM
algorithms with detailed descriptions of numerical analysis and mesh-
ing techniques can be found in [5] and [2]. Reading [4] and [7] is useful
to learn about using Python for scientific computing. For better un-
derstanding of how to use specific MATLAB tools to solve differential
equations, see documentation [6].
 CHAPTER 1

Finite Element Method

for the
One-Dimensional
Boundary Value
Problem

t was mentioned in the introduction of basic concepts that the devel-

I opment of the finite element method (FEM) in practical terms was
established by engineers to solve their structural problems. For this rea-
son, the FEM is usually approached through considering displacement
of a system of linear springs under applied force. This technique is de-
veloped from the stiffness approach applied to structural problems and
equations arising from this technique are force-displacement relation-
ships which model specific mechanics. Unlike this conventional approach,
the method of introducing FEM in this book is based on broader formu-
lation considering a generic differential equation without any structural
mechanics reference. All particular problems, including structural ones,
can be modelled as a special case of this generic equation.
In this chapter we obtain FEM algorithm for linear one-dimensional
second-order ordinary differential equation (ODE) with mixed boundary
conditions. First, we derive integral equation for the boundary value
problem and outline basic approach of the FEM. Then, finite elements

DOI: 10.1201/9781003265979-1 1
2 ■ Computational Framework for the Finite Element Method

and basis functions are introduced along with polynomial interpolation

techniques. We show how the integral equation can be discretized with
finite elements and how the FEM is reduced to solving linear system.

GLOSSARY
u, v, . . . : vectors are written using bold fonts.
P
n
(u · v): dot product of two vectors, u · v = ui vi .
i=1

U, V, . . . : matrices are denoted by capital letters.

f (x): a function of a single variable.

f ′ , f ′′ , . . . : derivatives of a single variable function f (x).

C(a, b): set of continuous on the interval (a, b) functions.

C k (a, b): set of continuous functions that have continuous first k deriva-
tives.

L2 (a, b): space of functions defined on (a, b) for which the second power
of the absolute value is Lebesgue integrable. If v(x) ∈ L2 (a, b), then
Rb
∥v∥2L2 = a |v|2 dx < ∞.

H 1 (a, b): Sobolev space defined as H 1 (a, b) := {v ∈ L2 (a, b) : v ′ ∈

Rb

L2 (a, b)}. If v(x) ∈ H 1 (a, b), then ∥v∥2H 1 = a |v ′ |2 dx < ∞.

Gm : set of polynomials of degree not greater than m.

1.1 FORMULATION OF THE BOUNDARY VALUE PROBLEM FOR

LINEAR SECOND-ORDER ODE
Throughout the chapter, we consider linear ODE of the form

′
− c(x)u′ (x) + b(x)u′ (x) + a(x)u(x) = f (x), x ∈ (s0 , s1 ). (1.1)

Here, c(x), b(x), a(x) and f (x) are known functions; u(x) is unknown
function to be found, and u′ = du/dx. It is assumed that c ∈
C 1 [s0 , s1 ]; b, a, f ∈ C[s0 , s1 ] and c(x) > 0 ∀x ∈ [s0 , s1 ]. Negative sign in
equation (1.1) is for convenience and the reason of keeping this sign will
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 3

be clarified later. We are going to derive FEM algorithm, which is based

on equation (1.1).
By considering equation of the form (1.1), we cover the problem
in most generic formulations which allows solving specific problems as
well; for example, when c(x) = −1, b(x) = a(x) = 0, we come to Pois-
son equation, u′′ (x) = f (x). Another example could be one-dimensional
steady-state heat equation with heat sink, −(c(x)u′ (x))′ ) + u(x) = 0,
where u(x) is a temperature and c(x) is a thermal conductivity. This
equation is a special case of more generic one (1.1).
Note that an ODE allows multiple solutions and addition conditions
are needed to obtain unique solution. To find a unique solution to equa-
tion (1.1), two boundary conditions are needed (second-order equation
needs two extra conditions to be uniquely resolved). If both boundary
conditions are specified at a single point (either s0 or s1 ), then this prob-
lem is called Cauchy problem. Problem (1.1) with boundary conditions
specified at both, s0 and s1 , boundary points is called boundary value
problem (BVP). Cauchy problem and BVP have distinct properties and
solution methods. This book is focussed on BVP only.
Let us consider various types of conditions, which can be specified
at a boundary point s (here, s could be any of {s0 , s1 }). For example,
solution is known at point s with u(s) = us , which gives us Dirichlet (or
first-type) boundary condition. Another situation is when a derivative
of solution at boundary point is defined u′ (s) = u′s which is called Neu-
mann (or second-type) boundary condition. Combination of Dirichlet
and Neumann boundary conditions gives Robin (or third-type) bound-
ary condition having form u′ (s) + ρu(s) = µ, or ±(cu′ )(s) + σu(s) = µ
with corresponding choice of σ and µ (here, function c(x) is a coefficient
of equation (1.1)). Usually, these conditions have some meaning depend-
ing on particular application problem. For example, in application to
the heat equation with u(x) being a temperature, Dirichlet boundary
condition means that a temperature at a boundary point is known,
and Neumann boundary condition specifies heat flux at a boundary
point.
If boundary conditions (BC) of different types are given for a BVP,
then it is called that a mixed boundary condition is defined. For example,
problem (1.1) can be complemented by BC

u(s0 ) = us0 , (cu′ )(s1 ) + σu(s1 ) = µ. (1.2)

4 ■ Computational Framework for the Finite Element Method

Here, Dirichlet BC is specified at s0 and Robin BC is given at s1

which all together give mixed BC. Further, conditions (1.2) are used as
a BC to find a unique solution to the problem (1.1). Now, let us give a
definition of the solution function u(x).

Definition 1.1 Function u(x) ∈ C 2 (s0 , s1 ) ∩ C 1 (s0 , s1 ] ∩ C[s0 , s1 ] sat-

isfying equation (1.1) and BC (1.2) is called a classical solution to the
BVP.

It is assumed that there exists a unique solution u(x), and further

we are focussed on solving BVP (1.1)–(1.2) using FEM. To reach this
goal, we need to transform the problem to an integral equation which is
shown in the next section.

EXERCISES
▶ To see clearly how solution property depends on particular BC,
solve the equation

u′′ + 3u′ − 4u = 0, x ∈ (0, 1)

with two sets of BC:

(a) u(0) = 1, u′ (0) = 0;

(b) u(0) = 1, u(1) = 0.

Case (a) is Cauchy problem having solution, which increases expo-
nentially while solution corresponding to case (b) decreases.

▶ Unlike Cauchy problem, even a simple BVP could have no solution.

Explore the problem:

u′′ + u = 0, x ∈ (0, π), u(0) = 1, u(π) = α,

where α is a parameter. Find values of α for which solution exists.

Is this solution unique?

▶ Find solution to the problem

−u′′ + u = 0, x ∈ (0, π), u(0) = 1, u(π) = α,

and show that it has unique solution for any value of parameter α.
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 5

1.2 INTEGRAL EQUATION

Let us transform the problems (1.1)–(1.2) into an integral equation suit-
able for applying FEM. There are several approaches of doing this, which
include variational and projective methods. In this book we use projec-
tive method while variational approach is discussed in Appendix A. Pro-
jective method is based on the orthogonal L2 projection on the Sobolev
space, H 1 (s0 , s1 ).
Definition 1.2 Given a function f (x) ∈ L2 (s0 , s1 ) and a space
H 1 (s0 , s1 ), the L2 orthogonal projection P r(f ) ∈ H 1 (s0 , s1 ) of a func-
tion f (x) is defined by
Zs1
(f (x) − P r(f )) v(x)dx = 0, ∀v(x) ∈ H 1 (s0 , s1 ). (1.3)
s0

In analogy with projection onto subspaces of Rn , (1.3) defines a pro-

jection of f onto H 1 , since the difference f − P r(f ) is required to be
orthogonal to all functions v in H 1 (see figure 1.1).
From Definition 1.2, it follows that L2 projection can be viewed as a
technique for approximating functions, which gives a weighted average
approximation of function f by its projection and weights v(x)
Zs1 Zs1
P r(f ) ∈ H 1 (s0 , s1 ),
f (x)v(x)dx = P r(f )v(x)dx, (1.4)
∀v(x) ∈ H 1 (s0 , s1 ).
s0 s0

In this context, the function v(x) is referred to as a weight or test func-

tion. Now, considering f in (1.4) to be right hand side of equation (1.1),

f
f - Pr(f )

xzcv
1 v
H
Pr(f )

FIGURE 1.1: Illustration of L2 orthogonal projection.

6 ■ Computational Framework for the Finite Element Method

projection P r(f ) corresponds to projecting left hand side of equation

(1.1) on to the space H 1 (s0 , s1 ), as a result we obtain an integral ex-
pression

Zs1  

′
−c(x)u′ (x) + b(x)u′ (x) + a(x)u(x) v(x)dx
s0
Zs1
= f (x)v(x)dx, (1.5)
s0

where u(x), v(x) ∈ H 1 (s0 , s1 ). The intuition behind representing origi-

nal BVP (1.1) in the integral form (1.5) can be viewed as follows: If u(x)
were an exact solution over the whole interval (s0 , s1 ), equation (1.1)
would be exact everywhere. But, given that in real engineering problems
this will not be the case, we try to obtain an approximate solution u(x)
for which it meets the BVP equation in a spatially averaged sense (1.5).
In other words, the residual or error (i.e., the amount by which the dif-
ferential equation is not satisfied exactly at a point) is distributed evenly
over the interval.
Let us rewrite expression (1.5) in the form with integrals over indi-
vidual terms
Zs1 Zs1
′

′
− c(x)u (x) v(x)dx + b(x)u′ (x)v(x)dx
s0 s0
Zs1 Zs1
+ a(x)u(x)v(x)dx = f (x)v(x)dx. (1.6)
s0 s0

By applying integration by parts1 to the first integral in (1.6) we come

to
Zs1 s1 Zs1
′ ′ ′ ′ 

(cu v + bu v + auv)dx − (cu v) = f vdx. (1.7)
s0
s0 s0

1
Integration by parts rule:
Zs1 Zs1 s1

′
u (x)v(x)dx = − u(x)v ′ (x)dx + (uv)  .
s0
s0 s0
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 7

By inspecting second term in (1.7) and taking into account BC (1.2), we

see that
s1
′ 

(cu v) = c(s1 )u(s1 )′ v(s1 ) − c(s0 )u(s0 )′ v(s0 )
s0
= µv(s1 ) − σu(s1 )v(s1 ) − c(s0 )u(s0 )′ v(s0 ). (1.8)

If function v(x) is defined so that v(s0 ) = 0, then it follows from (1.7)

and (1.8) that
Zs1 Zs1
′ ′ ′


cu v + bu v + auv dx + σu(s1 )v(s1 ) = f vdx + µv(s1 ). (1.9)
s0 s0

Expression (1.9) is an integral equation, and it can be seen that if

u(x) is a solution to BVP (1.1)–(1.2), then it satisfies (1.9). Inverse
would be valid if we complement integral equation (1.9) by the con-
dition u(s0 ) = us0 . As a result, equation (1.1) and BC (1.2) are now
transformed into one expression (1.9) where u(s0 ) = us0 and v(s0 ) = 0.
It is worth noting here that original BVP suggests that the solution
u should have derivatives up to second order. On the other hand, the
integral form (1.9) refers only to the first derivatives of u(x), which im-
plies weaker conditions on property of solution function. Moreover, due
to property of Sobolev space, L2 projection u(x) does not require the
function we seek to have continuous derivatives. As such, we relax some
conditions on solution of BVP by saying that the function u(x) is now
integrable continuous function having piecewise continuous derivatives
of the first order (in other words, it belongs to Sobolev space). For this
reason, (1.9) is called a weak form of the original BVP. The integral weak
form of (1.1)–(1.2) can now be defined in terms of the Sobolev space by
introducing two subspaces

W := {w ∈ H 1 (s0 , s1 ) : w(s0 ) = us0 },

W 0 := {w ∈ H 1 (s0 , s1 ) : w(s0 ) = 0},

as follows.

Definition 1.3 Expression (1.9) with u(x) ∈ W and arbitrary function

v(x) ∈ W 0 is called the integral equation corresponding to the BVP
(1.1)–(1.2). Function u(x) is called a weak solution if it satisfies (1.9).
8 ■ Computational Framework for the Finite Element Method

Obtaining expression (1.9) is the first step in the FEM formula-

tion for the BVP. Next step is to represent solution through polyno-
mial approximation. Since we consider u(x) to be piecewise smooth,
piecewise polynomial interpolation is used to approximate u(x). Gener-
ally speaking, FEM can be expressed as following: FEM = integral equa-
tion + piecewise polynomial interpolation. In the next section we explore
polynomial interpolation methods.

EXERCISES
▶ Prove that (1.1)–(1.2) follow from (1.9). Instruction: take any point
x0 ∈ (s0 , s1 ); consider an interval [x0 − h, x0 + h] ⊂ (s0 , s1 ) and
use the expression (1.7) defined on this interval with v ∈ C 1 [s0 , s1 ]
and v(x) = 0 for x ∈ / [x0 − h, x0 + h]; perform passage to the limit
h → 0 and obtain (1.1).

▶ Deduce integral equation and define sets W and W 0 for the problem
(1.1) with following BC:

(a) BC of the third order is specified at the point s0 and BC of

the first order at the point s1 .
(b) BC of the third order is specified at both points, s0 and s1 .

1.3 LAGRANGE INTERPOLATING POLYNOMIALS AND THE

FINITE ELEMENT APPROXIMATION
Let us consider function approximation methods. Here, we discuss two
approaches: using single global interpolating polynomial and piecewise
polynomial interpolation. Both approaches are based on Lagrange inter-
polating polynomials. Since the concept of piecewise interpolation is an
extension of the global one, we start with considering global interpola-
tion first.

1.3.1 Global Interpolating Polynomial

Let u = u(x) be a continuous on the closed interval [s0 , s1 ] function with
defined set of nodes

s0 = x1 < x2 < · · · < xm+1 = s1 , h = s1 − s0 ,

Finite Element Method for the One-Dimensional Boundary Value Problem ■ 9

and ui = u(xi ), i = 1, . . . , m + 1. Then, there is a unique polynomial uh

of degree not greater than m satisfying

uh (xi ) = ui , i = 1, . . . , m + 1. (1.10)

Definition 1.4 The points xi are called interpolation points or interpo-

lation nodes and expression (1.10) is the interpolation condition. Poly-
nomial uh (x) is considered to be an approximation of function u(x) on
the interval [s0 , s1 ].

Note that uh (x) is not the same as u(x), but rather an approximation,
which coincides with u(x) in a given set of nodes. Polynomial approxi-
mation uh (x) can be created in different ways, but we are interested in
Lagrange interpolating polynomials having the form

X
m+1 Y
m+1
x − xj
uh (x) = ui φi (x), φi (x) = . (1.11)
xi − xj
i=1 j=1,j̸=i

In other words, we seek an approximation in the form of linear combi-

nation of the polynomials φi (x) with known weights ui .

Definition 1.5 Polynomials φi (x) in (1.11) are called Lagrange basis

functions.

It can be seen that

φi ∈ Gm , φi (xj ) = δij , j = 1, . . . , m + 1,

where Gm denotes a set of polynomials of degree not greater than m,

and δij is the Kronecker delta.2 Functions φi (x) are called basis due to
the fact that they form a basis in Gm and any polynomial p ∈ Gm can be
represented through this basis (see 1.11). Particularly, if uh ≡ 1, then it
follows from (1.11) that

X
m+1
φi (x) = 1, x ∈ [s0 , s1 ]. (1.12)
i=1

2
Kronecker delta function is defined as:
(
0, if i ̸= j,
δij =
1, if i = j.
10 ■ Computational Framework for the Finite Element Method

It is worth noting that evaluating the basis functions φi (x) using

expression (1.11) requires O(m2 ) operations which becomes computa-
tionally expensive for large values of m. For this reason, it is desired to
rewrite (1.11) in another form of interpolation formula, which can be
referred as the barycentric formula

βi X
m+1
βi
φi (x) = w(x) , uh (x) = w(x) ui , (1.13)
x − xi x − xi
i=1

where
 −1
Y
m+1 Y
m+1
w(x) = (x − xj ), βi =  (xi − xj ) , (1.14)
j=1 j=1,j̸=i

and coefficients βi are called weights of barycentric formula. It follows

from (1.12) that

X
m+1 X
m+1
βi
1= φi (x) = w(x) ,
x − xi
i=1 i=1

and by using this fact, we come to the final form of the barycentric
interpolation formula
!−1 m+1
X
m+1
βi X βi
uh (x) = ui , (1.15)
x − xi x − xi
i=1 i=1

and basis functions

!−1
X
m+1
βi βi
φi (x) = . (1.16)
x − xi x − xi
i=1

It is easy to see that calculations of uh (x) using expression (1.15) for

any given x require O(m) operations. Weights βi do not depend on x
and ones precomputed can be reused for each evaluation of uh (x).
An important property of representations (1.15)–(1.16) is that they
remain valid when weights βi are multiplied by an arbitrary constant
value. The weights in the denominator are exactly the same as in the
numerator, and this means that any common factor in all the weights
may be cancelled. As such, weights βi can be defined up to constant
factor.
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 11

For particular case of nodes distribution, explicit formulas for

barycentric weights can be given. For instance, in case of evenly spaced
points xi+1 − xi = h/m, weights can be calculated through formula
m!
βi = (−1)i , i = 1, . . . , m + 1. (1.17)
(m − i + 1)!(i − 1)!
To illustrate calculation of weights βi , let us consider 4 nodes {x1 =
0, x2 = 1, x3 = 2, x4 = 3}. Using expression (1.14), we come to values
{β1 = −1/6, β2 = 1/2, β3 = −1/2, β4 = 1/6}, while formula (1.17) gives
{β1 = −1, β2 = 3, β3 = −3, β4 = 1}, which differ by factor 6; never-
theless, they can be equally used in (1.15)–(1.16). Figure 1.2 illustrates
four basis functions created from the given four nodes and each basis
is a polynomial of the third order. Note that using this basis allows to
interpolate exactly any cubic polynomial (and polynomial of degree less
than three), which is shown in figure 1.3.
Accuracy and some drawbacks of the global approximation are dis-
cussed in Appendix B, where it is shown that the strategy of increasing

1.5

0.5

-0.5
0 0.5 1 1.5 2 2.5 3

FIGURE 1.2: Lagrange basis functions corresponding to nodes {x1 =

0, x2 = 1, x3 = 2, x4 = 3}.
12 ■ Computational Framework for the Finite Element Method

2 3

2.5

1
2

1.5
0
1

0.5
-1

-2 -0.5
0 0.5 1 1.5 2 2.5 3 0 0.5 1 1.5 2 2.5 3

(a) (b)

FIGURE 1.3: Examples of interpolations with four nodes corresponding

to functions: (a) u(x) = 0.5(x − 1.5)3 ; (b) u(x) = 0.5(x − 1.5)4 . Here,
the dashed line is the source function and the solid line is the interpo-
lation. Cubic function is interpolated exactly; however, the fourth-order
polynomial is interpolated exactly only at nodes but not between nodes.

polynomial order to interpolate function having large number of inter-

polation nodes is not always a good approach. Below, we consider alter-
native approach representing piecewise polynomial interpolation.

1.3.2 Piecewise Polynomial Interpolation and the Finite Element

Approximation
Now, we turn our attention to the piecewise interpolation, which is ef-
fectively a number of localized interpolation stitched together. Let us
consider a set of n + 1 nodes defined on the interval [s0 , s1 ]

s0 = x1 < x2 < · · · < xn+1 = s1 ,

and subintervals ei = [xi , xi+1 ], i = 1, . . . , n. Then, a set of m + 1

different nodes are specified on each ei so that
(1) (2) (m+1)
xi = xi < xi < · · · < xi = xi+1 ,

and the total number of nodes can be easily calculated to be N =

nm + 1. Given a function u(x) ∈ C[s0 , s1 ], its approximation uh (x) ∈
C[s0 , s1 ] can be defined as follows:

uh (x) ∈ Gm , x ∈ ei , i = 1, . . . , n,
uh (xj ) = u(xj ), j = 1, . . . , N,
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 13

S
n
where h = max{hi , i = 1, . . . , n}. In other words, [s0 , s1 ] = ei and
i=1
function u(x) is interpolated on each subinterval ei through Lagrange
polynomial of the mth order.

Definition 1.6 Approximation uh (h) is called Lagrange spline, and

subintervals ei are called finite elements.

We can see that each finite element is associated with continuous

polynomial Gm , while the spline itself is a piecewise smooth continuous
function, which is smooth on each subinterval ei and continuous across
the interval [s0 , s1 ] (see figure 1.4).
Let us introduce a space of Lagrange splines of degree m

Hhm (s0 , s1 ) := {w ∈ C[s0 , s1 ] : w(x) ∈ Gm , x ∈ ei , i = 1, . . . , n}.

Space Hhm (s0 , s1 ) is considered to be an approximation of the space

H 1 (s0 , s1 ), and Hhm (s0 , s1 ) ⊂ H 1 (s0 , s1 ). Indeed, if w(x) ∈ Hhm (s0 , s1 )

1.5

0.5

-0.5
0 1 2 3 4 5 6

FIGURE 1.4: Lagrange basis functions corresponding to the spline with

two finite elements e1 = [0, 3] and e2 = [3, 6] having nodes {x1 = 0, x2 =
1, x3 = 2, x4 = 3, x5 = 4, x6 = 5, x7 = 6}. It is seen that spline at the
node x4 = 3 is continuous but not smooth function.
14 ■ Computational Framework for the Finite Element Method

then w(x) is a continuous and piecewise differentiable function which

means that w ∈ H 1 (s0 , s1 ). Analogously, approximations of the sub-
spaces W and W 0 associated with integral equation (1.8) can be intro-
duced.

Wh := {w ∈ Hhm (s0 , s1 ) : w(s0 ) = us0 },

Wh0 := {w ∈ Hhm (s0 , s1 ) : w(s0 ) = 0}.

Now, we have come to the state when we are ready to give a definition
of the FEM corresponding to the BVP (1.1)–(1.2).

Definition 1.7 The finite element approximation of the BVP (1.1)–

(1.2) is defined through the integral equation (1.8) where u = uh ∈ Wh
and v = vh ∈ Wh0 .

Zs1


cu′h vh′ + bu′h vh + auh vh dx + σuh (s1 )vh (s1 )
s0
Zs1
= f vh dx + µvh (s1 ). (1.18)
s0

Function uh is called an approximate solution to the BVP and the method

to find the function uh is called the finite element method (FEM).

Next, we are going to explain how to find the approximate solution

uh through reducing the problem to a linear system.

1.3.3 Linear System of the FEM

As shown above, the FEM of the BVP (1.1)–(1.2) solves equation (1.18)
for unknown function uh and with arbitrary vh . Introducing a basis in
Hhm (s0 , s1 ) allows reducing this problem to solving a linear system.
By considering the interval [s0 , s1 ] having n finite elements with m+1
nodes each, we obtain the total number of N = nm + 1 nodes, which
can be enumerated from 1 to N :

s0 = x1 < x2 < · · · < xN = s1 .

Each node xi can be associated with a Lagrange basis function

φi (x) ∈ Hhm (s0 , s1 ). Basis introduced in section 1.3.1 comprises smooth
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 15

1.5 1

0.8

0.6

0.5 0.4

0.2

-0.5 -0.2
0 1 2 3 4 5 6 0 1 2 3 4 5 6

(a) (b)

FIGURE 1.5: Examples of basis functions associated with Lagrange

spline having two finite elements e1 = [0, 3], e2 = [3, 6], and seven nodes
{x1 = 0, x2 = 1, . . . , x7 = 6}: (a) basis φ2 (x) corresponding to the node
x2 = 1; (b) basis φ4 (x) corresponding to the node x4 = 3.

functions while uh ∈ Hhm (s0 , s1 ) is a piecewise smooth Lagrange spline

and corresponding basis comprises piecewise smooth functions as well.
Functions φi (x) have a property of taking nonzero value only in the cor-
responding finite element interval and zero otherwise. A basis function
associated with a node, which is shared by two finite elements, is nonzero
in these two elements (see figure 1.5). As such, every φi (x) takes nonzero
values in either one or two finite elements. Recall that φi (xj ) = 0 if i ̸= j ,
and φi (xi ) = 1.
Let us denote function node values as ui = uh (xi ) and vi = vh (xi ),
then any functions uh ∈ Wh and vh ∈ Wh0 can be decomposed in terms
of basis φi (x) ∈ Hhm (s0 , s1 ) as following 3

X
N X
N
uh (x) = uj φj (x) = us0 φ1 (x) + uj φj (x),
j=1 j=2
(1.19)
X
N
vh (x) = vi φi (x), x ∈ [s0 , s1 ],
i=1

or
uh (x) = φT u, vh (x) = φT v, (1.20)
where u = {ui }N
i=1 , v = {vi }i=1 and φ = {φi (x)}i=1 are column-vectors.
N N

3
Note that v0 = 0 by definition of subspace Wh0 to which vh belongs.
16 ■ Computational Framework for the Finite Element Method

By substituting (1.20) into equation (1.18), we come to the expression4

Zs1


cv T φ′ (φ′ )T u + bv T φ(φ′ )T u + av T φφT u dx
s0
Zs1
T T
+ σv φ(s1 )φ(s1 ) u = f v T φdx + µv T φ(s1 ). (1.21)
s0

By introducing a matrix à ∼ (N × N ) and a vector F̃ ∼ (N × 1) having

components
Zs1


Ãij = cφ′i φ′j + bφi φ′j + aφi φj dx + σφi (s1 )φj (s1 ), (1.22)
s0

Zs1
F̃i = f φi dx + µφi (s1 ), (1.23)
s0

we can rewrite (1.21) in the form

v T Ãu = v T F̃ . (1.24)

Expression (1.24) can be seen as a sum of equations defined by the

system Ãu = F̃ with each equation being multiplied by vi (actually, we
can ignore the first equation since it corresponds to the value v1 ≡ 0).
Identity (1.24) is valid for arbitrary v , so by cancelling it out and by
splitting the vector u into unknown and known parts, we come to the
linear system

X
N
Ãij uj = F̃i − us0 Ãi1 , i = 2, . . . , N. (1.25)
j=2

From solving linear system (1.25), we obtain values for uj and the final
approximate solution to the BVP can be found using the first formula
in (1.19).
4
Here, we use the fact that

uh (x)vh (x) = φT uφT v = v T φφT u.

Finite Element Method for the One-Dimensional Boundary Value Problem ■ 17

Definition 1.8 Matrix à is called a global stiffness matrix and F̃ is a

global forcing vector.5 The system of linear equations (1.25) is called a
linear system of the FEM.

Elements of the stiffness matrix and forcing vector are calculated us-
ing expressions (1.22) and (1.23); however, it is impractical to use these
formulas directly. Below, we consider efficient method of assembling ma-
trices and derive corresponding computational algorithm for calculating
their elements.

EXERCISES
▶ Plot the Lagrange basis functions corresponding to the spline with
final elements e1 = [0, 1], e2 = [1, 2] and e3 = [2, 3] having nodes
{x1 = 0, x2 = 1, x3 = 2, x4 = 3} (linear basis functions).
▶ Deduce a linear system of the FEM corresponding to the following
BC:

(a) BC of the first order is specified at both points, s0 and s1 .

(b) BC of the third order is specified at both points, s0 and s1 .

1.4 ILLUSTRATIVE PROBLEM

One of the reasons of the success of the FEM is that it may be applied
to problems of great complexity; however, to use such problems for illus-
trative purpose tends to obscure the underlying ideas. In this section a
simple problem is solved. Note that this is not to suggest that the FEM
is the best method for solving such problems. In fact, there are other nu-
merical methods available which are superior. However, this particular
problem involves only small amount of algebra, and the algorithm ideas
come through quite well.
Consider the BVP having the form

−u′′ + u = x, x ∈ (0, 1), u(0) = 1, u′ (1) = 1, (1.26)

with known exact solution

e2−x + ex
u= + x. (1.27)
1 + e2
5
These naming come from the stiffness method (also known as the displacement,
method), which is used in matrix analysis of structures.
18 ■ Computational Framework for the Finite Element Method

It can be seen from comparing with generic BVP (1.1)–(1.2) that the
problem (1.26) corresponds to the coefficient values c(x) = 1, b(x) =
0, a(x) = 1, σ(x) = 0, µ(x) = 1. Consider a three-element discretiza-
tion of [0, 1] with nodes {x1 = 0, x2 = 1/3, x3 = 2/3, x4 = 1}.
     
1 1 2 2
e1 = 0, , e2 = , , e2 = ,1 . (1.28)
3 3 3 3
There are four basis functions associated with four interpolation nodes
which gives the following form of the approximate solution
   
1 2
uh = u(0)φ1 (x) + u φ2 (x) + u φ3 (x) + u(1)φ4 (x). (1.29)
3 3
Function value u(0) = 1 is known from the BC and the rest values,
u(1/2), u(2/3) and u(1) have to be found.
In each element there are just two nodes; hence, the interpolation
polynomials for each element must be linear. Basis functions associated
with each node are found from (1.11) and have the form
(
−3x + 1, 0 ≤ x ≤ 13 ,
φ1 (x) = 1
(1.30)
0, 3 < x < 0,


3x, 0 ≤ x ≤ 13 ,
φ2 (x) = −3x + 2, 31 ≤ x ≤ 23 , (1.31)

 2
0, 3 < x < 0,


3x − 1, 3 ≤ x ≤ 3,
1 2

φ3 (x) = −3x + 3, 23 ≤ x ≤ 1, (1.32)


 1
0, 1 < x < 3,
(
3x − 2, 23 ≤ x ≤ 1,
φ4 (x) = (1.33)
0, 1 < x < 23 .
Basis functions are shown in figure 1.6 and they have so-called hat
shapes. Note that φ1 and φ4 are nonzero over one element while φ2
and φ3 span two finite elements.
Now, elements of stiffness matrix (1.22) and forcing vector (1.23)
have to be found to solve linear FEM system (1.25). First, consider the
stiffness matrix in which elements are defined through
Z1


Ãij = φ′i φ′j + φi φj dx, i, j = 1, 2, 3, 4. (1.34)
0
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 19

0.8

0.6

0.4

0.2

0
0 0.2 0.4 0.6 0.8 1

FIGURE 1.6: Lagrange linear basis functions corresponding to the spline

with three finite elements e1 = [0, 1/3], e2 = [1/3, 2/3] and e3 = [2/3, 1]
having nodes {x1 = 0, x2 = 1/3, x3 = 2/3, x4 = 1}.

It is worth looking into expressions for every element to better under-

stand patterns and matrix formation.
1
Z1   Z3

2
Ã11 = φ′1 + (φ1 )2 dx = ·dx, (1.35)
0 0

1
Z1 Z3


Ã12 = Ã21 = φ′1 φ′2 + φ1 φ2 dx = ·dx, (1.36)
0 0

Z1


Ã13 = Ã31 = φ′1 φ′3 + φ1 φ3 dx = 0, (1.37)
0
20 ■ Computational Framework for the Finite Element Method

Z1


Ã14 = Ã41 = φ′1 φ′4 + φ1 φ4 dx = 0, (1.38)
0
1 2
Z1   Z3 Z3

2
Ã22 = φ′2 + (φ2 )2 dx = ·dx + ·dx, (1.39)
0 0 1
3

2
Z1 Z3


Ã23 = Ã32 = φ′2 φ′3 + φ2 φ3 dx = ·dx, (1.40)
0 1
3

Z1


Ã24 = Ã42 = φ′2 φ′4 + φ2 φ4 dx = 0, (1.41)
0
2
Z1   Z3 Z1

2
Ã33 = φ′3 + (φ3 )2 dx = ·dx + ·dx, (1.42)
0 1 2
3 3

Z1 Z1


Ã34 = Ã43 = φ′3 φ′4 + φ3 φ4 dx = ·dx, (1.43)
0 2
3

Z1   Z1

2
Ã44 = φ′4 + (φ4 ) 2
dx = ·dx. (1.44)
0 2
3

We can see that due to the symmetry of formula (1.34), index order is
not important and the stiffness matrix becomes symmetrical. In addi-
tion, elements Ã13 , Ã31 , Ã14 , Ã41 , Ã24 and Ã42 equal to zero since
corresponding, basis functions are non-overlapping, which gives zeroth
integrands (the only coupling occurs between nodes associated with the
same element). Also, the domain integrals over the interval [0, 1] can be
replaced by the sum of integrals taken separately over the finite elements
and only those integrals can be left which have non-zero values. Elements
Ã22 and Ã33 include two integrals because corresponding integrands are
non-zero over two finite elements. As a result, the stiffness matrix can
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 21

schematically be represented as follows:

 
∗ ∗ 0 0 Z3
1
Z3
2
Z1
∗ ∗ ∗ 0

à =   = ·dx + ·dx + ·dx
0 ∗ ∗ ∗
0 0 ∗ ∗ 0 1 2
3 3
     
∗ ∗ 0 0 0 0 0 0 0 0 0 0 (1.45)
∗ ∗ 0 0 0 ∗ ∗ 0 0 0 0 0
=  
0 0 0 0 + 0 ∗ ∗ 0 + 0 0
  
∗ ∗
0 0 0 0 0 0 0 0 0 0 ∗ ∗
= Āe1 + Āe2 + Āe3 .
Here, Āe1 , Āe2 and Āe3 are local to each finite element stiffness matrices,
which can be found separately and then summed up to obtain the matrix
Ã. One more important observation from (1.45) is that matrices are
sparse and à is a tridiagonal matrix.
Now, consider matrix Āe1 and calculate its first element integral
 
1
Z3

3x = x̂, dx = 1 dx̂,
Āe111 = ′ 2
((−3x + 1) ) + (−3x + 1) 2
dx =  d d dx̂
3
d 

dx = dx̂ dx = 3 dx̂
0
Z1 Z1

1
′ 2

1 28
= (3(1 − x̂) ) + (1 − x̂) dx̂ = 2
9 + (1 − x̂)2 dx̂ = .
3 3 9
0 0
(1.46)
Here, we introduce a new variable, x̂ = 3x, so that x ∈ [0, 1/3] → x̂ ∈
[0, 1], which results in basis functions to be φ1 (x̂) = 1− x̂ and φ2 (x̂) = x̂.
This transformation, as we see later, allows simplifying calculation of in-
tegrals and applying unified numerical integration methods (quadrature
rules). Similarly, integrals Āe121 and Āe221 can be found over x̂ space.
1
Z3


Āe121 = (−3x + 1)′ (3x)′ + (−3x + 1)(3x) dx
0
Z1 Z1
′

1
′ 1 53
= 3(1 − x̂) 3x̂ + (1 − x̂)x̂ dx̂ = (−9 + (1 − x̂)x̂) dx̂ = − .
3 3 18
0 0
(1.47)
Z1 Z1

1
1 28
Āe221 = (3x̂′ )2 + x̂2 dx̂ = 9 + x̂2 dx̂ = . (1.48)
3 3 9
0 0
22 ■ Computational Framework for the Finite Element Method

Likewise, change of variables for the element e2 , x̂ = 3x − 1, results

in x ∈ [1/3, 2/3] → x̂ ∈ [0, 1] and the basis functions are φ2 (x̂) =
1 − x̂, φ3 (x̂) = x̂. One important observation is that in the space x̂
basis functions φ2 (x̂) and φ3 (x̂) over the element e2 are identical to the
functions φ1 (x̂) and φ2 (x̂) over the element e1 . This leads to the fact
that the integrals over the element e2 are expected to be similar to those
over the element e1

Z1 Z1
′ 2

1
1 28
Āe222 = (3(1 − x̂) ) + (1 − x̂) dx̂ = 2
9 + (1 − x̂)2 dx̂ = .
3 3 9
0 0
(1.49)

Z1
1 53
Āe232 = (−9 + (1 − x̂)x̂) dx̂ = − . (1.50)
3 18
0

Z1

1 28
Āe332 = 9 + x̂2 dx̂ = . (1.51)
3 9
0

Finally, for the last element e3 we have x̂ = 3x−2 and x ∈ [2/3, 1] →

x̂ ∈ [0, 1] and φ3 (x̂) = 1 − x̂, φ4 (x̂) = x̂. Again, φ3 (x̂) and φ4 (x̂) over
e3 are identical to φ2 (x̂) and φ3 (x̂) over element e2 .

Z1

1 28
Āe333 = 9 + (1 − x̂)2 dx̂ = . (1.52)
3 9
0

Z1
1 53
Āe343 = (−9 + (1 − x̂)x̂) dx̂ = − . (1.53)
3 18
0

Z1

1 28
Āe443 = 9 + x̂2 dx̂ = . (1.54)
3 9
0

Once the local stiffness matrices Āe1 , Āe2 and Āe3 are found, the final
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 23

stiffness matrix can be assembled

 28   
9 − 18
53
0 0 0 0 0 0
− 53 28   0 28
− 53
0
à = 
 0
18 9 0 0 +  9 18 
0 0 0 0 − 53 18
28
9 0
0 0 0 0 0 0 0 0
   28  (1.55)
0 0 0 0 9 − 53
18 0 0
0  
0  − 18 53 56
− 18
53
0 
 0 0 9 
+ 0 28 53  = 
− 18   0 .
 0 9 − 53
18
56
9 − 53
18

0 0 − 53
18
28
9 0 0 − 53 28
18 9

For the forcing vector expression (1.23) gives

Z1
F̃i = xφi dx + φi (1), i = 1, 2, 3, 4. (1.56)
0

Following the same logic as for stiffness matrix, let us consider individual
integrals and deduce vector formation pattern.
1
Z1 Z3
F̃1 = xφ1 dx + φ1 (1) = xφ1 dx, (1.57)
0 0

1 2
Z1 Z3 Z3
F̃2 = xφ2 dx + φ2 (1) = xφ2 dx + xφ2 dx, (1.58)
0 0 1
3

2
Z1 Z3 Z1
F̃3 = xφ3 dx + φ3 (1) = xφ3 dx + xφ3 dx, (1.59)
0 1 2
3 3

Z1 Z1
F̃4 = xφ4 dx + φ4 (1) = xφ4 dx + 1. (1.60)
0 2
3

Here, we take into account the fact that only φ4 (1) is non-zero with the
unity value. By splitting domain integral into individual integrals over
the finite elements, we come to the following schematic representation
24 ■ Computational Framework for the Finite Element Method

for the forcing term

 
∗ Z3
1
Z3
2
Z1
∗
F̃ =  
∗ = ·dx + ·dx + ·dx + φ4 (1)
∗ 0 1 2
3 3
          (1.61)
∗ 0 0 0 0
∗ ∗ 0 0  
=        e1 e2 e3 0
0 + ∗ + ∗ + 0 = F̄ + F̄ + F̄ + 0 .
0 0 ∗ 1 1
Vectors F̄ e1 , F̄ e2 and F̄ e3 are considered to be local to each element
forcing vectors which can be found separately. Note that local vectors
are sparse while the vector F̃ is dense. By introducing new variables x̂
for each finite element (see above), corresponding vector elements can
be calculated as follows:
1
Z3 Z1
1 1
F̄1e1 = x(−3x + 1)dx = x̂(1 − x̂)dx̂ = . (1.62)
3 54
0 0
1
Z3 Z1
1 2 1
F̄2e1 = 2
3x dx = x̂ dx̂ = . (1.63)
3 27
0 0

2
Z3 Z1
1 2
F̄2e2 = x(−3x + 2)dx = (1 + x̂)(1 − x̂)dx̂ = . (1.64)
9 27
1 0
3

2
Z3 Z1
1 5
F̄3e2 = x(3x − 1)dx = (1 + x̂)x̂dx̂ = . (1.65)
9 54
1 0
3

Z1 Z1
1 7
F̄3e3 = x(−3x + 3)dx = (2 + x̂)(1 − x̂)dx̂ = . (1.66)
9 54
2 0
3

Z1 Z1
1 4
F̄4e3 = x(3x − 2)dx = (2 + x̂)x̂dx̂ = . (1.67)
9 27
2 0
3
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 25

Assembling the final forcing vector gives

1       1
54 0 0 0 54
 1   272   0  0  1 
 
F̃ =  27  +   +  7  +   =  9  .
 0   5   54  0  2  (1.68)
54 9
4 1
0 0 27
31
27

From (1.55) and (1.68), the equations can be written in the form
 28   1
9 − 53
18 0 0 1
54
− 53 56
− 53  u 1   1 
 18 9 18 0   3
  9 
 53   2  =  , (1.69)
 0 − 18
53 56
9 − 18  u 3   29 
0 0 − 53
18
28
9
u(1) 31
27
or   53   
28  − 18 0
9    56     53 
− 53 
 18  1  9  2 − 18 
 0  + u   + u  
3 − 53  3  56 9 
18
0 0 − 53
18
   1  (1.70)
0 54
 0   9
1 
+u(1)  
53 
− 18 =  .
 29 
28 31
9 27
Note that BC specifies u(0) = 1 and there are only three unknowns left
in the system (1.70). Then, moving first vector in (1.70) to the right
hand side of the equation and removing first row in the entire system
(see (1.25)) we come to the final linear system for the function values
 56   1
  55 
− 53 0 u 3
9
 53
18
53  


2 
18
2
− 18 56
9 − 18   u 3  =  9 . (1.71)
0 − 53
18
28
9 u(1) 31
27

Solving equations (1.71) gives

   
1 2
u = 1.129, u = 1.345, u(1) = 1.646. (1.72)
3 3
From the expression (1.27) the exact solutions at these points are
1.131, 1.351 and 1.648, respectively. It can be seen that FEM solution
approximates the exact one quite well.
26 ■ Computational Framework for the Finite Element Method

1.5 ALGORITHMS OF THE FINITE ELEMENT METHOD

Below, we are going to compose algorithms needed for programming
implementation of the FEM using from top to bottom approach with in-
creasing granularity of details. We start with an algorithm for composing
system (1.25), then, assembling matrices is considered, and finally, ex-
planation of how to calculate elements of these matrices is given. Each
subsequent step in the hierarchy of algorithms increases granularity of
the previous one by introducing more details.

1.5.1 Composing Linear System of the FEM

We have seen that solving BVP using FEM effectively comes down to
solving the linear system (1.25) which, in turn, is defined by the matrix
à and the vector F̃ . It is straightforward to create a generic algorithm
for composing FEM linear system (1.25).

Algorithm 1 Composing FEM linear system

1. Split the interval [s0 , s1 ] into n finite elements each having m + 1

points.

2. Assemble matrix à ∼ (N × N ) and vector F̃ ∼ (N × 1) where

N = nm + 1.

3. Incorporate Dirichlet BC, u(s0 ) = us0 , by doing following:

• Delete the first row of the matrix à and the first element of
the vector F̃ .
• Calculate F̃ = F̃ − us0 Ã1 , where Ã1 is the first column of
the matrix Ã.
• Delete the first column of the matrix Ã.

4. Solve the system Ãu = F̃ and find N − 1 node values of u.

5. Append us0 to the vector u.

There are two points in this algorithm which have to be clarified,

namely, how to assemble matrices and how to solve a linear system.
Regarding a method of solving linear system, we will discuss it later
that this is a sparse linear system which possess a unique, well-defined
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 27

solution, which allows applying any standard linear solver. As to the

method of assembling matrices, this is crucial feature in the context of
the FEM, since this is a computationally expensive part which affects
effectiveness of the entire FEM (especially when N is large). Next we
focus on the assembling algorithm.

1.5.2 Assembling Global Matrices

Let us consider the stiffness matrix (1.22). It is seen from (1.22) that the
matrix à is a square one and can be viewed as a sum of two matrices,
namely à = A + S , where
Zs1


Aij = cφ′i φ′j + bφi φ′j + aφi φj dx,
i, j = 1, . . . , N. (1.73)
s0
Si,j = σφi (s1 )φj (s1 ),

Here, N = nm + 1 and the matrix S is defined by the boundary condi-

tions. Recall that the interval [s0 , s1 ] is split by n + 1 points into n finite
S
n
elements each having m + 1 points so that [s0 , s1 ] = el . As such, the
l=1
integral in (1.73) can be represented through the sum of local integrals
over the finite elements el
n Z
X

Aij = cφ′i φ′j + bφi φ′j + aφi φj dx. (1.74)
l=1 el

Now, let us consider more closely an integral over a local finite el-
ement el and determine only those basis functions which are nonzero
over the element el . It is easy to see that lth element spans the points
xm(l−1)+1 , . . . , xml+1 , or, by introducing a local numeration index β =
1, . . . , m + 1 and a global starting index notation nl = m(l − 1), we can
write that xnl +β ∈ el . As a result, φnl +β are the basis functions associ-
ated with el which are nonzero over this element. These nonzero values
form a matrix Āl ∼ ((m + 1) × (m + 1)) with elements

xnZ
l +m+1


Ālαβ = cφ′nl +α φ′nl +β + bφnl +α φ′nl +β + aφnl +α φnl +β dx,
xnl +1

α, β = 1, . . . , m + 1. (1.75)
28 ■ Computational Framework for the Finite Element Method

Definition 1.9 Matrix (1.75) is called a local stiffness matrix of the lth
finite element.

Introducing a local stiffness matrix allows us in representing global

stiffness matrix through a sum of local ones. By inspecting (1.74) we
observe that Aij has zero value if φi and φj are nonoverlapping functions
(|i − j| > m), and nonzero value otherwise. Moreover, the sum (1.74)
has single nonzero summand if j ̸= j (|i − j| < m) and two summands
if i = j . As such, elements Aij can be expressed as
X
Aij = Ālαβ .
l,α,β:i=nl +α,j=nl +β

To incorporate all zero elements as well, let us extend a local stiffness

matrix by introducing matrix Al ∼ (N × N ) which is a matrix with zero
value elements except of a block corresponding to the finite element el
and defined by the local stiffness matrix (1.75)

Alnl +α,nl +β = Ālαβ , α, β = 1, . . . , m + 1. (1.76)

Definition 1.10 Matrix (1.76) is called an extended local stiffness ma-

trix corresponding to the lth element.

Summarizing, we can see that the global stiffness matrix, A, can be

obtained from summation of the extended local stiffness matrices, Al ,
which, in turn, are calculated through the local matrices (1.75).
X
n
A= Al .
l=1

Analogously, global forcing vector is a sum of two vectors, F̃ = F +

M , where (see (1.23))
Zs1
Fi = f φi dx, Mi = µφi (s1 ), i = 1, . . . , N. (1.77)
s0

By introducing a local forcing vector, F̄ ∼ ((m + 1) × 1), through

xnZ
l +m+1

F̄αl = f φnl +α dx, α = 1, . . . , m + 1, (1.78)

xnl +1
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 29

and extended local forcing vector, F ∼ (N × 1), as following

Fnl l +α = F̄αl , α = 1, . . . , m + 1, (1.79)

we come to the expression

X
n
F = F l.
l=1

Note that the extended local forcing vector, F l , contains all zero elements
except of values defined by the local forcing vector (1.79).
Matrix S and vector M result from the boundary conditions and
they are specified at the single point s1 . Since φi (xj ) = δij and s1 = xN ,
then each of S and M has the single nonzero value, namely, SN N = σ
and MN = µ.
As a result, we come to the algorithm for assembling stiffness matrix
and forcing vector.

Algorithm 2 Assembling global matrices

1. Set A = 0 and F = 0, where A ∼ (N × N ) and F ∼ (N × 1).

2. For each finite element index l = 1, . . . , n do:

• Calculate global index nl = m(l − 1).

• Calculate elements of the local stiffness matrix Āl ∼
(m + 1, m + 1).
l
• Calculate elements of the local forcing vector F̄ ∼ (m+1, 1).
• For each local index α, β = 1, . . . , m + 1 do:
(a) Anl +α,nl +β = Anl +α,nl +β + Ālαβ .
(b) Fnl +α = Fnl +α + F̄αl .

3. Incorporate BC at the point s1 by assigning:

• AN N = AN N + σ .
• FN = FN + µ.

Later, we create a programming code implementing this algorithm

and discuss it in details. One problem which has not been illuminated
30 ■ Computational Framework for the Finite Element Method

so far is how to calculate elements of local matrices. Below, we turn our

attention to this problem and deduce an algorithm for calculating these
elements.

1.5.3 Calculating Elements of the Local Matrices

We start with a simpler case of calculating elements of the local forc-
ing vector defined by the integral (1.78) for the lth finite element. By
inspecting expression (1.78) we observe that the integrand depends on
the local basis functions φnl +α having form of Lagrange polynomial

Y
m+1
x − xnl +j
φnl +α (x) = , x ∈ [xnl +1 , xnl +m+1 ], (1.80)
xnl +α − xnl +j
j=1,j̸=α

which depends on the global index nl . We are aimed to transform ex-

pression (1.80) to the one which is independent on the global index so
that to obtain invariant basis expression across all finite elements. To
achieve this, let us introduce a local variable, x̂, and transformation as
follows:
x − xnl +1
x̂ = , x = xnl +1 + x̂hl ,
hl (1.81)
dx = hl dx̂, hl = xnl +m+1 − xnl +1 .
It can be seen the expression (1.81) specifies linear transformation so
that xnl +j → x̂j , or

xnl +1 , . . . , xnl +m+1 → 0 = x̂1 , . . . , x̂m+1 = 1,

and el = [xnl +1 , xnl +m+1 ] → ê = [0, 1], ∀nl . As a result, any finite
element is transformed into a canonical, or basis, element of the unity
length. Moreover, substitution (1.81) into (1.80) gives

Y
m+1
x̂ − x̂j
φnl +α (x) = φnl +α (xnl +1 + x̂hl ) = = φ̂α (x̂), (1.82)
x̂α − x̂j
j=1,j̸=α

where basis functions φ̂α are now expressed in terms of the local variable
x̂. If we denote fˆ = f (xnl +1 + x̂hl ), then integral (1.78) can be rewritten
as
Z1
F̄αl = hl fˆφ̂α dx̂, α = 1, . . . , m + 1. (1.83)
0
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 31

Integral (1.83) can be evaluated exactly in a limited number of cases

(linear φ̂α or fˆ = const), and, generally speaking, we have to apply
a numerical approximation technique to calculate (1.83). We utilize a
quadrature rule6 which gives
X
q
F̄αl ≈ hl γ̂k fˆ(dˆk )φ̂α (dˆk ), 0 ≤ dˆk ≤ 1, α = 1, . . . , m + 1, (1.84)
k=1

where q is a number of quadrature nodes, γ̂k and dˆk are quadrature

weights and nodes, respectively. Currently, we do not look at the con-
struction of a particular rule leaving this task for the next section. The
main result is that we have defined a numerical method allowing calcu-
lation of the local forcing vector through the formula (1.84).
In a similar way, computation of the local stiffness matrix can be
reduced to the numerical calculations through the approximate quadra-
ture rule. By using transformation (1.81) and introducing functions â, b̂
and ĉ, integral (1.75) reduces to

Z1
Ālαβ = (h−1 ′ ′ ′
l ĉφ̂α φ̂β + b̂φ̂α φ̂β + hl âφ̂α φ̂β )dx̂, α, β = 1, . . . , m + 1.
0

Here, we use the fact that φ(x)′ = φ̂(x̂)′ /hl . Thereby,

X
q
Ālαβ ≈ γ̂k (h−1 ′ ′ ′ ˆ
l ĉφ̂α φ̂β + b̂φ̂α φ̂β + hl âφ̂α φ̂β )(dk ),
k=1
α, β = 1, . . . , m + 1. (1.85)

Expressions (1.84) and (1.85) define approximate numerical calcula-

tions of the local matrices. Intuitively, it is clear that the higher precision
of quadrature approximation, the higher accuracy of the FEM. Below,
we imply that integral calculations are performed approximately and the
symbol ‘≈’ is substituted by ‘=’ to avoid complicated notations.
Let us rewrite expressions (1.84) and (1.85) in matrix forms. To
6
A quadrature rule is an approximation of the definite integral of a function,
f (x), stated as a weighted sum of function values at specified points, xi ,
Z1 X
q
f dx ≈ γk f (xk ).
0 k=1
32 ■ Computational Framework for the Finite Element Method

achieve this, we introduce complementary matrices Êkα = φ̂α (dˆk ) and

D̂kα = φ̂′α (dˆk ) having dimension q × (m + 1). With the help of these
matrices, formula (1.84) for the local forcing vector takes the matrix
form
l l
 T
l
F̄ = Ê T F̂ , F̂ = hl γ̂1 fˆ(dˆ1 ), . . . , γ̂q fˆ(dˆq ) . (1.86)

One interesting observation following from (1.86) is that in case of hl =

const ∀l, and when distribution of quadrature nodes, dˆk , remains the
same across all finite elements, then the local forcing vector is calculated
only once (all local vectors are equal to each other).
Now, it is easy to represent calculations of the local stiffness matrix
(1.85) in the form of matrix expression

Āl = D̂T Ĉ l D̂ + Ê T B̂ l D̂ + Ê T Âl Ê,

where
 
l ˆ
 = hl diag γ̂1 â(d1 ), . . . , γ̂q â(dq ) , ˆ
 
B̂ l = diag γ̂1 b̂(dˆ1 ), . . . , γ̂q b̂(dˆq ) ,
 
Ĉ l = h−1
l diag γ̂ 1 ĉ( ˆ
d1 ), . . . , γ̂ q ĉ( ˆ
dq ) .

Generally speaking, matrices Ê and D̂ can be associated with inter-

polating matrix and differentiating matrix, respectively. Indeed, for the
function uh (x) we have local representation for x ∈ el (see(1.20))

X
m+1 X
m+1
uh (x) = φnl +α (x)unl +α = φ̂α (x̂)unl +α = φ̂(x̂)T ul ,
α=1 α=1
u = {unl +α }m+1
l
α=1 , x ∈ el .

For any given point x = dk ∈ el (for example, dk is a quadrature node),

we obtain that uh (dk ) = φ̂(dˆk )T ul , where φ̂(dˆk )T is the k th row of the
matrix Ê . Consequently, uh (d) = Êul , where d and uh are the vec-
tors of points and function values to be interpolated. As such, matrix
Ê can be viewed as interpolating matrix. By performing similar rea-
soning we observe, that u′h (d) = h−1 l D̂ul , and the matrix D̂ can be
associated with differentiating operation. These matrices can be used
not only for calculation of stiffness matrix, but when plotting functions
uh and u′h .
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 33

Algorithm 3 Calculating local matrices

1. Calculate the element’s length, hl = |el |, and a vector of the inter-

polation nodes on the basis element, x̂α = h−1l (xnl +α −xnl +1 ), α =
1, . . . , m + 1.

2. Specify basis functions:

Y
m+1
x̂ − x̂j
φ̂α (x̂) = ,
x̂α − x̂j
j=1,j̸=α

3. Specify a vector of weights, γ̂ ∼ (q × 1), and a vector of nodes,

dˆ ∼ (q × 1), for the quadrature rule defined on the basis element
(0 ≤ dˆk ≤ 1).

4. Calculate the vector d = xnl +1 + hl dˆ.

5. Calculate matrices and a vector:

Êk,α = φ̂α (dˆk ),

D̂k,α = φ̂′ (dˆk ),
α
l
 = hl diag (γ̂1 a(d1 ), . . . , γ̂q a(dq ))
B̂ l = diag (γ̂1 b(d1 ), . . . , γ̂q b(dq )) ,
Ĉ l = h−1
l diag (γ̂1 c(d1 ), . . . , γ̂q c(dq )) ,
l
F̂ = hl (γ̂1 f (d1 ), . . . , γ̂q f (dq ))T .

6. Calculate the local stiffness matrix and the local forcing vector:
 
Āl = D̂T Ĉ l + Ê T B̂ l D̂ + Ê T Âl Ê,
l l
F̄ = Ê T F̂ .
34 ■ Computational Framework for the Finite Element Method

Summarizing, we come to the algorithm for calculating elements of

the local stiffness matrix and forcing vector corresponding to the lth
finite element.
As we can see, this is the very stage where basis functions come into
play, and this algorithm depends on the choice of particular quadrature
rule. It is worth noting that if the final elements are of the same length
having the same quadrature and interpolation node distribution, then
matrices Ê and D̂ have to be calculated only once.
Quadrature nodes and weights distribution have to meet certain cri-
teria to be suitable for numerical integration with appropriate accuracy.
Below, we discuss some strategies of choosing nodes distribution.

1.6 QUADRATURE RULES

As we have seen, calculating elements of FEM matrices includes numer-
ical integration which can be done through applying some quadrature
rule.
Z1 X
q
ˆ
f dx̂ ≈ γ̂k fˆ(dˆk ).
0 k=1

Choosing particular values of number q , node values, dˆk , and weights,

γ̂k , results in different quadrature rules. Below, we utilize two types of
quadrature, namely, Gaussian quadrature and Lobatto quadrature rule.
Appendix C gives some theoretical background for these rules where
basic explanations and examples are given. In addition, theory on cal-
culations of weights and nodes using orthogonal polynomials is given in
Appendix D. Below, we use expressions without detailed explanations
which can be found in the given appendices.
First, we consider Gaussian quadrature for integrals over the in-
terval [−1, 1] which is the most common and well-studied domain of
integration. Integration over the interval [0, 1] can be obtained from
the integration over the interval [−1, 1] through the transformation
x̂ = 1/2 + x̃/2, x̃ ∈ [−1, 1]

Z1 Z1
1X ˜ ˜ X
q q
1
fˆdx̂ = f˜dx̃ ≈ γ̃k f (dk ) = γ̂k fˆ(dˆk ),
2 2
0 −1 k=1 i=1

1 1 d˜k
γ̂k = γ̃k , dˆk = + .
2 2 2
It is worth mentioning that Gaussian quadrature is a type of quadrature
formula, which has the highest order of precision with the given number
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 35

of nodes, q , which is equal to 2q − 1. Nodes, d˜k , are the roots of Legendre

polynomials, Lq (x̃), of order q . In general, nodes and weights can be
calculated using eigenvalue decomposition of the following square matrix
 
0 β1
β1 0 β2  j
  βj = p ,
 .. .. ..  4j 2 − 1
Q= . . . , (1.87)
 
 βq−2 0 βq−1  j = 1, . . . , q − 1.
βq−1 0

If Q = U ΛU −1 , where Λ = diag(λ1 , . . . , λq ) is a diagonal matrix of

ordered eigenvalues and U is a matrix of corresponding eigenvectors, then
Gaussian quadrature nodes are d˜k = λk and the weights are γ̃k = 2U1k 2 .

One important observation about Gaussian quadrature is that there

is no guarantee that the set of nodes contains boundary points, −1 or 1.
In order to include the end points of the integration, Lobatto quadrature
can be used
Z1 X
q−1
f˜dx̃ ≈ γ̃1 f˜(−1) + γ̃k f˜(d˜k ) + γ̃q f˜(−1).
−1 k=2

This type of quadrature has the precision of order 2q − 3 where quadra-

ture nodes are roots of the polynomial (1 − x̃2 )L′q−1 (x̃). Value of
nodes and weights can be found through the eigenvalue decomposition
Q = U ΛU −1 of the matrix
 
0 β1 s
β1 0 β2 
  j(j + 2)
 .. .. ..  βj = ,
Q= . . .  , (2j + 1)(2j + 3)
 
 βq−2 0 βq−3  j = 1, . . . , q − 3.
βq−3 0

Nodes of Lobatto quadrature are d˜ = {−1, λi , 1} and weights to be

 2

2 4U1i 2
γ̃ = , , , i = 1, . . . , q − 2,
q 2 − q 3(1 − λi ) q 2 − q

where λi and Ui are the eigenvalues of matrix Q. Lobatto quadrature

nodes can be chosen to be interpolation nodes on the basis element. In
this case, q = m + 1 and x̂α = dˆα = (1 + d˜α )/2.
36 ■ Computational Framework for the Finite Element Method

1.7 DEFINING PARAMETERS OF THE FEM

From the previous sections we have learned that there are three param-
eters defining particular FEM scheme: the number of finite elements, n,
the degree of approximating polynomial, m, and the number of quadra-
ture nodes on the basis element, q . To build an efficient FEM imple-
mentation, it is worth analysing influence of these parameters since they
affect property of stiffness matrices and accuracy of the FEM. Below we
discuss various points which need to be taken into account when creating
particular FEM scheme.
Structure of the stiffness matrix. Numbers n and m determine
uniquely the structure of the global stiffness matrix, A, in terms of dis-
tribution of the non-zero entries. If n ≫ m, then the matrix A is the
sparse one containing large number of zeroth elements. Contrarily, when
n is small but m is large, then the matrix A is considered to be dense
(see figure 1.7).
The total number of non-zeroth elements is equal to n(m + 1)2 −
(n − 1), and this number estimates computer memory consumption and
computational costs to solve linear system. It is seen that costs increase
linearly with n but have quadratic growth with m.
Accuracy of the solution and choice of parameters n and m.
Numbers n and m influence accuracy of the approximate solution uh . Let
us briefly illustrate this influence. Assuming that numerical integration
is not used (all integrals are calculated exactly), it is stated in the FEM

21 21
20 20
19 19
18 18
17 17
16 16
15 15
14 14
13 13
12 12
11 11
10 10
9 9
8 8
7 7
6 6
5 5
4 4
3 3
2 2
1 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

(a) (b)

FIGURE 1.7: Examples of non-zero entries distribution for the global

stiffness matrix: (a) n = 5, m = 4. Matrix has 121 non-zero elements;
(b) n = 2, m = 10. Matrix has 241 non-zero elements.
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 37

theory that
Zs1  k 2 !
hk−1 d u
∥u − uh ∥H 1 ≤ C k−1 ∥u∥H k , ∥u∥2H k = u2 +  k  dx.
m dx
s0

Here C is a constant, u is the exact solution, 2 ≤ k ≤ min{m + 1, r}

where number r is defined from the criteria ∥u∥H r < ∞. In connection to
this, two cases are of interest to us, namely, (a) solution is not sufficiently
smooth function, and r < (m + 1); (b) solution is quite smooth function,
and r ≫ (m + 1). By choosing highest value for k , we obtain estimations
 r−1   m
h h
(a) ∥u − uh ∥H 1 = O r−1
, (b) ∥u − uh ∥H 1 = O .
m mm
We can see that parameter m affects the solution accuracy differently.
To clarify this, let us consider a simplified example when all elements
are of the same length, h = (s1 − s0 )/n. In this case, h = O(n−1 ) and
we come to the estimations
   
1 1
(a) ∥u − uh ∥H 1 = O , (b) ∥u − uh ∥H 1 = O .
(nm)r−1 (nm)m
(1.88)
Consequently, case (a) corresponds to the power growth of accuracy
with respect to both parameters, n and m, unlike the case (b) where
only increase of n leads to power growth of accuracy while increasing m
results in exponential growth.
Thereby, it could be recommended three strategies of how to choose
parameters m and n:
1. Having chosen small m (practically, 1 ≤ m ≤ 5), the desired accu-
racy is reached by increasing n (decreasing h).
2. Having chosen small n (it is allowed to take n = 1 which corre-
sponds to the single finite element ), the desired accuracy is reached
by increasing m (practically, m = 5, . . . , 50, . . . ).
3. Polynomial degree, m, is not fixed for all elements and can vary.
This strategy is useful when solution behaves differently on the in-
terval [s0 , s1 ]. If there is a region with rapidly increasing derivative
of the solution, then within this region the value of m is chosen
to be fixed and small, but elements are refined (n increases). The
value of n in the rest of interval is fixed but the polynomial degree
increases.
38 ■ Computational Framework for the Finite Element Method

It is worth noting that the Euclidean condition number of the stiff-

ness matrix, A, is of order O(h−2 ), so refining finite elements is sensible
to some extent. Extremely small elements leads to solving ill-conditioned
linear system.
In addition, following circumstance has to be taken into account
when choosing elements distribution. In practise, differential equation
coefficients could be functions having singularities (discontinuities of a
function or its derivative) at particular points. In this case, it is advisable
to take these points to be boundary nodes of finite elements, that is xnl .
As a result, all functions would be smooth within each finite element and
this suffices to obtain desired accuracy of the FEM; otherwise, accuracy
decreases significantly.
Accuracy of the solution and distribution of points within
finite elements. Vector of points within a basis element (0 =
x̂1 , . . . , x̂m+1 = 1) defines distribution of nodes for each finite element.
Theoretically (in the exact computer arithmetic), solution uh does not
depend on the way of choosing distribution of these points. Practically
(in floating point computation), this distribution plays an important
role, particularly, it affects conditional number of the stiffness matrix.
When the value of m is small (m < 7), nodes x̂i can be evenly spaced
with a constant step. However, when the value of m is relatively large,
it is recommended to choose nodes x̂i so that they are roots of some
orthogonal polynomial of the order m + 1. For instance, a good choice
would be Chebyshev polynomials or Legendre polynomials.
Quadrature rule and choice of quadrature nodes distribu-
tion. Theory states (and results of FEM practical calculation confirm)
that the following conditions should be satisfied for a quadrature rule:

• quadrature weights are positive, γ > 0,

• number of nodes q ≥ m,

• a quadrature has to be exact for polynomials of degree 2m − 1 and

higher7
7
A quadrature rule is called exact for polynomials of degree m, Pm (x), if it yields
exact values of integrals for polynomials of that degree
Zs1 X
q
Pm (x)dx = γk Pm (xk ).
s0 k=1

.
Finite Element Method for the One-Dimensional Boundary Value Problem ■ 39

Practically, there are two quadrature rules meeting these criteria,

namely, Gaussian quadrature having number of nodes q ≥ m, and Lo-
batto quadrature with q ≥ (m + 1). There is a possibility to obtain
quadrature nodes, dˆi , which coincide with interpolation nodes on the
basis elements, x̂i , and q = m + 1. In this case, Lobatto quadrature
rule is used for numerical integration since the nodes of this rule include
endpoints of the basis element and, in addition, the nodes are roots of
orthogonal Legendre polynomial which, in turn, can be taken as nodes
of interpolating polynomials on the basis element.
 CHAPTER 2

Programming
One-Dimensional Finite
Element Method for the
Linear Boundary Value
Problem

n this chapter, we are going to compose MATLAB⃝ R

codes for finding
I numerical solution to the BVP using FEM described in the previous
chapter. In addition, algorithm implementation for calculating solution
first derivative and solution error will be considered.
Before we start coding FEM algorithm, let us outline the strategy of
how it is going to be done. Programming implementation will have a form
of library with set of functions with code for particular numerical method
or piece of algorithm. We are aimed to group steps of the FEM algorithms
into functions according to their logic. For example, from generic high-
level FEM algorithm 1 follows that it is convenient to have at least four
stand-alone functions for each step of the algorithm, and probably some
complementary helper functions as well. The approach we consider below
is bottom to top which is opposed to top to bottom consideration in
chapter 1. We will start with programming quadrature rules and splitting
interval into finite elements; then we will look into coding assembling

DOI: 10.1201/9781003265979-2 41
42 ■ Computational Framework for the Finite Element Method

stiffness matrices and BC. As a last step, the high-level main function
will be considered which implements logic of algorithm 1.
The main data structure used in the code implementation is a matrix,
so it is assumed that a reader is familiar with basic skills of matrix
manipulation commands in MATLAB and Python. There is, however, a
special case of matrices which we will discuss in detail, namely, sparse
matrices. As we have seen from chapter 1, FEM results in matrices with
sparse structure which we need to reflect in coding.

2.1 SPARSE MATRICES IN MATLAB⃝R

The basic structure to be utilized in the implementation of FEM algo-
rithm is a sparse matrix. The main feature of sparse matrices is the com-
pact data representation when zeroth elements are ignored and not kept
in memory. Operations with sparse matrix in MATLAB are similar to
operations with full (dense) matrix. The difference is that sparse matrix
should be created with specification sparse(). There are three methods
to create a sparse matrix in MATLAB.

1. Creating a sparse matrix from the full one. In this case the argu-
ment of the function sparse() is a dense matrix and returning value
is a sparse matrix with the shape and values of the dense one. For
example,
B =[1 3 0
0 4 0
2 0 5 ] ;
A = sparse (B)
A = (1 ,1) 1
(3 ,1) 2
(1 ,2) 3
(2 ,2) 4
(3 ,3) 5

The sparse matrix is represented in the form of indices of nonzero

elements and corresponding values. As a result we see arrays of
indices (i,j) and values.

2. Creating a sparse matrix by elements. The previous matrix can be

specified as follows
A = sparse (3 ,3) ;
 Programming One-Dimensional Finite Element Method ■ 43

A(1 ,1)=1; A(3 ,1)=2; A(1 ,2)=3;

A(2 ,2)=4; A(3 ,3)=5;

Here, we specify matrix dimensions as arguments of the function

sparse() followed by assigning values of matrix elements.

3. Creating a sparse matrix from the arrays of indices and values.

For example, the next code creates the matrix A from previous
examples.
% indices
i = [ 1 3 1 2 3 ] ;
j = [ 1 1 2 2 3 ] ;
% values
v = [ 1 2 3 4 5 ] ;
% matrix
A = sparse (i,j,v ,3 ,3) ;

In general case, values in vectors of indices could repeat and in this

case the corresponding values are summed up. This allows forma-
tion of the matrix A by accumulating its elements. For example,
the matrix A can be specified as
i = [ 1 1 3 1 2 3 ] ;
j = [ 1 1 1 2 2 3 ] ;
v = [ 0.3 0.7 2 3 4 5 ] ;
A = sparse (i,j,v ,3 ,3) ;

Here A(1,1)=0.3+0.7. It is worth noting that (i,j) could be specified

as two-dimensional matrices. In this case, function sparse() treats
them as column vectors. In addition, the value v could be a scalar
and it would be automatically extended to the vector of the cor-
responding length with all elements of v.

The third method is preferable for creating large sparse matrices

since it is more generic and it reflects the way in which matrices are
represented in MATLAB internally.

2.2 INPUT DATA STRUCTURES

Let us define input data structure to be used in MATLAB implementa-
tion. Particular BVP problem is defined by:
44 ■ Computational Framework for the Finite Element Method

(1) numbers s0 and s1 specifying boundary;

(2) functions c(x), b(x), a(x) and f (x) specifying BVP coefficients;

(3) type of boundary conditions at the points s0 and s1 .

There is nothing special about item (1) while representation of (2) and
(3) in terms of MATLAB structures needs to be clarified. Functions in
MATLAB can be defined either through anonymous inline declaration
f = @(x) sin(x)
or using stand-along .m file containing function definition
function y=f(x)
y=sin(x);
end

Whenever it is possible, we strive to use vectorized computations which

are much more efficient in terms of computational costs. Having a vector
x = [x1,. . . ,xn],
function call y = f(x) returns a vector
y = [f(x1),. . . ,f(xn)]
and we operate with variables being vectors rather than with individual
components.
Considering item (3), we can use matrix to specify boundary condi-
tions. Let us introduce a matrix bc having dimension 2 × 3 which packs
all boundary condition data. First row corresponds to BC at the point
s0 and the second row contains data for the boundary point s1. First
column indicates type of BC while second and third columns contain
corresponding data values. For example, bc(1,:)=[1,0,u s0] is for the BC
of the first type at the point s0 and bc(2,:)=[3,sigma,mu] is for the BC of
the third type at the point s1.
Below, MATLAB codes for algorithm implementation will be given
in reverse order with regards to above considered BEM algorithmic steps,
namely, we start with coding quadrature rules and finish with solving
linear system of the BEM. All implementations will be based on derived
expressions.

2.3 CODING QUADRATURE RULES

Nodes and weights of Gaussian quadrature on arbitrary interval [s1,s2]
can be calculated using listing 2.1. Function GaussQuad() inputs the num-
ber of points, n, left boundary of the interval, s0, right boundary, s1,
 Programming One-Dimensional Finite Element Method ■ 45

and returns a pair of vectors, d and w, which are quadrature nodes and
weights accordingly. Here, quadrature nodes are zeroes of Legendre poly-
nomial. The function can take either three or one argument and in case
of a single argument, it is assumed the nodes are sought on the interval
[−1,1]. This logic is implemented in lines 2–4 with MATLAB function
nargin which returns the number of function input arguments given in the
call to the currently executing function. The code lines 8–10 compute
the elements of matrix Q (see (1.87)) and compose the matrix using di-
agonal assembling. Function diag(bta,k) places the elements of vector bta
on the k-th diagonal (k=0 represents the main diagonal, k=1 is above the
main diagonal, and k=−1 is below the main diagonal). Then, we perform
eigen value decomposition (line 11) and extract sorted eigen values (line
12). To perform eigen values extraction, first, we use MATLAB function
diag() which being called with matrix L returns its main diagonal, then
we call the function sort() which returns sorted nodes, d, and it also re-
turns an index vector, k, that describes the rearrangement of elements
such that d = L(k,:). We need this index vector to keep correspondence
between sorted eigen values and unsorted eigen vectors, U. The last step
is to calculate weights on the interval [−1,1] (line 13) and to perform
transformation for extended region [s0,s1] (lines 14–15). Note that all
calculations here are vectorized, namely, we do not use loops to iterate
over vector or matrix elements, but rather use vectors itself in calcu-
lation formulas. This significantly improves performance and simplifies
code readability.
1 function [d,w] = GaussQuad (n,s0 ,s1)
2 if nargin ==1
3 s0=−1; s1 =1;
4 end
5 if n==1
6 d=(s0+s1 )/2; w=s1−s0; return ;
7 end
8 j=1:n−1; bta=j./ sqrt(4∗ j.^2−1); Q=diag(bta,−1)+diag(bta ,1);
9 [U,L]= eig(Q);
10 [d,k]= sort(diag(L));
11 w=2∗ U(1,k).^2; w=w(:);
12 d=s0+0.5 ∗ (s1−s0)∗(d+1);
13 w=0.5 ∗ (s1−s0)∗ w;
14 end

Listing 2.1: MATLAB code for Gaussian quadrature rule.

46 ■ Computational Framework for the Finite Element Method

Similarly, Lobatto quadrature implementation can be coded as shown

in listing 2.2. We need to make sure that input number of nodes is equal
or greater than two to make calculation possible (lines 2–5). Compared
with Gaussian quadrature rule, matrix elements are calculated differ-
ently (line 14) and boundary points are added to the nodes and weights
(lines 19–20). Recall that the nodes of Lobatto quadrature can be taken
to be interpolation nodes on the interval [s0,s1].
1 function [d,w] = LobattoQuad (n,s0 ,s1)
2 if n<2
3 disp (’LobattoQuad : number of nodes is less then 2’ );
4 return ;
5 end
6 if nargin ==1
7 s0=−1; s1 =1;
8 end
9 if n==2
10 d=[s0;s1]; w=[(s1−s0 )/2; (s1−s0 )/2];
11 return ;
12 end
13 j=1:n−3;
14 bta=sqrt(j.∗(j+2)./(2 ∗ j+1)./(2 ∗ j+3));
15 Q=diag(bta,−1)+diag(bta ,1);
16 [U,L]= eig(Q);
17 [d,k]= sort(diag(L));
18 w=4/3 ∗ (U(1,k).^2) ’;
19 w=[2/(n^2−n); w./(1−d .^2); 2/(n^2−n)];
20 d=[−1; d ; 1 ];
21 d=s0+0.5 ∗ (s1−s0)∗(d+1);
22 w=0.5 ∗ (s1−s0)∗ w;
23 end

Listing 2.2: MATLAB code for Lobatto quadrature rule.

2.4 IMPLEMENTATION CODE FOR INTERPOLATING AND

DIFFERENTIATING MATRICES
Interpolating and differentiating matrices (Ê and D̂) are used for cal-
culation of the function uh and its derivative at arbitrary points. These
matrices are defined by basis functions for calculation of which we utilize
 Programming One-Dimensional Finite Element Method ■ 47

expressions (1.13) and (1.14)

 −1
Y
m+1
βα =  (x̂α − x̂j ) , (2.1)
j=1,j̸=α

Y
m+1
Êk,α = φ̂α (dˆk ) = βα (dˆk − x̂j ), (2.2)
j=1,j̸=α

X
m+1 Y
m+1
D̂k,α = φ̂′α (dˆk ) = βα (dˆk − x̂j ). (2.3)
l=1,l̸=α j=1,j̸=α,j̸=l

The code in listing 2.3 implements calculation of Ê and D̂ defined on

the basis element. Function interpolatingMat() returns interpolation ma-
trix, E, and differentiation matrix, D, with input arguments to be interpo-
lation points, x, and arbitrary nodes at which interpolation is calculated,
d. Since the formulas for matrix elements are nonlinear we cannot fully
apply vectorized calculations and have to use loops to iterate over el-
ements. First, elements βα are calculated in the loop lines 4–7 where
the variable b is used to store the values of βα . Vector j forms indices
which span the range of product operator in (2.1) and function prod()
returns the product of the vector elements. Listing lines 8–21 implement
matrices E and D calculations with two nested loops for matrix elements
k and i to calculate the product and one more loop to calculate the sum
in (2.3). The indices are processed consistently in ascending order, so
lines 14–15 perform this logic for product and summation calculation.
Indices formation in the lines 5, 9 and 15 follows the same pattern with
skipping i-th element.
1 function [E,D]= interpolatingMat (x,d)
2 nx=numel(x); nd=numel (d);
3 E= zeros (nd ,nx); D= zeros (nd ,nx ); b= zeros (1,nx );
4 for i=1: nx
5 j=[1:(i−1),(i+1): nx ];
6 b(i)=1/ prod(x(i)−x(j));
7 end
8 for i=1: nx
9 j=[1:(i−1),(i+1): nx ];
10 for k=1: nd
11 E(k,i)=b(i)∗ prod(d(k)−x(j));
12 ds =0;
48 ■ Computational Framework for the Finite Element Method

13 for l=j
14 i1=min(i,l); i2=max(i,l);
15 jj =[1:(i1 −1),(i1 +1):( i2 −1),(i2 +1): nx];
16 ds=ds+prod(d(k)−x(jj ));
17 end
18 D(k,i)=b(i)∗ ds;
19 end
20 end
21 end

Listing 2.3: MATLAB code for interpolating and differentiating matrices

calculation.
In addition to the function interpolatingMat(), it is useful to have a
functionality which allows performing mesh refinement and calculating
function values along with its derivatives on the refined mesh. This is
helpful, for example, when plotting solution. Listing 2.4 illustrates the
code for generating corresponding refined mesh values. It makes use
previous function interpolatingMat() to obtain matrices E and D and new
mesh is generated by splitting each element into k subelements. Function
getRefinedValues() has following arguments: u is a vector of function values
on the coarse mesh, xl is a vector of finite element nodes, d is a vector of
points on the basis element [0,1] and k is a number of refined mesh points
on each finite element. Returning vectors are refined mesh points, x, new
function values, y, and new function derivative values on refined mesh,
dy. New points are generated using MATLAB command linspace(x1,x2,k)
which generates k evenly distributed points in the interval [x1,x2] (see
lines 2 and 12). For better readability, listing 2.4 is complemented with
comments.
1 function [x,y,dy]= getRefinedValues (u,xl ,d,k)
2 d ref = linspace (0,1,k+1); % refined basis element
3 [E,D]= interpolatingMat (d, d ref );
4 n=numel(xl); m=numel (d)−1;
5 x ref =(n−1)∗k+1; % number of all refined mesh points
6 x= zeros ( x ref ,1); y= zeros (size(x)); dy= zeros (size(x));
7 % Iterate over finite elements and refine them
8 for l=1:n−1
9 h=xl(l+1)−xl(l); % size of element l
10 i c =(l−1)∗m+(1:m+1); % coarse point indices
11 i ref =(l−1)∗k+(1:k+1); % refined points indices
12 x( i ref )= linspace (xl(l),xl(l+1) ,k+1) ’;
 Programming One-Dimensional Finite Element Method ■ 49

13 y( i ref )=E∗u( i c );
14 dy( i ref )=D∗u( i c )/h;
15 end
16 end

Listing 2.4: MATLAB code for generating values on refined mesh.

So far, we have created flexible computational tools for manipulation
with mesh and quadrature points which lays a foundation for the next
step to implement numerical integration.

EXERCISES
▶ Verify that the number of operations to calculate E and D using
function interpolatingMat() has the order of O(nx2 nd) and O(nx3 nd),
respectively.

▶ Perform a number of running function interpolatingMat() with dif-

ferent value of dimension nx when x=d and estimate running time.
Define dependence of calculation time on value nx.

▶ Show that when x=d then the matrix D can be calculated through

βj X
n
D̂ij = , i ̸= j, D̂ij = − D̂ij .
βi (x̂i − x̂j )
j=1,j̸=i

Usage of these expressions results in complexity of calculation ma-

trix D to be O(nx2 ) rather than O(nx4 ) compared to the implemen-
tation function interpolatingMat().

▶ Compose your own version of function interpolatingMat().

2.5 IMPLEMENTATION CODE FOR CALCULATING AND ASSEM-

BLING FEM MATRICES
As discussed above, composing of the global stiffness matrix, Ã, and
global forcing vector, F̃ , can be decomposed into two parts (see 1.73
and 1.77): assembling matrix A and vector F which do not take into ac-
count boundary condition and assembling matrix S and vector M which
account for boundary conditions. Function assemblingAF() in linsting 2.5
implements the first part where we compute A and F .
Generally speaking, the function assemblingAF() returns stiffness ma-
trix A and forcing vector F corresponding to the equation −(cu′ )′ + bu′ +
50 ■ Computational Framework for the Finite Element Method

au = f with homogeneous Neumann boundary conditions cu′ = 0. Ar-

guments have the following meaning: c,b,a,f are equation coefficients, xl
is a vector of finite elements nodes, x is a vector of interpolation points on
the basis element, d is a vector of quadrature nodes on the basis element
and w is a vector of quadrature weights on the basis element. The code
fully implements algorithm 3 for calculating elements of local matrices
and then it incorporates assembling global matrices without taking into
account boundary conditions (first two steps of algorithm 2). Code line
5 corresponds to the first step of algorithm 2 and lines 6–17 implement
second step with looping over finite elements, computing local matri-
ces (lines 7–14) and accumulating components of global matrices (lines
15–16).
1 function [A,F]= assemblingAF (c,b,a,f,xl ,x,d,w)
2 [E,D]= interpolatingMat (x,d);
3 ET=E ’; DT=D ’;
4 m=numel(x)−1; n=numel (xl ); n total =(n−1)∗m+1;
5 A= sparse ( n total , n total ); F= zeros ( n total ,1);
6 for l=1:n−1
7 h=xl(l+1)−xl(l); % size of element l
8 ne=(l−1)∗m+(1:m+1); % point indices
9 xd=xl(l)+h∗d; % quadrature nodes on element l
10 c loc =diag ((w/h).∗ c(xd ));
11 b loc =diag(w.∗ b(xd ));
12 a loc =diag ((h∗w).∗ a(xd ));
13 Al=(DT∗ c loc +ET∗ b loc)∗ D+ET∗ a loc ∗E;
14 Fl=(h∗w).∗ f(xd);
15 A(ne ,ne)=A(ne ,ne)+ Al;
16 F(ne)=F(ne)+ET∗Fl (:);
17 end
18 end

Listing 2.5: MATLAB code for assembling one-dimensional matrices.

It is worth stressing attention on the line A(ne,ne)=A(ne,ne)+Al. Here,

A is n total by n total global stiffness matrix, Al is (m+1) by (m+1) local
stiffness matrix and the structure ne contains global indices of points
on each element. As such, local element is added to the corresponding
component of the global matrix which represents assembling the global
matrix. This assembling strategy is not fully vectorized but it is good
for matrix of moderate number of components. Later, in section 5.1, we
 Programming One-Dimensional Finite Element Method ■ 51

consider other approaches to assemble matrices which are efficient for

large matrices and allow full vectorization.
Next, we need to take into account BC and calculate matrix S and
vector M which are being added to A and F , respectively, to form
full FEM matrices. Incorporating BC is performed according to the step
three of algorithm 1 for BC of the first type (Dirichlet BC), and according
to the step three of algorithm 2 for BC of the third type (Robin BC).
Recall that BC of the second type (Neumann BC) can be considered
as a special case of Robin BC. Code listing 2.6 implements logic for
including BC where function assemblingBC() inputs boundary condition
matrix, bc, stiffness matrix, A, forcing vector, F, and outputs stiffness
matrix and forcing vector complemented with BC, [A0,F0]. As discussed
in section 2.2, first column of matrix bc encodes type of BC, so lines 6–13
correspond to BC of the third type either for point s0 (lines 6–9) or point
s1 (lines 10–13). Then, BC of the first type is considered (lines 15–22).
In both cases, the stiffness matrix and forcing vector are modified in
some way to include BC. The last step is to form final matrices from the
modified one (lines 23–25).
1 function [A0 ,F0]= assemblingBC (bc ,A,F)
2 % bc - boundary conditions matrix of size 2x3 :
3 % bc(1,:)=[1,0,u_s0] , or bc(1,:)=[3,sig_s0,mu_s0]
4 % bc(2,:)=[1,0,u_s1] , or bc(2,:)=[3,sig_s1,mu_s1]
5 n=numel(F); % number of all mesh points
6 if bc (1 ,1)==3
7 A(1 ,1)=A(1 ,1)+ bc (1 ,2);
8 F(1)=F(1)+ bc (1 ,3);
9 end
10 if bc (2 ,1)==3
11 A(n,n)=A(n,n)+bc (2 ,2);
12 F(n)=F(n)+bc (2 ,3);
13 end
14 ib =1; ie=n;
15 if bc (1 ,1)==1
16 ib =2; u s0 =bc (1 ,3);
17 F=F−u s0 ∗A(: ,1);
18 end
19 if bc (2 ,1)==1
20 ie=n−1; u s1 =bc (2 ,3);
21 F=F−u s1 ∗A(:,n);
52 ■ Computational Framework for the Finite Element Method

22 end
23 I=(ib:ie)’;
24 A0=A(I,I);
25 F0=F(I);
26 end

Listing 2.6: MATLAB code for assembling one-dimensional boundary

conditions.

Once the final stiffness matrix, A0, and forcing vector, F0, are created
using function assemblingBC(), resulting FEM system can be solved and
solution can be composed according to the steps 4 and 5 of algorithm 1.
Function solveFEM() in listing 2.7 returns the final solution, u. The code
lines 12–13 call linear solver (backslash MATLAB operator) and append
Dirichlet BC if any (u s0 and u s1).
1 function u = solveFEM (bc ,A0 ,F0)
2 u s0 =[]; u s1 =[];
3 if bc (1 ,1)==1 , u s0 =bc (1 ,3) ; end
4 if bc (2 ,1)==1 , u s1 =bc (2 ,3) ; end
5 u0=A0\F0;
6 u=[ u s0 ;u0; u s1 ];
7 end

Listing 2.7: MATLAB code for solving one-dimensional FEM system.

It is convenient to combine previous three functions into the single

one which performs solution of a linear BVP. Let us introduce a function
solveBVP() which return final solution, u, and mesh points, x mesh, with
given arguments being BC, equation coefficients, finite element nodes,
and interpolation along with quadrature nodes on the basis element (see
listing 2.8).
1 function [u, x mesh ]= solveBVP (bc ,c,b,a,f,xl ,x,d,w)
2 m=numel(x)−1; n=numel (xl );
3 N=(n−1)∗m+1; % number of mesh points
4 x mesh = zeros (N ,1); % mesh points
5 for l=1:n−1
6 ne=(l−1)∗m+(1:m+1); % mesh point indices
7 x mesh (ne)=xl(l)+( xl(l+1)−xl(l))∗ x;
8 end
9 [A,F]= assemblingAF (c,b,a,f,xl ,x,d,w);
10 [A0 ,F0]= assemblingBC (bc ,A,F);
 Programming One-Dimensional Finite Element Method ■ 53

11 u= solveFEM (bc ,A0 ,F0 );

12 end

Listing 2.8: MATLAB code for solving one-dimensional BVP.

We could stop here and decide that the task of coding FEM is done,
but one important part of any numerical simulation pipeline is missing.
To make sure that we have done all correctly and to validate output
results, we need a tool for error analysis. The main approach is to run
simulation for a problem with known exact solution and then compare
the output with true values in the form of error. To analyse FEM er-
ror when exact solution is known, it is worth having a function which
calculates the error norm in spaces L2 and H 1
Zs1 Zs1

2
e = u − uh , ∥e∥2L2 = 2
e (x)dx, ∥e∥2H 1 = e′ (x) dx.
s0 s0

Function errorNorm() which code is given in listing 2.9 calculates and out-
puts these norms. Here, e0 is a value of L2 error norm, e1 is a value of
H 1 error norm, u and du are exact solution and its derivative, y is an
FEM solution, xl is a vector of finite element nodes and d is a vector
of interpolation points on the basis element [0,1]. Function errorNorm()
uses Gaussian quadrature to calculate the norms, and interpolating and
differentiating matrices to find corresponding values of the solution.
1 function [e0 ,e1]= errorNorm (u,du ,y,xl ,d)
2 m=numel(d)−1;
3 [ d new ,w]= GaussQuad (m+2 ,0 ,1);
4 [E,D]= interpolatingMat (d, d new );
5 e0 =0; e1 =0;
6 for l=1: numel(xl)−1
7 h=xl(l+1)−xl(l);
8 dl=xl(l)+h∗ d new ;
9 ic=(l−1)∗m+(1:m+1);
10 uh=E∗y(ic); duh=D∗y(ic )/h;
11 e=u(dl)−uh; de=du(dl)−duh;
12 e0=e0+h/2∗ sum(w.∗ e .^2); e1=e1+h/2∗ sum(w.∗ de .^2);
13 end
14 e0=e0 ^(1/2); e1=e1 ^(1/2);
15 end

Listing 2.9: MATLAB code for the FEM error analysis.

54 ■ Computational Framework for the Finite Element Method

Now, we are ready to solve example problem using created library.

Let us consider the following BVP

(u′ cos(x))′ − 2u′ sin(x) + u sin(x) = sin2 (x), x ∈ (−1, 1),

u(−1) = sin(−1), u′ (1) = cos(1). (2.4)

Here, exact solution to be u = sin(x) and equation coefficients are

the following functions : c(x) = cos(x), b(x) = −2 sin(x), a(x) =
sin(x), f (x) = sin2 (x). Boundary points are s0 = −1 and s1 = 1. At the
point s0 we have Dirichlet BC which is a BC of the first type and at the
point s1 we have Neumann BC. The FEM library deals with either first
or third type of BC, so we need to rewrite BC at the point s1 in the form
of BC of the third type, namely, in the form c(1)u′ (1)+σ(1)u(1) = µ(1).
It is easy to see that σ = 0 and µ = cos2 (1).
Having all basic functions for assembling and solving FEM, it is not
difficult to write a script (see listing 2.10) which solves example BVP
and plots solution along with error norm values.
1 % main script
2 clc ; clear all ; close all
3 % set BVP data:
4 % integration domain
5 s 0=−1; s 1 =1;
6 % exact solution
7 u=@(x) sin(x);
8 du=@(x) cos(x);
9 % equation coefficients
10 c=@(x) cos(x);
11 b=@(x) −2∗sin(x);
12 a=@(x) sin(x);
13 f=@(x) sin(x).^2;
14 % boundary conditions
15 sigma =0;
16 mu=c( s 1)∗ du( s 1 )+ sigma∗u( s 1 );
17 bc =[1 0 u( s 0 )
18 3 sigma mu ];
19 % set FEM parameters
20 m=3; % polynomial degree
21 ne =6; % number of final elements
 Programming One-Dimensional Finite Element Method ■ 55

22 M=m+1; % number of quadrature nodes

23 xl= linspace ( s 0 , s 1 ,ne +1); % finite element nodes
24 t= LobattoQuad (m+1 ,0 ,1); % interpolation nodes on basis element
25 [d,w]= LobattoQuad (M ,0 ,1); % quadrature nodes and weighs
26 % solve BVP
27 tic
28 [uh ,x]= solveBVP (bc ,c,b,a,f,xl ,t,d,w);
29 timeFemSol =toc
30 % find error in various norms
31 [e0 ,e1]= errorNorm (u,du ,uh ,xl ,t)
32 [X,Uh ,dUh ]= getRefinedValues (uh ,xl ,t,10∗ m);
33 Z=u(X)−Uh; z=u(x)−uh; dZ=du(X)−dUh;
34 ie =1:m: numel(x);
35 einfh=norm(Z,inf)
36 einfdh =norm(dZ ,inf)
37 einfbh =norm(u(xl(:))−uh(ie),inf)
38 figure ; % plot solution
39 plot(X,Uh ,’−b’,x,uh ,’rx ’,x(ie),uh(ie),’ro ’)
40 xlabel (’x’); ylabel (’ u h ’)
41 figure ; % plot solution error
42 plot(X,Z,’−b’,x,z,’rx ’,x(ie),z(ie),’ro ’)
43 xlabel (’x’); ylabel (’u−u h ’)
44 figure ; % plot derivatives error
45 plot(X,dZ ,’−b’,x, zeros (size(x)),’rx’,x(ie), zeros (size(x(ie ))) , ’ro ’)
46 xlabel (’x’); ylabel (’u’’−u’’ h ’)

Listing 2.10: MATLAB code for solving example one-dimensional BVP.

Plots generated by this script are shown in figures 2.1, 2.2 and 2.3
where the finite element nodes are indicated as circles and crosses are
quadrature nodes which coincide with interpolation nodes.
Estimations of numerical error for the FEM solution are given in
table 2.1. It can be seen that implementation of the FEM algorithm
performs numerical calculations with acceptable accuracy.

TABLE 2.1: Summary of computational errors for the FEM solution to

the problem (2.4).

∥e∥L2 ∥e∥H 1 ∥e∥∞ ∥e′ ∥∞

10−6 10−5 10−6 10−4
56 ■ Computational Framework for the Finite Element Method

0.5
h

0
u

-0.5

-1
-1 -0.5 0 0.5 1
x

FIGURE 2.1: FEM solution to the problem (2.4).

Changing equation coefficients and parameters of the FEM algorithm

in the main script allows solving various BVP. A reader is encouraged
to play around with different parameter settings (m,ne,M) and see how it
affects solving time and errors magnitude.

EXERCISES
▶ Find numerical solution to the problems given below with known
exact solutions. Boundary conditions of the first type may be cho-
sen to close BVP. Specify your own values for parameter ε. Perform
analysis of the solution behaviour when ε becomes small. Choose
different FEM parameters and make observation regarding changes
 Programming One-Dimensional Finite Element Method ■ 57

8e-06

6e-06

4e-06

2e-06
h
u-u

-2e-06

-4e-06

-6e-06
-1 -0.5 0 0.5 1
x

FIGURE 2.2: Absolute error of the FEM solution to the problem (2.4).

of the error magnitude.

   
exp − √xε − exp x−2 √
ε
1. − εu′′ + u = 0, x ∈ (0, 1), u=   .
1 − exp − √2ε
2. − εu′′ − bu′ + u = (1 + επ 2 ) cos(πx) + bπ sin(πx), x ∈ (−1, 1),
b = 2 + cos(πx), u = cos(πx).
1
3. − (ε + x2 )u′′ − 4xu′ − 2u = 0, x ∈ (1, 1), u= .
ε + x2
4. − εu′′ + u = (1 + επ 2 ) cos(πx), x ∈ (−1, 1),
   
x−1 x+1
u = cos(πx) + exp √ + exp − √ .
ε ε

2.6 PYTHON IMPLEMENTATION

To give a reader more flexibility in implementing FEM, we turn our at-
tention to the Python programming language and explain how to create
58 ■ Computational Framework for the Finite Element Method

0.0004

0.0003

0.0002

0.0001
h
u’-u’

-0.0001

-0.0002

-0.0003
-1 -0.5 0 0.5 1
x

FIGURE 2.3: Absolute error of the FEM solution derivative correspond-

ing to the problem (2.4).

FEM computational framework in Python. Basically, we are going to

translate MATLAB codes into Python ones with some variations in spe-
cific features. We expect that a reader has basic Python programming
skills.
For dense matrix operation we use NumPy library which provides
broad range of specific functions for matrix manipulation and most of
them have MATLAB analogy. Book [7] could be helpful in improving
scientific programming skills using NumPy library.
There are some important notes regarding using vectors and matrices
in Python. First, it is worth noting that indexing in Python starts with
zero (unlike indexing in MATLAB starting with one) and all index values
given in previous chapters should be decremented by one to correspond
Python indexing.
Second, there is a distinction between different types of array data
structure in Python. For example, there is a structure called list,
a=[1,2,3], which stores data in array like manner, but it is not a vec-
tor in terms of ability to be used in matrix calculations; however if it is
 Programming One-Dimensional Finite Element Method ■ 59

declared through NumPy library, a = numpy.array([1, 2, 3]), then it can be

used in vectorized calculations, for example, in a dot product calculation
of two arrays, numpy.dot(a,b). Conversion between list data structure to
the numpy.array structure is supported by the NumPy library. Another
note is that unlike in MATLAB where most built in functions sup-
port vectorized calculations using any array variable, in Python these
vectorized calculations should be performed through explicitly calling
NumPy library commands. For example, MATLAB version of square
root function call on vector, j=1:n;s=sqrt(j.), in Python would have the
form: j=numpy.arange(1,n);s=numpy.sqrt(j).
Also, unlike in many matrix languages, the product operator, ∗, op-
erates elementwise in NumPy arrays, and matrix product can be per-
formed using the numpy.matmul() or @ operator (in Python version >=3.5).
For example, having two matrices A=numpy.array([[1, 0],[0, 1]]) and
B=numpy.array([[4, 1],[2, 2]]), result of operation A∗B would be
array([[4, 0],[0, 2]]), but A@B results in array([[4, 1],[2, 2]]).
Array slicing and indexing works exactly the same way it does for
lists except that they can be applied to multiple dimensions as well. For
example, given a matrix A, the command A[0,3] accesses a single element
of the matrix, and A[:,3] extracts a column. Note that slices of arrays
do not copy the internal array data but only produce new views of the
original data, so if b=A[0,3] and b=b+1 then element of matrix A would be
modified implicitly as well. If a copy is needed, then an explicit copy()
command is required. NumPy arrays may be indexed with other arrays
or lists. For all cases of index arrays, the copy of original data is returned,
not a view. For example A[np.array([0,2,4]),0] or A[np.array([0,2,4])][0] re-
turns elements of the first column with indices 0, 2 and 4.
To operate with sparse matrices in Python we use scipy.sparse library.
There are various sparse matrix classes in scipy.sparse library (coo matrix,
csc matrix, csr matrix, etc.) to perform matrix manipulations of different
types. For example, class coo matrix is used for constructing a sparse ma-
trix in coordinate format from arrays of indices and values (see figure 2.1
for detailed explanations) but it does not directly support arithmetic op-
erations. Class sparse.lil matrix is a structure for constructing sparse ma-
trices incrementally which supports flexible slicing. Classes csr matrix and
csc matrix are for compressed sparse row matrix and compressed sparse
column matrix representations, respectively. These matrix formats are
suitable for arithmetic operations and row/column slicing but ineffi-
cient for changing sparsity structure. Usually, coo matrix is a fast format
for constructing sparse matrices. Once a matrix has been constructed,
60 ■ Computational Framework for the Finite Element Method

conversion to csc matrix or csr matrix format is performed (explicitly or

implicitly) for fast arithmetic and matrix vector operations.
Before start writing Python functions, it is required to import li-
braries which we will be using across the code. Script in listing 2.11
shows how to perform importing. Libraries numpy and scipy.sparse are for
working with dense and sparse matrices, spsolve is for solving sparse lin-
ear systems, plt is for plotting simulation results and timeit library allows
operate with timing counters. We need to run this script only once in
the FEM Python library.
1 import numpy
2 import scipy. sparse as sparse
3 import timeit
4 from scipy . sparse . linalg import spsolve
5 import matplotlib . pyplot as plt

Listing 2.11: Python code implementing libraries import.

Python listings given below contain functions which names and func-
tionality repeat ones written in MATLAB, so notations of arguments and
returning values have consistent with MATLAB counterparts meaning.
While providing Python implementation of particular function, the fo-
cus will be on specific Python language features which differ the code
from MATLAB version rather than on describing logic, which already
has been discussed in previous sections.
Let us look into Python implementation of Gaussian and Lobatto
quadrature rules (see listings 2.12 and 2.13). By design, arguments s0
and s1 can be omitted, so the code line 2 retrieves the number of ac-
tual input arguments and stores it in the variable nargin. This is done
through the function locals() which returns a vector of arguments, and
the function len() returning vector length.
We can see in the code arithmetic calculation of the form j∗∗2, which
implements raising j to the second power. The function numpy.diag(bta,k)
constructs a diagonal matrix from a given array, bta, and a diagonal posi-
tion, k. The function linalg.eig(Q) computes eigenvalues and eigenvectors
of the matrix Q. To obtain ordered eigenvalues, function numpy.argsort(L)
is used which returns the indices that would sort the array L.
1 def GaussQuad (n,s0 ,s1 ):
2 nargin =len( locals ())
3 d=[]; w=[]
4 if nargin ==1:
 Programming One-Dimensional Finite Element Method ■ 61

5 s0=−1; s1=1
6 if n==1:
7 d=(s0+s1 )/2; w=s1−s0
8 return d,w
9 j=numpy. arange (1,n)
10 bta=j/numpy.sqrt(4∗(j∗∗2)−1)
11 Q=numpy.diag(bta , k=−1)+numpy .diag(bta , k=1)
12 L,U = numpy. linalg .eig(Q)
13 k=numpy. argsort (L)
14 d=L[k]; w=2∗(U[0][k]∗∗2)
15 d=s0+0.5 ∗ (s1−s0)∗(d+1)
16 w=0.5 ∗ (s1−s0)∗ w
17 return d,w

Listing 2.12: Python code for Gaussian quadrature rule.

Code lines 18–21 in listing 2.13 implement extending arrays of
weights, w, and nodes, d, with new values at the boundary. This is coded
through the functions numpy.append() to append value to the end of the
array, and numpy.insert() to insert the value at the beginning of the array.
Overall, calculations follow linear logic of the corresponding algorithms
for Gaussian and Lobatto quadrature rules.
1 def LobattoQuad (n,s0 ,s1 ):
2 nargin =len( locals ())
3 d=[]; w=[]
4 if n<2:
5 print (’LobattoQuad : number of nodes is less then 2’)
6 return d,w
7 if nargin ==1:
8 s0=−1; s1=1
9 if n==2:
10 d=[s0 ,s1]; w=[(s1−s0 )/2 ,(s1−s0 )/2]
11 return d,w
12 k=numpy. arange (1,n−2)
13 bta=numpy.sqrt(k ∗(k+2)/(2 ∗ k+1)/(2 ∗ k+3))
14 Q=numpy.diag(bta ,k=−1)+numpy .diag(bta ,k=1)
15 L,U = numpy. linalg .eig(Q)
16 k=numpy. argsort (L)
17 d=L[k]; w=4/3 ∗ (U[0][k]∗∗2); w=w/(1−d ∗∗2)
18 w=numpy. append (w ,2/(n∗∗2−n))
19 w=numpy. insert (w ,0 ,2/(n∗∗2−n))
62 ■ Computational Framework for the Finite Element Method

20 d=numpy. append (d ,1)

21 d=numpy. insert (d,0,−1)
22 d=s0+0.5 ∗ (s1−s0)∗(d+1);
23 w=0.5 ∗ (s1−s0)∗ w;
24 return d,w

Listing 2.13: Python code for Lobatto quadrature rule.

Script listing 2.14 demonstrates how interpolating and differentiating
matrices calculation can be implemented in Python. Note that it is a
good practice to declare and initialize variables before using them to
make it clear of what data manipulations are allowed to work with.
Lines 2–6 introduce main variables which are used across the listing
where nx and nd represent lengths of corresponding input arrays, E and
D are declared to be zeroth matrices of dimension nd by nx, and b is a
one-dimensional array of length nx. Function numpy.zeros((nd,nx)) returns a
matrix of zeros with the given shape, (nd,nx), and if the second dimension
is omitted, then a vector is returned. Looping with parameter can be
coded through either specifying a range using a special function range(nx)
(see line 7) which returns iterator spanning values in the range [0,nx), or
giving the range explicitly as a vector of predefined values (see line 15).
Formulas (2.1)–(2.3) which are coded in listing 2.14 include calculation of
product of elements which is implemented through function numpy.prod().
Indices over which the product in formulas is taken exclude particular
values and this is implemented using numpy.delete() function which returns
a new array with deleted sub-arrays (lines 8, 11 and 17).
1 def interpolatingMat (x,d):
2 nx=numpy .size(x); nd= numpy .size(d)
3 E=numpy.zeros ((nd ,nx ))
4 D=numpy.zeros ((nd ,nx ))
5 b=numpy.zeros ((nx ,))
6 j all =numpy . arange (nx)
7 for i in range (nx ):
8 j=numpy. delete ( j all ,i)
9 b[i]=1/ numpy.prod(x[i]−x[j])
10 for i in range (nx ):
11 j=numpy. delete ( j all ,i)
12 for k in range (nd ):
13 E[k,i]=b[i]∗ numpy .prod(d[k]−x[j])
14 ds=0
15 for l in j:
 Programming One-Dimensional Finite Element Method ■ 63

16 i1=min(i,l); i2=max(i,l)
17 jj=numpy. delete ( j all ,[i1 ,i2 ])
18 ds=ds+ numpy .prod(d[k]−x[jj ])
19 D[k,i]=b[i]∗ ds
20 return E,D

Listing 2.14: Python code for interpolating and differentiating matrices

calculation.

Along with calculation of interpolating and differentiating matrices,

error norms calculations and mesh refinement are another complemen-
tary functionalities which simplify manipulating FEM data (see list-
ings 2.15 and 2.16). Note that matrix multiplication is performed using
@ operator.

1 def errorNorm (u,du ,y,xl ,d):

2 m=numpy.size(d)−1
3 d new ,w= GaussQuad (m+2 ,0 ,1)
4 E,D= interpolatingMat (d, d new )
5 e0 =0; e1=0
6 for l in range (numpy .size(xl)−1):
7 h=xl[l+1]−xl[l]
8 dl=xl[l]+h∗ d new
9 ic=l∗m+numpy. arange (m+1)
10 uh=E @ y[ic]; duh=D @ y[ic ]/h
11 e=u(dl)−uh; de=du(dl)−duh
12 e0=e0+h/2∗ sum(w ∗(e ∗∗2))
13 e1=e1+h/2∗ sum(w ∗(de ∗∗2))
14 e0=e0 ∗∗ (1/2); e1=e1 ∗∗(1/2)
15 return e0 ,e1

Listing 2.15: Python code for the FEM error analysis.

1 def getRefinedValues (u,xl ,d,k):

2 d ref =numpy . linspace (0,1,k+1) # refined basis element
3 E,D= interpolatingMat (d, d ref )
4 n=numpy.size(xl); m= numpy .size(d)−1
5 x ref =(n−1)∗k+1; # number of all refined mesh points
6 x=numpy.zeros (( x ref ,))
7 y=numpy.zeros(x.shape )
8 dy=numpy .zeros(x. shape )
9 for l in range (n−1):
64 ■ Computational Framework for the Finite Element Method

10 h=xl[l+1]−xl[l] #size of element l

11 i c =l∗m+numpy . arange (m+1) # coarse point indices
12 i ref =l∗k+numpy . arange (k+1) # refined points indices
13 x[ i ref ]= numpy . linspace (xl[l],xl[l+1] ,k+1)
14 y[ i ref ]=E @ u[ i c ]
15 dy[ i ref ]=D @ u[ i c ]/h
16 return x,y,dy

Listing 2.16: Python code for generating values on refined mesh.

Let us discuss in more details listing 2.17 for assembling FEM
matrices. Here, we use sparse matrices as a main data structure for
stiffness matrix, A, and forcing vector, F, and declare them through
sparse.coo matrix() class. This class allows creating matrices in coordinate
form using constructor coo matrix((data, (i, j)), shape=(m, n)), where (m,n)
are the matrix dimensions, data is an array of matrix entries, i is an
array of row indices and j is an array of column indices of the matrix
entries. If arguments (data, (i, j)) are omitted, then an empty sparse
matrix of given shape will be created, as shown in code lines 8 and 9.
Class for sparse matrices in Python does not support advanced indexing,
so the best way of assembling stiffness matrix is to use extended local
matrix as a summand when accumulating final stiffness matrix (see defi-
nition 1.10 and algorithm 2). Recall that extended local stiffness matrix
has all zeros apart from the diagonal block for corresponding final ele-
ment. Assume that we have a final element with three nodes, so the block
would be 3 × 3 = 9 elements and to construct a bock diagonal sparse
matrix we need three arrays with nine elements each, namely, indices
i=[0,0,0,1,1,1,2,2,2], j=[0,1,2,0,1,2,0,1,2] and data with some data val-
ues which are flatten one-dimensional representation of two-dimensional
(3 × 3) block. Generating local indices is implemented in lines 10–12,
where i loc is a range of local node indices, i loc sp mat is an array of
local row indices and j loc sp mat is an array of local column indices for
the sparse matrix constructor. Here, function numpy.repeat(i loc,m+1) re-
peats each element of the array i loc given number of times, m+1, and
numpy.tile(i loc,m+1) construct an array by repeating entire array i loc the
number of times, m+1. After calculating local matrix in dense form (line
19), global row and column indices are calculated (lines 20–21), and ex-
tended stiffness matrix is added in the form of sparse matrix (see line
22). This approach illustrates a possible way of manipulating with sparse
matrices.
1 def assemblingAF (c,b,a,f,xl ,x,d,w):
 Programming One-Dimensional Finite Element Method ■ 65

2 E,D= interpolatingMat (x,d)

3 ET=numpy . transpose (E)
4 DT=numpy . transpose (D)
5 m=numpy.size(x)−1
6 n=numpy.size(xl)−1
7 n total =n∗m+1;
8 A= sparse . coo matrix (( n total , n total ))
9 F= sparse . coo matrix (( n total ,1))
10 i loc =numpy . arange (m + 1)
11 i l o c s p m a t = numpy . repeat ( i loc , m + 1)
12 j l o c s p m a t = numpy .tile( i loc , m + 1)
13 for l in range (n):
14 h=xl[l+1]−xl[l] # size of element l
15 xd=xl[l]+h∗d # quadrature nodes on element l
16 c loc =numpy.diag ((w/h)∗ c(xd ))
17 b loc =numpy.diag(w∗b(xd ))
18 a loc =numpy.diag ((h∗w)∗ a(xd ))
19 Al=(DT @ c loc +ET @ b loc ) @ D+ET @ a loc @ E
20 row=l∗m+ i l o c s p m a t
21 col=l∗m+ j l o c s p m a t
22 A=A+ sparse . coo matrix (( Al. flatten () ,(row , col )), \
23 shape =( n total , n total ))
24 Fl=ET @ (h∗w∗f(xd )). reshape(−1,1)
25 F=F+ sparse . coo matrix (( Fl. flatten (), \
26 (l∗m+ i loc , numpy . zeros(m+1))) , shape =( n total ,1))
27 return A,F

Listing 2.17: Python code for assembling one-dimensional matrices.

Script for assembling BC (see listing 2.18) follows linear logic of re-
placing corresponding values in stiffness matrices by the BC values. Some
comments are added to make it clear which part of the code responsible
for the BC of the first type and which one for the third type. The func-
tion returns matrices A0 and F0 which are ready to be used with linear
solver.
1 def assemblingBC (bc ,A,F):
2 # bc - boundary conditions matrix of size 2x3 :
3 # bc(1,:)=[1,0,u_s0] , or bc(1,:)=[3,sig_s0,mu_s0]
4 # bc(2,:)=[1,0,u_s1] , or bc(2,:)=[3,sig_s1,mu_s1]
5 n=F.shape[0]−1 #number of all mesh points
6 # set boundary conditions of 3-d type
66 ■ Computational Framework for the Finite Element Method

7 if bc [0 ,0]==3:
8 A[0 ,0]=A[0 ,0]+ bc [0 ,1]
9 F[0]=F[0]+ bc [0 ,2]
10 if bc [1 ,0]==3:
11 A[n,n]=A[n,n]+ bc [1 ,1]
12 F[n ,0]=F[n ,0]+ bc [1 ,2]
13 #set boundary conditions of the first type
14 ib =0; ie=n+3
15 if bc [0 ,0]==1:
16 ib =1; u s0 =bc [0 ,2]
17 F=F−u s0 ∗A[: ,0]
18 if bc [1 ,0]==1:
19 ie=n+2; u s1 =bc [1 ,2]
20 F=F−u s1 ∗A[:,n]
21 A0=A[ib:ie ,ib:ie]
22 F0=F[ib:ie ,0]
23 return A0 ,F0

Listing 2.18: Python code for assembling one-dimensional boundary con-

ditions.

Listings 2.19 and 2.20 show function implementations for solving

FEM and BVP. Note how the sparse linear system is solved using
sparse.linalg.spsolve() function.

1 def solveFEM (bc ,A0 ,F0 ):

2 u s0 =[]; u s1 =[]
3 if bc [0 ,0]==1: u s0 =bc [0 ,2]
4 if bc [1 ,0]==1: u s1 =bc [1 ,2]
5 u0= sparse . linalg . spsolve (A0 ,F0)
6 u= u s0
7 u=numpy. append (u,u0)
8 u=numpy. append (u, u s1 )
9 return u

Listing 2.19: Python code for solving one-dimensional FEM system.

1 def solveBVP (bc ,c,b,a,f,xl ,x,d,w):

2 m=numpy.size(x)−1
3 n=numpy.size(xl)
4 N=(n−1)∗m+1 # number of mesh points
5 x mesh =numpy. zeros ((N ,)) # all mesh points
 Programming One-Dimensional Finite Element Method ■ 67

6 for l in range (n−1):

7 ne=l∗m+numpy. arange (m+1) # mesh point indices
8 x mesh [ne]=xl[l]+( xl[l+1]−xl[l])∗ x
9 A,F= assemblingAF (c,b,a,f,xl ,x,d,w)
10 A0 ,F0= assemblingBC (bc ,A,F)
11 u= solveFEM (bc ,A0 ,F0)
12 return u, x mesh

Listing 2.20: Python code for solving one-dimensional BVP.

Finally, the main script for testing example problem is given in list-
ing 2.21. To specify equation coefficients and exact solution, we use in-
line function definitions (lines 6–12) with corresponding vectorized numpy
functions. Also, built-in function numpy.linalg.norm() is used to calculate
various norms, for example, ∥·∥∞ norm is printed in lines 37–39.
1 def mainTest ():
2 # set BVP data:
3 # integration domain
4 s 0=−1; s 1 =1
5 # exact solution
6 def u(x): return numpy .sin(x)
7 def du(x): return numpy .cos(x)
8 # equation coefficients
9 def c(x): return numpy .cos(x)
10 def b(x): return −2∗numpy .sin(x)
11 def a(x): return numpy .sin(x)
12 def f(x): return numpy .sin(x)∗∗2
13 # boundary conditions
14 sigma =0
15 mu=c( s 1)∗ du( s 1 )+ sigma∗u( s 1 )
16 bc=numpy .array ([[1 , 0, u( s 0 )],
17 [3, sigma , mu] ])
18 # set FEM parameters
19 m=3 # polynomial degree
20 ne=6 # number of final elements
21 M=m+1 # number of quadrature nodes
22 xl=numpy . linspace ( s 0 , s 1 ,ne +1) # finite element nodes
23 t, = LobattoQuad (m+1 ,0 ,1) # interpolation nodes
24 d,w= LobattoQuad (M ,0 ,1) # quadrature nodes and weighs
25 # solve BVP
26 start time = timeit . default timer ()
68 ■ Computational Framework for the Finite Element Method

27 uh ,x= solveBVP (bc ,c,b,a,f,xl ,t,d,w)

28 print (" solving time =",timeit . default timer () − start time )
29 # find error in L_2 and Hˆ1 norms
30 e0 ,e1= errorNorm (u,du ,uh ,xl ,t)
31 print ("L2 norm error =",e0)
32 print ("H1 norm error =",e1)
33 X,Uh ,dUh= getRefinedValues (uh ,xl ,t,10∗ m)
34 # find error in various norms
35 Z=u(X)−Uh; z=u(x)−uh; dZ=du(X)−dUh
36 ie=numpy . arange (0, numpy .size(x),m)
37 print ("uh error inf norm:",numpy . linalg .norm(Z, numpy.inf ))
38 print ("duh error inf norm:",numpy . linalg .norm(dZ , numpy .inf ))
39 print ("error at f.e. nodes inf norm:", \
40 numpy. linalg .norm(u(xl)−uh[ie],numpy .inf ))
41 plt. figure ()
42 # plot solution
43 plt.plot(X,Uh ,’−b’,x,uh ,’rx ’,x[ie],uh[ie],’ro ’)
44 plt. xlabel (’x’); plt. ylabel (’ u h ’)
45 plt.show ()
46 #plot solution error
47 plt.plot(X,Z,’−b’,x,z,’rx ’,x[ie],z[ie],’ro ’)
48 plt. xlabel (’x’); plt. ylabel (’u−u h ’)
49 plt.show ()
50 #plot derivatives error
51 plt.plot(X,dZ ,’−b’, \
52 x,numpy.zeros ( numpy .size(x)),’rx ’, \
53 x[ie],numpy . zeros ( numpy .size(x[ie ])) , ’ro ’)
54 plt. xlabel (’x’); plt. ylabel (’u’’−u’’ h ’);
55 plt.show ()

Listing 2.21: Python code for solving example one-dimensional BVP.

 CHAPTER 3

Finite Element Method

for the
Two-Dimensional
Boundary Value
Problem

y learning how to solve one-dimensional BVP using FEM, we

B have gained knowledge allowing us to take next step and consider
two-dimensional case. Although all steps of the algorithm for the two-
dimensional case are similar to the one-dimensional one, their implemen-
tations are different and require specific features and coding strategies
to be considered.
We begin by formulating a model problem in terms of linear partial
differential equation with mixed boundary conditions. Then, an integral
formulation of the model problem is given with further finite element
discretization. We introduce basis functions and show how the discretized
problem can be reduced to solving a linear system. Also, basic concepts
of two-dimensional mesh with finite elements having triangular shape
are discussed.
Notations introduced in chapter 1 are used across the current chapter
along with new ones given below.

DOI: 10.1201/9781003265979-3 69
70 ■ Computational Framework for the Finite Element Method

GLOSSARY
f (x): a function of multiple variables.

f (x): a multivariate function of multiple variables.

∂f ∂f ∂2f
∂x1 , ∂x2 , ∂x1 ∂x2 , . . . : partial derivatives of a function f (x).
 T
∂f ∂f
∇: the nabla operator with definition ∇f = ∂x1 , ∂x2 .

3.1 MODEL PROBLEM

Similar to the one-dimensional case, two-dimensional FEM approach will
be based on considering a generic BVP which can be reduced to a specific
problem by simplifying particular terms in the BVP formulation. This
allows to deduce a FEM algorithm which covers as many application
problems as possible.
Consider a BVP of finding a function u = u(x) in two-dimensional
region Ω with piecewise smooth boundary Γ = ΓD ∪ ΓR

−∇ · (c(x)∇u) + b(x) · ∇u + a(x)u = f (x), x = (x1 , x2 ) ∈ Ω, (3.1)

u(x) = uD (x), x ∈ ΓD ,
c(x)∇u · ν(x) + σ(x)u = µ(x), x ∈ ΓR .
Here, ΓD and ΓR are the boundary parts for Dirichlet and Robin bound-
ary conditions, respectively, and either of them could be empty (in this
case the corresponding boundary condition is omitted); Γ is supposed
to be closed; ν(x) is the unit outward normal vector at the point x.
Functions c, a, f, uD , σ, µ and b(x) = (b1 (x), b2 (x))T are known
and supposed to be piecewise smooth. The model problem (3.1) can be
reduced to variety of particular problems with appropriate definition of
the coefficients, for example, when c(x) = 1, b(x) = a(x) = 0 we come
to a Poisson’s equation.
Let us reformulate the problem (3.1) in terms of integral equations.
First, we consider function sets W and W 0

W = w ∈ H 1 (Ω) : w(x) = uD (x), x ∈ ΓD ,

W 0 = w ∈ H 1 (Ω) : w(x) = 0, x ∈ ΓD ,

where H 1 (Ω) is the Sobolev space. Then, perform a standard sequence of

steps to come to the integral formulation of the problem. We follow the
Finite Element Method for the Two-Dimensional Boundary Value Problem ■ 71

logic of the projective method described in section 1.2 which is equally

applied to the two-dimensional case. By multiplying equation (3.1) by
function v ∈ W 0 , integrating over region Ω, applying Gauss theorem1
and taking into account boundary conditions we come to the formulation
of the problem in the form
Z Z
(c∇u · ∇v + b · ∇uv + auv) dx + σuvdx
Ω ΓR
Z Z
= f vdx + µvdx. (3.2)
Ω ΓR

Now, the problem can be formulated as follows: find a function u ∈ W

so that, for any v ∈ W 0 , the function u satisfies equation (3.2). Here,
functions v are the test functions.

3.2 FINITE ELEMENTS DEFINITION

Let us introduce Th - partitioning (triangulation) of the domain Ω by
finite elements τ , and all boundary points Γ are vertices of some ele-
ments. A finite element is a triple (τ, Pτ , Gτ ), where τ is the closed area
of a simple form (triangle or polygon), Pτ are the interpolation points
belonging to τ and Gτ are interpolation functions defined on τ (maxi-
mum diameter of elements in Th is denoted by h). Then, ΓhD and ΓhR are
partitioning of ΓD and ΓR , respectively. We introduce notation: Ph is a
set of all interpolation points (grid points of Th ), PD is a set of points
belonging to ΓhD and PR is a set of points belonging to ΓhR . Now, we are
looking for functions uh and vh defined on grid Ph so that
Z Z
(c∇uh · ∇vh + b · ∇uh vh + auh vh ) dx + σuh vh dx
Th Γh
Z R
Z
= f vh dx + µvh dx. (3.3)
Th Γh
R

Function uh represents an approximate solution to the BVP and the

FEM is to find this function.
R R R
1
Gauss theorem: ∇ · bvdx = − b · ∇vdx + b · νvdx.
Ω Ω Γ
72 ■ Computational Framework for the Finite Element Method

1 1

0.8 0.8

0.6 0.6

2
2

x1
x

0.4 0.4

0.2 0.2

0 0
0 0.2 0.4 0.6 0.8 1 0 0.2 0.4 0.6 0.8 1
x x1
1 1

(a) (b)

FIGURE 3.1: Examples of the triangulation with three (a) and six (b)
interpolation points over a triangle element.

3.3 TRIANGULATION EXAMPLES

Figure 3.1(a) shows example of the domain triangulation with three
interpolation points. In this case, the finite element τ is a triangle, inter-
polation points Pτ are the triangle’s vertices and interpolation functions
Gτ = G1 = {g1 + g2 x1 + g3 x2 } are polynomials of the first order. Any
two elements share either edge or vertex and each edge contains two
interpolation points.
Figure 3.1(b) shows triangulation with six interpolation points. Each
Gτ includes vertices and in-between points belonging to the edges. As a
result, three points of interpolation are available for each edge and the
interpolation function is of the second order, Gτ = G2 = {g1 + g2 x1 +
g3 x2 + g4 x21 + g5 x1 x2 + g6 x22 }.

3.4 LINEAR SYSTEM OF THE FEM

Equation (3.3) reduces to the system of linear equation. Firstly, we need
to select basis functions which define interpolation over finite elements
τ . We define basis functions as follows: Let us enumerate all points Ph
from 1 to np and assign a basis function φi (x) to each point pi ∈ Ph so
that φi (pj ) = δij , j = 1, . . . , np . 2 Then, any vh can be represented in
2
δij = 1 if i = j and δij = 0 if i ̸= j. Basis function φ has an important property:
if pi does not belong to a finite element then φ(pi ) = 0 on this element.
Finite Element Method for the Two-Dimensional Boundary Value Problem ■ 73

the form of interpolating polynomial

X
np
vh (x) = vi φi (x),
i=1

where vi = v(pi ). Let us divide set of indices I = {1, 2, . . . , np } into two

subsets: ID = {i ∈ I : pi ∈ PD } and IU = {i ∈ I : pi ∈ / PD }. Solution
at the points piD is known from the boundary condition (uh (piD ) = uDi ).
We need to find a solution at the points piU .
The following expansions are valid in Th :
X X X
uh (x) = ui φi (x) + uDi φi (x), vh (x) = vi φi (x). (3.4)
i∈iU i∈iD i∈iU

Let us define a matrix à ∼ (np × np ) and a vector F̃ ∼ (np × 1) having

components
Z Z
Ãij = (c∇φj · ∇φi + b · ∇φj φi + aφj φi ) dx + σφj φi dx (3.5)
Th Γh
R

Z Z
F̃i = f (x)φi dx + µ(x)φi dx (3.6)
Th Γh
R

where à is called global stiffness matrix and F̃ is the global forcing

vector. Then, equation (3.3) can be rewritten in the form of the linear
system (see section 1.3.3 for details)3
X X
Ãij uj = qi , qi = F̃i − Ãij uDj , i ∈ IU . (3.7)
j∈IU j∈ID

By solving system (3.7) we define uj , j ∈ IU , and the approximation

solution of the problem (3.2) is found from (3.4). Although matrix and
vector elements can be defined from (3.5) and (3.6), these formulas are
not usually used for calculation purpose. There exists more convenient
and efficient calculation method which we consider below.
3
Equation (3.3) follows from equation (3.7). This can be seen if we multiply ith
equation in (3.7) by vi and sum up all equations taking into account (3.4)–(3.6).
74 ■ Computational Framework for the Finite Element Method

3.5 STIFFNESS MATRIX AND FORCING VECTOR

Linear system (3.7) implies calculation of matrix à and vector F̃ . In
practical application problems, these matrices are usually of large sizes
and chosen calculation method affects overall performance of the FEM
programming implementation. Here, we consider efficient method of their
calculation.
It is followed from (3.5) that matrix à is a sum of two square matrices
of (np × np ) dimension: Ã = A + S ,4
Z
Aij = (c∇φj · ∇φi + b · ∇φj φi + aφj φi ) dx,
Th
Z
Sij = σφj φi dx, i, j = 1, . . . , np .
Γh
R

Similarly,
Z Z
F̃ = F + M , Fi = f φi dx, Mi = µφi dx, i = 1, . . . , np .
Th Γh
R

Recall that triangulation Th is a union of finite elements τ , that is

S
nt
Th = τl where nt is the total number of finite elements. It is assumed
l=1
that there are mτ number of interpolation points belonging to the el-
ement τl (for the triangular G1 element mτ = 3) and these points are
ordered (locally numerated): pi1 , pi2 , . . . , pimτ . Let us specify a connec-
tivity matrix, t ∼ (mτ × nt ), and place into lth column the indices of the
points of the lth element (i1 , i2 , . . . , imτ ) so that tjl defines index of the
j th point (in local order) belonging to the element τl .
Calculation of A and F . Represent the integral over triangulation
Th through the sum of integrals over elements τl . Using the matrix of
indices, tjl , we can introduce a matrix Āl with the components
Z


Ālαβ = c∇φtβl · ∇φtαl + b · ∇φtβl φtαl + aφtβl φtαl dx,
τl
α, β = 1, . . . , mτ ,

4
Note that S is a symmetric matrix; A is a symmetric matrix provided b = 0.
Finite Element Method for the Two-Dimensional Boundary Value Problem ■ 75

which is the local stiffness matrix of the finite element τl . Now, we can
express global matrix in terms of local stiffness matrices by introducing
extended local stiffness matrix Al ∼ (np ×np ) so that matrix Al contains
zeros except of elements with indices tαl and tβl , and

Altαl ,tβl = Ālαβ , α, β = 1, . . . , mτ .

For example, matrix Al for the triangular G1 element has mτ × mτ =

3 × 3 = 9 nonzero elements. As a result,

X
nt
A= Al .
l=1

The latter expression indicates that the global stiffness matrix A can
be obtained by summation of the extended local stiffness matrices, Al .
Since there is no sense to sum up zeros, we come to the algorithm of
composing global matrix A (see algorithm 4).

Algorithm 4 Composing global stiffness matrix A

1. Specify connectivity matrix of indices t ∼ (mτ × nt ).

2. Define zero value matrix A ∼ (np × np ).

3. For each l = 1, 2, . . . , nt :

(a) calculate matrix Ālαβ ∼ (mτ × mτ )

(b) perform summation across indices tαl and tβl : Atαl ,tβl =
Atαl ,tβl + Ālαβ , α, β = 1, 2, . . . , mτ

Similarly, the algorithm for calculation of F can be obtained (see

l
algorithm 5). Vector F̄ is called the local force vector.
Calculation S and M . Matrix S and vector M contain bound-
ary integrals over ΓhR , so the calculations are performed only using in-
terpolation points belonging to the boundary. Let us introduce, analo-
gous to matrix of indices t, a matrix of indices associated with edges,
e ∼ (me × ne ), which is called edge matrix. Here ne is the number of
edges belonging to the boundary ΓhR and me is the number of interpo-
lation points on the edge. In other words, ejk defines index of the j th
point (in local order) belonging to the k th boundary edge. As a result,
76 ■ Computational Framework for the Finite Element Method

Algorithm 5 Composing global vector F

1. Define zero value vector F ∼ (np × 1).

2. For each l = 1, 2, . . . , nt :
l
(a) calculate F̄ ∼ (mτ × 1) :
Z
l
F̄α = f (x)φtαl (x)dx
τl

(b) perform summation across indices tαl : Ftαl = Ftαl + F̄αl , α =

1, 2, . . . , mτ

for the k th edge, ek , we can define a local matrix S̄ k with elements

Z
k
S̄αβ = σ(x)φeβk φeαk dx.
ek

By introducing extended matrix S k (see similar extended matrix Al ) we

obtain
Xne
S= Sk.
k=1
k
Vector M is calculated through introducing a local vector M̄ for
each edge ek Z
k
M̄α = µ(x)φeαk (x)dx,
ek

and summation of the extended vectors M k across all edges

X
ne
M= M k.
k=1

Algorithm of composing matrix S and vector M is the same as for matrix

A and vector F .

3.6 ALGORITHM OF SOLVING PROBLEM

Algorithm 6 summarizes previous results and describes sequence of steps
to find the approximate solution to the problem (3.2).
Finite Element Method for the Two-Dimensional Boundary Value Problem ■ 77

Algorithm 6 Generic two-dimensional FEM

1. Define geometry of the problem (domain Ω and their boundaries

ΓD and ΓR );

2. Define boundary conditions;

3. Build triangulation of the domain Ω;

4. Define a connectivity matrix, t, and an edge indices matrix, e;

5. Compose matrix A and vector F ;

6. Define indices iU and iD ;

7. Compose matrix S and vector M ;

8. Compose matrix à and vector q (see (3.7));

9. Solve linear system (3.7) and find the vector of nodal values u for
the solution uh ;

10. Express solution uh through basis functions expansion;

In the following chapters we will discuss each step of this algorithm

and provide implementation codes which form a FEM framework library.
Programming framework for the FEM will be obtained in MATLAB as
well as in Python programming language. Mathematical formulations
obtained above will serve as defining expressions for coding numerical
methods. To make the code consistent, the same data structures for the
FEM representation across both languages implementations are going to
be used.
 CHAPTER 4

Building
Two-Dimensional
Meshes

irst four steps of the FEM algorithm given in section 3.6 will be
F covered in this chapter. We will describe how to define geometry of
a problem and build two-dimensional triangular mesh using MATLAB
and Python tools. Basic data structure for the mesh representation will
be considered.
Basically, generating geometry for a domain with simple boundary
shape is not a challenge; however things become more complicated when
a geometry has subdomains or nontrivial boundary shape. In general,
the problem of generating geometry can be viewed as having two tasks:
geometry definition through some data structure, and performing tri-
angulation to build finite elements. In this chapter we are focussed on
the first task, namely, various approaches of how to create data struc-
tures for geometry definition and how to represent mesh in a matrix
form. Questions of how to encode boundary and build geometry will be
discussed as well.
To perform triangulation itself using predefined geometry definition,
we are going to use specific MATLAB and Python tools. Triangula-
tion algorithm implementation is not discussed below and it is beyond
the scope of the book, but rather existing implementation as a tool or
third-party library is used. Interested reader can find mesh generating
algorithms in [3] where some triangulation techniques are discussed.

DOI: 10.1201/9781003265979-4 79
80 ■ Computational Framework for the Finite Element Method

FIGURE 4.1: Example of the domain with labelled subdomains.

4.1 DEFINING GEOMETRY

Let us start with considering an example geometry to show how it can
be represented to use with the FEM solver. Figure 4.1 shows an exam-
ple of the geometry domain Ω. This domain consists of three labelled
subdomains, Ω1 , Ω2 and Ω3 so that Ω = Ω1 ∪ Ω2 ∪ Ω3 . It is seen that
Ω1 and Ω3 are rectangles and Ω2 is a square. A circle of radius 0.25 is
removed from Ω1 . Also, it is highlighted that we have internal area of
the geometry (coloured in grey) and external one which is called com-
plement of the domain Ω and will be referenced as Ω0 . The geometry is
split into subdomains to illustrate the fact that PDE coefficients could
be different in these subdomains and we need to take it into account.
Next, boundaries of the geometry are considered (see figure 4.2).
Boundaries of Ω1 , Ω2 and Ω3 are split into segments. Segments are la-
belled, they cannot intersect and have single common end point. As a
result, the square is specified with a minimum of four segments and the
circle – with two segments. We define internal and external (boundary)
segments. Specific boundary conditions could be specified on each seg-
 Building Two-Dimensional Meshes ■ 81

FIGURE 4.2: Example domain with labelled boundaries.

ment. Figure 4.2 shows the boundary consisting of 15 segments including

5 internal ones (labelled as 2, 3, 6, 10 and 11). Each segment line can be
described in a parametric form

x1 = x1 (s), x2 = x2 (s), s ∈ [s0 , s1 ].

For example, a straight line can be parameterized as follows:

 
x(s) = xstart + s xend − xstart , s ∈ [0, 1], (4.1)

where xstart = x(0) and xend = x(1) are starting and ending points of
a line segment. A circle segment has a parametric form

x1 (s) = r cos(s)+xcentre
1 , x2 (s) = r sin(s)+xcentre
2 , s ∈ [s0 , s1 ], (4.2)

where r is a radius and xcentre is a circle centre point.

When following the segment from the starting point having param-
eter value of s0 to the endpoint with parameter value of s1 , there is
always one subdomain on the left and one on the right hand side. For
82 ■ Computational Framework for the Finite Element Method

example, Ω3 is on the left and Ω0 is on the right when following the

indicated direction of segment 5; Ω0 is on the left and Ω3 is on the right
when following the direction of the segment 9. Thus, parameter order is
important and it defines the direction of boundary path.
As a result, the geometry shown in figure 4.2 can be uniquely defined
by specifying two matrices: matrix of parameter values, Sparam , and
endpoints coordinates X1 X2
0 0 0 0 0 0 0 0 0 0 0 π 3π 0 π
!
2 2

Sparam = 1 1 1 1 1 1 1 1 1 1 1 3π
2
2π π2 π
03313300033 0 0 0 0
12200213321 1 1 1 1
 2 1.25 1.25 2 2 0.75 0 0 0 0.75 0

0 1.25 0.75 2 2 1.25 0 0 2 0.75 2
X1 X2 = −1 0.75 0.25 −1 0 0.75 −1 0 1 0.25 0
−1 0.25 0.25 0 1 0.75 0 1 1 0.75 0

Here, matrix Sparam ∼ (4 × 15) has 15 columns with one column per
boundary segment. Columns from first to eleventh are for straight line
segments and from twelve to fifteen are for circle segments. First and
second rows of Sparam contain parameter values for starting and end-
point of the corresponding segment, third and fourth rows contain la-
bels of the left hand and right hand regions correspondingly. Matrix
X1 X2 ∼ (4 × 11) encodes coordinates of straight line segments with one
column per segment. Here, first two rows are x1 coordinates of starting
and endpoints, and the last two rows are x2 coordinates of line segments
correspondingly. Having matrices Sparam and X1 X2 along with formu-
las (4.1) and (4.2) allows calculating coordinates of any point on the
boundary given an index of boundary segment. In general, quite compli-
cated geometries (not only lines and circles) can be represented through
parametric form and encoded in the similar way.
Here, we introduce a MATLAB function geometryFunction(b index , s)
which returns (x1 , x2 ) coordinates of a boundary point for any segment
with index b index and parameter value s. Parameter b index can be either
scalar or vector and it is allowed to omit parameters. Function call with a
single argument, geometryFunction(b index), returns corresponding entries of
the matrix Sparam with one column for each boundary segment specified
in b index. If the function is called without arguments, geometryFunction(),
it returns total number of boundary segments.
1 function [x1 ,x2]= geometryFunction ( b index , s)
2 % Geometry data
3 s param =[ 0 0 0 0 0 0 0 0 0 0 0 pi 3/2∗ pi 0 pi /2
4 1 1 1 1 1 1 1 1 1 1 1 3/2∗ pi 2∗ pi pi /2 pi
 Building Two-Dimensional Meshes ■ 83

5 0 3 3 1 3 3 0 0 0 3 3 0 0 0 0
6 1 2 2 0 0 2 1 3 3 2 1 1 1 1 1 ];
7 x1x2 =[2 1.25 1.25 2 2 0.75 0 0 0 0.75 0
8 0 1.25 0.75 2 2 1.25 0 0 2 0.75 2
9 −1 0.75 0.25 −1 0 0.75 −1 0 1 0.25 0
10 −1 0.25 0.25 0 1 0.75 0 1 1 0.75 0 ];
11 if nargin ==0 , x1=size( s param ,2); return ; end
12 if nargin ==1 , x1= s param (:, b index ); return ; end
13 x1= zeros (size(s));
14 x2= zeros (size(s));
15 [m,n]= size( b index );
16 if m==1 && n==1, b index = b index ∗ones(size(s)); end
17 if ~ isempty (s),
18 % line segments
19 for k=1:11
20 i=find( b index ==k);
21 if ~ isempty (i)
22 x1(i)= x1x2 (1,k)+( x1x2 (2,k)−x1x2 (1,k))∗ s(i);
23 x2(i)= x1x2 (3,k)+( x1x2 (4,k)−x1x2 (3,k))∗ s(i);
24 end
25 end
26 % circle segments
27 for k =12:15
28 i=find( b index ==k);
29 if ~ isempty (i)
30 c x1 =1; c x2=−0.5; rc =0.25;
31 x1(i)=rc∗cos(s(i))+ c x1 ;
32 x2(i)=rc∗sin(s(i))+ c x2 ;
33 end
34 end
35 end
36 end

Listing 4.1: MATLAB code for generating geometry boundaries.

After defining geometry boundaries, the next step is to perform tri-

angulation to obtain a mesh for the FEM algorithm. Before looking into
specific methods of mesh building, let us first discuss data structures
which are used for triangular mesh representation.
84 ■ Computational Framework for the Finite Element Method

0.5

-0.5

-1
0 0.5 1 1.5 2

FIGURE 4.3: Mesh for example geometry.

4.2 REPRESENTING MESHES IN MATRIX FORM FOR LINEAR IN-

TERPOLATION FUNCTIONS
Above, we have discussed data structures to encode geometry with sub-
domaines definition given in figure 4.1 and boundary segments specifi-
cation given in figure 4.2. The next logical step would be considering
triangulation which is illustrated in figure 4.3 for the example geometry.
In this book, only triangular mesh is used leaving other types beyond
the scope (for example, mesh with rectangular elements).
In this section, we do not consider methods to build a mesh itself but
instead, we are focussed on how the mesh can be represented as a data
structure. It is assumed that there exists a triangular mesh and we want
to encode it. Linear interpolation functions are considered here (with
three interpolation nodes), so triangle vertices are the mesh nodes and
interpolation nodes at the same time. Let us call it G1 mesh stressing
that it is used when solution is approximated by a polynomial of the
first order.
 Building Two-Dimensional Meshes ■ 85

In general, the mesh data structure should serve two main purposes.
Firstly, it should provide information about triangle vertices to allow
performing interpolation on elements. Secondly, it should contain in-
formation about element edges which belong to boundary segments to
correctly apply BC. As such, the mesh data should encapsulate infor-
mation about mesh points, their connectivity to form triangles (finite
elements) and relation between element edges and boundary segments.
One of the most convenient forms of mesh representation which has be-
came an industry standard is a matrix form. Three matrices, P, T and
E , store all necessary information which allow apply FEM interpolation
algorithms. Below we discuss them individually.
Given enumerated np mesh points, let us form a matrix P ∼ (2 × np )
which stores coordinates of mesh points (triangle vertices) so that for
ith point coordinate x1 = P1,i and x2 = P2,i . Matrix P can be used to
access any mesh points but it does not keep any information about mesh
elements formation.
Structure representing how mesh triangles are formed from the set
of vertices is called connectivity matrix, T . Given a number of triangles,
nt , matrix T ∼ (4 × nt ) stores indices of vertices for each triangular ele-
ment and corresponding subdomain label to which this triangle belongs.
Elements T1,j , T2,j and T3,j are the indices of vertices of the j th triangle
(counted anticlockwise), element T4,j is the subdomain label. Note that
the matrix T is formed using indices of points from matrix P , so the
order in which points are arranged in P is important.
The last structure is an edge matrix, E , which stores information
regarding finite element edges belonging to the boundary segments (in-
ternal and external). Given a number of edges, ne , matrix E ∼ (7 × ne )
contains the following information. Elements E1,k and E2,k contain in-
dices of vertices belonging to the k th edge (vertex index with respect
to matrix P ), elements E3,k and E4,k are the corresponding parameter
values s0 and s1 for parametric representation, element E5,k is the index
of boundary segment to which the edge belongs, elements E6,k and E7,k
are the subdomain labels from the left and right hand side of the edge
according to the parameterization direction.
To better understand mesh encoding, let us consider a simple case of
L-shaped geometry given in figure 4.4 with 3 subdomains and 10 bound-
ary segments (8 external and 2 internal segments). Splitting each square
(subdomain) into two triangles results in rough mesh with 6 finite ele-
ments. In figure 4.4, all points and boundary segments are enumerated.
86 ■ Computational Framework for the Finite Element Method

2
1 3 4

10 6
0.5

7 8
2

0 1 8 7
x

1 9 5
-0.5

3 4
-1 2 5 6
-1 -0.5 0 0.5 1
x
1

FIGURE 4.4: L-shaped domain with rough triangulation.

Matrices P, T and E for the mesh shown in figure 4.4 have the form
 
−1 −1 0 1 0 1 1 0
P = ,
0 −1 1 1 −1 −1 0 0
 
1 4 7 2 5 6
2 3 4 5 6 7
T =
8
,
8 8 8 8 8
2 1 1 2 3 3
 
1 3 2 5 6 7 1 8 5 8
2 4 5 6 7 4 8 7 8 3
 
0 0 0 0 0 0 0 0 0 0
 
E=
1 1 1 1 1 1 1 1 1 1.
1 2 3 4 5 6 7 8 9 10
 
2 0 2 3 3 1 0 1 2 0
0 1 0 0 0 0 2 3 3 1
 Building Two-Dimensional Meshes ■ 87

A reader is encouraged to examine matching entries of these matrices

to the mesh element labels in figure 4.4.

4.3 COMPLEMENTARY MESH

Representation of the mesh through matrices (P, T, E) suffices for the
FEM algorithms; however, sometimes the information stored in these
matrices is not enough to answer the following questions:

1. Which elements contain a given mesh point (node)?

2. Which elements share the common edge?

3. If the element’s edge is a boundary one?

To answer these question matrices (P, T, E) should be extended by in-

cluding additional information.
Let us consider 1st question. Connectivity matrix T can be con-
sidered as a compact representation of the extended Boolean matrix
Text ∼ (np × nt ). Each j th column of the matrix Text has three nonzero
(unity) elements located at positions T1,j , T2,j and T3,j . It is not difficult
to see that ith row of the matrix Text has unity on the positions corre-
sponding to the elements having node i as a vertex. Consequently, if we
obtain a sparse representation of the matrix Text (which can be done by
introducing vectors of indices it and pt ) then we are able to resolve 1st
question. This logic is coded through MATLAB function in listing 4.2
which returns sparse format of extended transposed connectivity matrix.
1 function [it ,pt]= extendT (p,t)
2 np=size(p ,2);
3 nt=size(t ,2);
4 j =[1: nt ;1: nt ;1: nt];
5 T ext = sparse (t(1:3 ,:) ,j,1,np ,nt ); % extended connectivity matrix
6 % coordinate form of T_ext
7 [it ,j]= find( T ext ’);
8 pt=find(diff ([0;j;np +1])) ’;
9 end

Listing 4.2: MATLAB code for generating extended transposed connec-

tivity matrix.
88 ■ Computational Framework for the Finite Element Method

Matrix Text for the mesh given in figure 4.4 takes the form
 
1 0 0 0 0 0
1 0 0 1 0 0
 
0 1 0 0 0 0
 
0 1 1 0 0 0
Text = 
0 0
,
 0 1 1 0 
0 0 0 0 1 1
 
0 0 1 0 0 1
1 1 1 1 1 1

and the following piece of code

[it ,pt]= extendT (p,t) ;
for i=1: size(p ,2)
disp ([i,it(pt(i):pt(i+1)−1)’])
end

results in displaying mesh point index and corresponding triangles hav-

ing this point as a vertex.
i it(pt(i):pt(i+1)−1)
1 1
2 1 4
3 2
4 2 3
5 4 5
6 5 6
7 3 6
8 1 2 3 4 5 6

It can be seen that ith mesh node is the vertex of triangles with indices
it(pt(i):pt(i+1)−1).
Resolving 2nd and 3rd questions. Let us introduce two complementary
matrices E c and T c as follows:

• Matrix E c ∼ (7 × nk ) contains information not only about ele-

ment’s edges belonging to boundary segments (like matrix E ), but
information about edges of all elements. Here, nk is the number
c and E c are the
of edges of all finite elements. Components E1,k 2,k
indices of mesh points belonging to k th edge, E3,k
c c
and E4,k are
th
the values of parameter s for the k edge provided it belongs to
boundary segments and E3,k c c
= E4,k c
= 0 otherwise, E5,k is the
 Building Two-Dimensional Meshes ■ 89

segment index, or E5,kc = 0 if the k th edge does not belong to

a boundary segment, E6,kc c
and E7,k are the indices of triangles
(elements) from left and right hand sides of the k th edge.

• Matrix T c ∼ (4 × nt ) contains information regarding indices of

edges and subdomain labels. Components T1,j c , T c and T c are
2,j 3,j
th c
the indices of edges of the j element, T4,j is the subdomain label
to which the j th element belongs.

Three matrices (P, T c , E c ) are complementary to (P, T, E) and contain

full information regarding the mesh (we further call them complemen-
tary G1 mesh). Complementary G1 mesh is convenient when elements are
treated independently. Following MATLAB function complMeshG1() calcu-
lates matrices E c and T c
1 function [ e c , t c ]= complMeshG1 (p,e,t)
2 ne=size(e ,2); nt=size(t ,2);
3 tt=(t(1:3 ,:)) ’;
4 ee = [tt (: ,[1 ,2]); tt (: ,[2 ,3]); tt (: ,[3 ,1])]; % not unique edges
5 [ee ,~,j]= unique (sort(ee ,2) ,’rows ’); % unique mesh edges
6 ee=ee ’; j=j ’; nee=size(ee ,2);
7 mt =1: nt;
8 t c =[j(mt);j(mt+nt);j(mt+2∗ nt )]; % elements edges
9 t c =[ t c ;t(4 ,:)];
10 et= zeros (2, nee ); % edge to element connectivity matrix
11 for k=1: nt
12 for j=1:3
13 it= t c (j,k);
14 if et(1,it )==0 , et(1,it )=k;
15 else et(2,it)=k; end
16 end
17 end
18 % sort first 2 rows of e as in ee
19 for i=1: ne
20 if e(1,i)>e(2,i);
21 c=e(1,i); e(1,i)=e(2,i); e(2,i)=c;
22 c=e(3,i); e(3,i)=e(4,i); e(4,i)=c;
23 c=e(6,i); e(6,i)=e(7,i); e(7,i)=c;
24 end
25 end
26 [~,ib ,it]= intersect (ee ’,e(1:2 ,:) ’ , ’rows ’);
90 ■ Computational Framework for the Finite Element Method

27 % set 3:5 rows of e_c

28 e c =[ee; zeros (5, nee )];
29 e c (3:5 , ib)=e(3:5 , it );
30 % set 6 ,7 rows of e_c
31 for ie =1: nee % ie=edge
32 t1=et(1,ie); t2=et(2,ie ); % neighbour triangles
33 i=ee(1,ie); j=ee(2,ie ); k= setdiff (tt(t1 ,:) ,[i j]);
34 % oriented area of triangle (i,j,k)
35 d12=p(:,j)−p(:,i);
36 d13=p(:,k)−p(:,i);
37 S = d12(1,:). ∗ d13(2,:)− d12(2,:). ∗ d13 (1 ,:);
38 if S>0, e c (6,ie)= t1; e c (7,ie )= t2;
39 else e c (6,ie)=t2; e c (7,ie )= t1; end
40 end
41 end

Listing 4.3: MATLAB code for generating complementary mesh.

Complementary matrices and extended connectivity matrix consid-

ered here give more flexibility in manipulating mesh and allow extracting
more rich information regarding mesh elements which could be helpful
for building refined FEM algorithms.

4.4 BUILDING MESHES IN MATLAB⃝R

Building triangulation in MATLAB for the two-dimensional domain Ω
can be performed using function initmesh() which is part of the pde toolbox
extension of the MATLAB. For example,
[p,e,t]= initmesh (’geometry ’,’Hmax ’ ,0.1);
pdemesh (p,e,t); axis equal ;

Here, function initmesh() builds a mesh defined in the geometry file

’geometry’ and command pdemesh() plots the resulting mesh. Parameter
’Hmax’ defines the maximum edge value of the mesh triangles. Function
initmesh() returns mesh representation in terms of points, edges and con-
nectivity matrices, (p,e,t), described above.
There are two possibilities to define a geometry for the function
initmesh():

• using custom-build function;

• using a matrix (when all segments are lines or ellipse segments).

 Building Two-Dimensional Meshes ■ 91

In order a custom-build function defining geometry to be passed

to the function initmesh() as a parameter, it should have option to re-
turn specific values depending on provided arguments. The function
geometryFunction() for geometry encoding discussed in section 4.1 (see list-
ing 4.1) can be passed to the function initmesh() as an argument and it
meets interface requirements to be processed as a function argument.
For instance, following script generates and plots the mesh shown in
figure 4.3 where the geometry is defined by geometryFunction()
[p,e,t]= initmesh (’geometryFunction ’,’Hmax ’ ,0.1);
pdemesh (p,e,t); axis equal ;

Another option of geometry definition which can be used by initmesh()

function is a matrix where each row must have specific meaning. As an
illustration, the geometry shown in figure 4.2 can be encoded through
the following matrix definition
1 function g= geometryMatrix
2 g=[
3 2 2 2 2 2 2 2 2 2 2 2 4 4 4 4
4 2 1.25 1.25 2 2 0.75 0 0 0 0.75 0 0.75 1 1.25 1
5 0 1.25 0.75 2 2 1.25 0 0 2 0.75 2 1 1.25 1 0.75
6 −1 0.75 0.25 −1 0 0.75 −1 0 1 0.25 0 −0.5 −0.75 −0.5 −0.25
7 −1 0.25 0.25 0 1 0.75 0 1 1 0.75 0 −0.75 −0.5 −0.25 −0.5
8 0 3 3 1 3 3 0 0 0 3 3 0 0 0 0
9 1 2 2 0 0 2 1 3 3 2 1 1 1 1 1
10 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
11 0 0 0 0 0 0 0 0 0 0 0 −0.5 −0.5 −0.5 −0.5
12 0 0 0 0 0 0 0 0 0 0 0 0.25 0.25 0.25 0.25
13 0 0 0 0 0 0 0 0 0 0 0 0.25 0.25 0.25 0.25
14 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
15 ] ;
16 end

Listing 4.4: Example geometry definition using matrix encoding.

The matrix in listing 4.4 contains 15 columns (number of segments)

and each column defines one segment. First element in the column defines
type of the segment (2 is a straight line, 4 is an ellipse); 2th and 3th
(4th and 5th ) elements define x1 (x2 ) coordinates of starting points and
endpoints, respectively; 6th and 7th elements specify labels of left and
right subdomains. Elements from 8 to 12 are for ellipse specification
and can be omitted for straight lines. Elements 8 and 9 define x1 and
92 ■ Computational Framework for the Finite Element Method

x2 coordinates of the ellipse centre; elements 10 and 11 are ellipse’s

semi-axes; 12th element specifies ellipse’s rotation angle (anticlockwise
in radian).1 Following piece of code builds the example mesh shown in
figure 4.3 using geometryMatrix geometry definition.
geometry = geometryMatrix ;
[p, e, t]= initmesh (geometry ,’Hmax ’ ,0.1);
pdemesh (p, e, t); axis equal ;

For better mesh visualization, it is sometimes helpful to display not

only mesh as a set of triangles, but labels for individual triangle vertices
and edges as well. This would improve mesh illustration and facilitate
debugging process for matrix encoding, (p,e,t). Listing 4.5 introduces a
function plotG1mesh() which uses matrices p, e and t to plot labelled tri-
angulation. Function plotG1mesh() has the following parameters: p,e,t are
the matrices defining the mesh, opt is a Boolean vector for option spec-
ification (opt(1)==1 – outputs point labels, opt(2)==1 – outputs boundary
edge labels, opt(3)==1 – outputs triangle labels), and fs is a font size.
1 function h= plotG1mesh (p,e,t,opt ,fs)
2 h= figure ;
3 pdemesh (p,e,t); axis equal ; hold on
4 plot(p(1,:),p(2,:), ’.k’,’MarkerSize ’ ,8)
5 xlabel (’ x 1 ’), ylabel (’ x 2 ’)
6 if opt (1)==1 % output point labels
7 for k=1: size(p ,2)
8 text(p(1,k),p(2,k),[’ ’ int2str (k)], ...
9 ’FontSize ’,fs ,’Color ’,’r’);
10 end
11 end
12 if opt (2)==1 % output boundary labels
13 for k=1: size(e ,2)
14 i=e(1,k); j=e(2,k);
15 x1=(p(1,i)+p(1,j ))/2; x2 =(p(2,i)+p(2,j ))/2;
16 text(x1 ,x2 +0.05 ,[ ’ ’ int2str (e(5,k))], ...
17 ’FontSize ’,fs ,’Color ’,’k’);
18 end
19 end
20 if opt (3)==1 % output element labels
21 for k=1: size(t ,2)

1
The matrix has only 7 rows if all segments are straight lines.
 Building Two-Dimensional Meshes ■ 93

22 I=t(1:3 ,k); x1x2=sum(p(:,I) ’)/3;

23 text(x1x2 (1), x1x2 (2) , int2str (k),’FontSize ’,fs ,’Color ’,’b’);
24 end
25 end
26 end

Listing 4.5: MATLAB code which plots labelled mesh.

The L-shaped labelled geometry shown in figure 4.4 is generated

through the script
[p, e, t]= initmesh (’lshapeg ’,’Hmax ’, inf );
plotG1mesh (p, e, t, [1, 1, 1], 12);

File lshapeg.m for this geometry is provided in the MATLAB pde toolbox
(parameter inf indicates building rough mesh). Figure 4.4 shows trian-
gulation with given labels of triangles, edges and vertices and function
plotG1mesh() plots this triangulation.
Similarly, complementary mesh discussed in section 4.3 can also be
labelled with corresponding indices using following script
[p,e,t]= initmesh (’lshapeg ’,’hmax ’,inf );
[ e c , t c ]= complMeshG1 (p,e,t);
plotComplMeshG1 (p,e,t, e c ,12);

where the function plotComplMeshG1() plots complementary mesh and has

a form given in listing 4.6
1 function h= plotComplMeshG1 (p,e,t, e c ,fs)
2 h= figure ; pdemesh (p,e,t); axis equal ; hold on
3 plot(p(1,:),p(2,:), ’.k’,’MarkerSize ’ ,8);
4 xlabel (’ x 1 ’), ylabel (’ x 2 ’)
5 for i = 1: size(p ,2)
6 text(p(1,i),p(2,i),[’ ’ int2str (i)], ...
7 ’FontSize ’,fs−1,’Color ’,’k’);
8 end
9 for it =1: size( e c ,2) % edge labels
10 i= e c (1,it); j= e c (2,it);
11 text ((p(1,i)+p(1,j))/2 −0.06,(p(2,i)+p(2,j))/2 , ...
12 [’ ’ int2str (it)],’FontSize ’,fs−2,’Color ’,’r’);
13 if e c (5,it);
14 text ((p(1,i)+p(1,j ))/2+0.05 ,( p(2,i)+p(2,j ))/2+0.05 , ...
15 [’ ’ int2str ( e c (5,it))] ,’FontSize ’,fs−2,’Color ’,’k’);
16 end
94 ■ Computational Framework for the Finite Element Method

17 end
18 for i=1: size(t ,2) % element labels
19 I=t(1:3 ,i);
20 text(sum(p(1,I))/3 , sum(p(2,I))/3 , int2str (i), ...
21 ’FontSize ’,fs−1,’Color ’,’b’);
22 end
23 end

Listing 4.6: MATLAB code which plots labelled complementary mesh.

As a result, we obtain figure 4.5 with given indices for mesh points,
triangle elements and edges. Boundary edges are marked with two num-
bers: index of the edge and index of the boundary segment.

4.5 BUILDING MESHES IN PYTHON

Above, we have considered how to define a domain geometry and build
a mesh using MATLAB tools. Now, we explain how to perform mesh
building in Python. Again, the approach is to use third-party library

2
1 3 5 4

2
10 6
0.5 6 8 7

7 8
2

0 1 2 8 13 7
x

1 6
1 9 5
-0.5 1 4 10 12 11

4 5

3 4
-1 2 3 5 9 6
-1 -0.5 0 0.5 1
x
1

FIGURE 4.5: Complementary mesh.

 Building Two-Dimensional Meshes ■ 95

for mesh processing rather than discussing particular mesh building al-
gorithm. There is a powerful mesh generation tool, named Gmsh, having
its own scripting language allowing creating complex geometries. The
library PyGmsh provides a Python interface for the Gmsh scripting language
so one can create geometry and generate meshes more easily with excess
to Python’s features. After installing PyGmsh, the default Gmsh kernel with
basic geometry construction functions can be used.
Module PyGmsh has a class Geometry to represent a geometry in the
following way: first, it is to be defined points (using the method
add point), then lines (using add line, add circle,add circle arc, add line loop,
etc.), and finally surfaces (using add plane surface method). These geomet-
rical entities are assigned identification numbers when they are created.
Groups of geometrical entities can be defined (using add physical line or
add physical surface methods) and are called physical entities with unique
identification numbers. The purpose of these physical entities is to assem-
ble geometrical entities into larger groups so that they can be referred
to by the mesh module as single entities. In terms of domain geome-
try definitions, physical entities can be viewed as labelled boundaries or
subdomains on which boundary conditions or coefficients are defined. As
an example, script in listing 4.7 defines geometry illustrated in figures
4.2 and 4.3. Function geometry() has a parameter h – mesh triangular size,
and returns two structures: geometry object, geom, and labels of geometry
elements, geom labels.
1 import pygmsh
2 import numpy
3 def geometry (h):
4 geom = pygmsh . built in . Geometry () # initialize geometry object
5 #rectangular #1
6 rect1 p1 =geom. add point ([0.0 , −1.0, 0.0] , h)
7 rect1 p2 =geom. add point ([0.0 , 0.0, 0.0] , h)
8 rect1 p3 =geom. add point ([2.0 , 0.0, 0.0] , h)
9 rect1 p4 =geom. add point ([2.0 , −1.0, 0.0] , h)
10 rect1 l1 =geom. add line ( rect1 p1 , rect1 p2 )
11 rect1 l2 =geom. add line ( rect1 p2 , rect1 p3 )
12 rect1 l3 =geom. add line ( rect1 p3 , rect1 p4 )
13 rect1 l4 =geom. add line ( rect1 p4 , rect1 p1 )
14 # circular hole
15 cirlcle p0 =geom. add point ([1.0 , −0.5, 0.0] , h) #center
16 cirlcle p1 =geom. add point ([0.75 , −0.5, 0.0] , h)
96 ■ Computational Framework for the Finite Element Method

17 cirlcle p2 =geom. add point ([1.0 , −0.75, 0.0] , h)

18 cirlcle p3 =geom. add point ([1.25 , −0.5, 0.0] , h)
19 cirlcle p4 =geom. add point ([1.0 , −0.25, 0.0] , h)
20 arc 1 =geom. add circle arc ( cirlcle p1 , cirlcle p0 , cirlcle p2 )
21 arc 2 =geom. add circle arc ( cirlcle p2 , cirlcle p0 , cirlcle p3 )
22 arc 3 =geom. add circle arc ( cirlcle p3 , cirlcle p0 , cirlcle p4 )
23 arc 4 =geom. add circle arc ( cirlcle p4 , cirlcle p0 , cirlcle p1 )
24 rect1 line =geom. add line loop ([ rect1 l1 , rect1 l2 , \
25 rect1 l3 , rect1 l4 , \
26 arc 1 , arc 2 , arc 3 , arc 4 ])
27 #rectangle #2
28 rect2 p1 =geom. add point ([0.75 , 0.25 , 0.0] , h)
29 rect2 p2 =geom. add point ([0.75 , 0.75 , 0.0] , h)
30 rect2 p3 =geom. add point ([1.25 , 0.75 , 0.0] , h)
31 rect2 p4 =geom. add point ([1.25 , 0.25 , 0.0] , h)
32 rect2 l1 =geom. add line ( rect2 p1 , rect2 p2 )
33 rect2 l2 =geom. add line ( rect2 p2 , rect2 p3 )
34 rect2 l3 =geom. add line ( rect2 p3 , rect2 p4 )
35 rect2 l4 =geom. add line ( rect2 p4 , rect2 p1 )
36 rect2 line =geom. add line loop ([ rect2 l1 , rect2 l2 , \
37 rect2 l3 , rect2 l4 ])
38 #rectangle #3
39 rect3 p1 =geom. add point ([0.0 , 0.0, 0.0] , h)
40 rect3 p2 =geom. add point ([0.0 , 1.0, 0.0] , h)
41 rect3 p3 =geom. add point ([2.0 , 1.0, 0.0] , h)
42 rect3 p4 =geom. add point ([2.0 , 0.0, 0.0] , h)
43 rect3 l1 =geom. add line ( rect3 p1 , rect3 p2 )
44 rect3 l2 =geom. add line ( rect3 p2 , rect3 p3 )
45 rect3 l3 =geom. add line ( rect3 p3 , rect3 p4 )
46 rect3 l4 =geom. add line ( rect3 p4 , rect3 p1 )
47 rect3 line =geom. add line loop ([ rect3 l1 , rect3 l2 , \
48 rect3 l3 , rect3 l4 , rect2 l1 , \
49 rect2 l2 , rect2 l3 , rect2 l4 ])
50 #create surfaces
51 rect1 surf =geom. add plane surface ( rect1 line )
52 rect3 surf =geom. add plane surface ( rect3 line )
53 rect2 surf =geom. add plane surface ( rect2 line )
54 # define labels for geometry elements:
55 geom labels={}
56 group id =geom. TAKEN PHYSICALGROUP IDS
 Building Two-Dimensional Meshes ■ 97

57 # domain labels
58 ph rect1 surf =geom. add physical surface ( rect1 surf , label ="1")
59 geom labels [ group id[−1]]="1"
60 ph rect2 surf =geom. add physical surface ( rect2 surf , label ="2")
61 geom labels [ group id[−1]]="2"
62 ph rect3 surf =geom. add physical surface ( rect3 surf , label ="3")
63 geom labels [ group id[−1]]="3"
64 # boundary labels
65 ph rect1 l1 =geom. add physical line ( rect1 l1 , label ="7: L0:R1")
66 geom labels [ group id[−1]]="7: L0:R1"
67 ph rect1 l2 =geom. add physical line ( rect1 l2 , label ="11: L3:R1")
68 geom labels [ group id[−1]]="11: L3:R1"
69 ph rect1 l3 =geom. add physical line ( rect1 l3 , label ="4: L0:R1")
70 geom labels [ group id[−1]]="4: L0:R1"
71 ph rect1 l4 =geom. add physical line ( rect1 l4 , label ="1: L0:R1")
72 geom labels [ group id[−1]]="1: L0:R1"
73 ph rect2 l1 =geom. add physical line ( rect2 l1 , label ="10: L3:R2")
74 geom labels [ group id[−1]]="10: L3:R2"
75 ph rect2 l2 =geom. add physical line ( rect2 l2 , label ="6: L3:R2")
76 geom labels [ group id[−1]]="6: L3:R2"
77 ph rect2 l3 =geom. add physical line ( rect2 l3 , label ="2: L3:R2")
78 geom labels [ group id[−1]]="2: L3:R2"
79 ph rect2 l4 =geom. add physical line ( rect2 l4 , label ="3: L3:R2")
80 geom labels [ group id[−1]]="3: L3:R2"
81 ph rect3 l1 =geom. add physical line ( rect3 l1 , label ="8: L0:R3")
82 geom labels [ group id[−1]]="8: L0:R3"
83 ph rect3 l2 =geom. add physical line ( rect3 l2 , label ="9: L0:R3")
84 geom labels [ group id[−1]]="9: L0:R3"
85 ph rect3 l3 =geom. add physical line ( rect3 l3 , label ="5: L0:R3")
86 geom labels [ group id[−1]]="5: L0:R3"
87 p h a r c 1 =geom. add physical line ( arc 1 ,label ="12: L0:R1")
88 geom labels [ group id[−1]]="12: L0:R1"
89 p h a r c 2 =geom. add physical line ( arc 2 ,label ="13: L0:R1")
90 geom labels [ group id[−1]]="13: L0:R1"
91 p h a r c 3 =geom. add physical line ( arc 3 ,label ="14: L0:R1")
92 geom labels [ group id[−1]]="14: L0:R1"
93 p h a r c 4 =geom. add physical line ( arc 4 ,label ="15: L0:R1")
94 geom labels [ group id[−1]]="15: L0:R1"
98 ■ Computational Framework for the Finite Element Method

95 return geom , geom labels

Listing 4.7: Python code for defining example geometry.

Let us make some comments regarding defining labels for the geom-
etry elements. Subdomains are labelled by numbers, but for labelling a
boundary (see lines 65 –94) we use group of colon-separated three labels:
a number, letter L with a number and letter R with a number. Here, first
number is the boundary label and subsequent numbers are subdomain
labels from left (letter L) and right (letter R) hand sides of the boundary.
These labels are assigned to physical groups of the geometry and kept
in the dictionary geom labels which maps identification number of each
physical group to the specified label. Group identification numbers are
generated automatically and kept in the list TAKEN PHYSICALGROUP IDS of the
class Geometry.
The next step is to generate a mesh and retrieve triangulation data
for p,t,e matrices (see section 4.2 for detailed explanation of data struc-
ture p,t,e ). Function generateMesh() in listing 4.8 creates matrices of point
coordinates, p, connectivity, t and edges e which have same structure as
described in section 4.2. It has two parameters: geom – geometry object
defining geometry structure, and geom labels – a structure containing la-
bels for geometry elements (these structures are created by geometry()
function), and returns matrices (p,t,e).
1 import pygmsh
2 import numpy
3 def generateMesh (geom , geom labels ):
4 # generate mesh
5 points , cells , point data , cell data , field data = \
6 pygmsh . generate mesh (geom)
7 #extract p,t,e matrices
8 p= points [: ,0:2]
9 t=numpy.zeros (( cells [" triangle "]. shape [0] ,4))
10 e=numpy.zeros (( cells ["line"]. shape [0] ,7))
11 t[: ,0:3]= cells[" triangle "]
12 e[: ,0:2]= cells["line"]
13 for label in field data :
14 elemnt index = field data [ label ][0]
15 group index = field data [ label ][1]
16 names=list( cell data .keys ())
17 if names[ group index −1]==" triangle ": # domain labels
18 t[ cell data [" triangle "] \
 Building Two-Dimensional Meshes ■ 99

19 ["gmsh: physical "]== elemnt index ,3]= \

20 int( geom labels [ elemnt index ])
21 elif names[ group index −1]=="line": # boundary labels
22 label=None
23 left label =None
24 right label =None
25 for item in geom labels [ elemnt index ]. split (":"):
26 if item [0]== "L": left label =int(item [1:])
27 elif item [0]=="R": right label =int(item [1:])
28 else: label =int(item)
29 if label == None or \
30 left label == None or \
31 right label == None:
32 print (’error , wrong geometry boundary labelling ’)
33 index= cell data ["line"]["gmsh: physical "]== elemnt index
34 e[index ,4]= label
35 e[index ,5]= left label
36 e[index ,6]= right label
37 return p,t. astype (int),e. astype (int)

Listing 4.8: Python code for building a mesh from given geometry.

It is worth noting that as we will see later, elements of the edge

matrix, e, corresponding to geometry parameter values generated by the
MATLAB initmesh() function are not in use in FEM framework, as such,
to be consistent, in listing 4.8, we keep the same number of rows in
matrix e but not filling those for parameter values of edges.
As a result, the mesh illustrated in figure 4.3 can be generated
through running the script
geom , geom labels = geometry (0.5)
p,t,e = generateMesh (geom , geom labels )
 CHAPTER 5

Programming
Two-Dimensional Finite
Element Method

n this chapter we will consider five different methods of assembling

I global stiffness matrix and global force vector with evaluation of com-
putational cost, efficiency and performance of each method in details.
First, we will be focussed on matrices assembling technique, not on cal-
culating matrices elements, and assuming generic local stiffness matrix
to be a unity matrix. Further, we will consider methods for calculat-
ing elements of local stiffness matrices and local forcing vectors. Also, it
will be shown how to incorporate boundary conditions into FEM. De-
scription given in this chapter will involve some mathematical analysis
which is important to understand computational techniques. Numerical
methods for calculating integrals, function transformations and operat-
ing with basis functions will be used to deduce algorithms for calculating
local FEM matrices.

5.1 ASSEMBLING GLOBAL STIFFNESS MATRIX

Let us consider assembling global stiffness matrix for G1 triangular mesh
corresponding to a square domain. Triangulation is represented in terms
of matrices (p,e,t). It is important to mention that t(1:3,it) stores global
node indices for the element having index it. Local stiffness matrices
could be assembled into the global one through the following five meth-
ods.

DOI: 10.1201/9781003265979-5 101

102 ■ Computational Framework for the Finite Element Method

1st algorithm (inefficient). This algorithm is based on the definition

of global stiffness matrix and assembles the stiffness matrix element by
element, but it is computationally inefficient and not recommended for
practical use in MATLAB.
1 function A= stiffnessAssemb 1 (p,t)
2 np=size(p ,2) ;
3 nt=size(t ,2) ;
4 ntep =3; % number of triangular element points
5 A= sparse (np ,np) ; % global stiffness matrix
6 Al=ones(ntep ,ntep) ; % local stiffness matrix
7 for k=1: nt
8 I=t(1: ntep ,k) ; % global point indices on element k
9 for i=1: ntep
10 for j=1: ntep
11 A(I(i),I(j))=A(I(i),I(j))+ Al(i,j) ;
12 end
13 end
14 end
15 end

Listing 5.1: First version of the code for assembling stiffness matrix which
uses element by element strategy.

2nd algorithm (partly optimized). This is a vectorized version of the

previous algorithm and it is suitable for meshes with small number of
elements.
1 function A= stiffnessAssemb 2 (p,t)
2 np=size(p ,2) ;
3 nt=size(t ,2) ;
4 ntep =3;
5 A= sparse (np ,np) ; % global stiffness matrix
6 Al=ones(ntep ,ntep) ; % local stiffness matrix
7 for k=1: nt
8 I=t(1: ntep ,k) ;
9 A(I,I)=A(I,I)+Al ; % assembling matrix
10 end
11 end

Listing 5.2: Second version of the code for assembling stiffness matrix
which uses partly vectorized approach.
 Programming Two-Dimensional Finite Element Method ■ 103

3d algorithm (optimized). This algorithm is based on assembling the

stiffness matrix in the coordinate form.
1 function A= stiffnessAssemb 3 (p,t)
2 np=size(p ,2) ;
3 nt=size(t ,2) ;
4 ntep =3;
5 ntep2=ntep ^2; % number of local stiffness matrix elements
6 m=ntep2∗nt ; % number of elemnts of all local matrices
7 % coordinates representation of matrix A
8 i= zeros (m ,1) ;
9 j= zeros (m ,1) ;
10 v=ones(m ,1) ;
11 Al=rand(ntep ,ntep) ; % local stiffness matrix
12 % assembling matrix A in coordinate form (i,j,v)
13 for k=1: nt
14 I=t(1: ntep ,k) ;
15 il= repmat (I(:) ,1, ntep) ;
16 jl=il ’;
17 m=ntep2 ∗(k −1)+(1:ntep2 ) ;
18 i(m)=il (:) ;
19 j(m)=jl (:) ;
20 v(m)=Al (:) ;
21 end
22 A= sparse (i,j,v,np ,np) ;
23 end

Listing 5.3: Third version of the code for assembling stiffness matrix
which uses coordinate form of sparse matrix.

Some comments are to be mentioned here. For any matrix B, index-

ing like B(:) transforms the matrix into a column of the length numel(B).
Element Al(i,j) should be added to the corresponding positions of ma-
trix A. As such, instructions i(m)=il(:) ; j(m)=jl(:) ; v(m)=Al(:) transform
matrices il, jl and Al into columns and assign them to the corresponding
elements of the vectors i, j and v.
4th algorithm (most efficient). This algorithm is based on fully vec-
torized form of assembling global stiffness matrix
1 function A= stiffnessAssemb 4 (p,t)
2 np=size(p ,2) ;
3 nt=size(t ,2) ;
104 ■ Computational Framework for the Finite Element Method

4 %indices of local points

5 k1=t(1 ,:) ;
6 k2=t(2 ,:) ;
7 k3=t(3 ,:) ;
8 % aij(m)=Al(i,j) on element m
9 a12=ones(nt ,1) ; A= sparse (k1 ,k2 ,a12 ,np ,np) ;
10 a13=ones(nt ,1) ; A=A+ sparse (k1 ,k3 ,a13 ,np ,np) ;
11 a23=ones(nt ,1) ; A=A+ sparse (k2 ,k3 ,a23 ,np ,np) ;
12 % replace next 3 lines by A=A+A.’ for symmetric A
13 a21=ones(nt ,1) ; A=A+ sparse (k2 ,k1 ,a21 ,np ,np) ;
14 a31=ones(nt ,1) ; A=A+ sparse (k3 ,k1 ,a31 ,np ,np) ;
15 a32=ones(nt ,1) ; A=A+ sparse (k3 ,k2 ,a32 ,np ,np) ;
16 a11=ones(nt ,1) ; A=A+ sparse (k1 ,k1 ,a11 ,np ,np) ;
17 a22=ones(nt ,1) ; A=A+ sparse (k2 ,k2 ,a22 ,np ,np) ;
18 a33=ones(nt ,1) ; A=A+ sparse (k3 ,k3 ,a33 ,np ,np) ;
19 end

Listing 5.4: Fourth version of the code for assembling stiffness matrix
which uses fully vectorized approach.
Function stiffnessAssemb 4() is loop free and operates only with vec-
tors. For the symmetric matrix A the algorithm could be more memory
efficient (in this case some of aij can be replaced by a single vector and
A=A+A.’). We can avoid vectorization of the local stiffness matrices in func-
tion stiffnessAssemb 4() and save some memory. For example, the following
version of assembling algorithm is comparable in terms of computational
cost with the previous one
1 function A= stiffnessAssemb 5 (p,t)
2 np=size(p ,2) ;
3 nt=size(t ,2) ;
4 ntep =3;
5 %indices of local points
6 k1=t(1 ,:) ;
7 k2=t(2 ,:) ;
8 k3=t(3 ,:) ;
9 Al=ones(nt ,ntep ,ntep) ; % all local stiffness matrices
10 A= sparse (k1 ,k2 ,Al (: ,1 ,2) ,np ,np) ;
11 A=A+ sparse (k1 ,k3 ,Al (: ,1 ,3) ,np ,np) ;
12 A=A+ sparse (k2 ,k3 ,Al (: ,2 ,3) ,np ,np) ;
13 % replace next 3 lines by A=A+A.’for symmetric A
14 A=A+ sparse (k2 ,k1 ,Al (: ,2 ,1) ,np ,np) ;
 Programming Two-Dimensional Finite Element Method ■ 105

15 A=A+ sparse (k3 ,k1 ,Al (: ,3 ,1) ,np ,np) ;

16 A=A+ sparse (k3 ,k2 ,Al (: ,3 ,2) ,np ,np) ;
17 A=A+ sparse (k1 ,k1 ,Al (: ,1 ,1) ,np ,np) ;
18 A=A+ sparse (k2 ,k2 ,Al (: ,2 ,2) ,np ,np) ;
19 A=A+ sparse (k3 ,k3 ,Al (: ,3 ,3) ,np ,np) ;
20 end

Listing 5.5: Fifth version of the code for assembling stiffness matrix which
uses fully vectorized approach with improved memory usage efficiency.

Let us compare computational efficiency of all assembling algorithms

with the help of the function testAssembStiffness() in listing 5.6.
1 function testAssembStiffness
2 clc
3 % assembling time
4 time 1 =[] ; time 2 =[] ; time 3 =[] ; time 4 =[] ; time 5 =[] ;
5 nt =[] ; np =[] ;
6 for nx =[10 50 100]
7 % set a mesh of rectangular domain
8 [p,e,t] = poimesh (’squareg ’,nx ,nx) ;
9 np=[np size(p ,2)] ;
10 nt=[nt size(t ,2)] ;
11 tic , stiffnessAssemb 1 (p,t) ; time 1 =[ time 1 toc] ;
12 tic , stiffnessAssemb 2 (p,t) ; time 2 =[ time 2 toc] ;
13 tic , stiffnessAssemb 3 (p,t) ; time 3 =[ time 3 toc] ;
14 tic , stiffnessAssemb 4 (p,t) ; time 4 =[ time 4 toc] ;
15 tic , stiffnessAssemb 5 (p,t) ; time 5 =[ time 5 toc] ;
16 end
17 disp(’np nt ver 1 ver 2 ver 3 ver 4 ver 5 ’)
18 disp ([np ’ nt ’ time 1 ’ time 2 ’ time 3 ’ time 4 ’ time 5 ’])
19 end

Listing 5.6: Script for comparing efficiency of various stiffness matrix

assembling strategies.

Table 5.1 summarizes results of the computational efficiency test.

We can conclude that the CPU time for the first and second versions
of the function stiffnessAssemb() is proportional to the square of nodes
number while CPU time for the third, fourth and fifth versions of the
assembling algorithm are practically proportion to the number of mesh
nodes. Algorithms of ver 4 and ver 5 are faster than ver 3 since they do
106 ■ Computational Framework for the Finite Element Method

TABLE 5.1: Summary of the computational efficiency test. Last five

columns contain CPU time for corresponding version of the stiffness
matrix assembling algorithm.

np nt ver 1 ver 2 ver 3 ver 4 ver 5

121 200 0.04883 0.00586 0.05566 0.0 0.0
2601 5000 1.85449 0.66308 1.36817 0.00293 0.00293
10201 20000 17.21289 8.50488 5.65820 0.01270 0.01367

not contain loops. As a result, it is recommended to use vectorized form

of the global matrix assembling algorithm.
For arbitrary finite elements (not necessarily triangle) we recommend
using generic function shown in listing 5.7 for assembling global stiffness
matrix (provided there is a function calcLocalStiffness() to compute a
local stiffness matrix). Here, p is a matrix of points, t is a matrix of
elements, and ntep is a number of element’s points.
1 function A= stiffnessAssembGeneric (ntep ,p,t)
2 np=size(p ,2) ;
3 nt=size(t ,2) ;
4 Al= zeros (ntep ,ntep ,nt) ; % all local stiffness matrices
5 for k=1: nt
6 Al(k ,: ,:)= calcLocalStiffness (k,p,t) ; % local stiffness matrix
7 end
8 A= sparse (np ,np) ; % global matrix
9 for i=1: ntep
10 for j=1: ntep
11 A=A+ sparse (t(i,:) ,t(j ,:) , Al(:,i,j),np ,np) ;
12 end
13 end
14 end

Listing 5.7: Version of the code for assembling stiffness matrix with finite
elements of arbitrary shape.

5.2 ASSEMBLING GLOBAL FORCING VECTOR

Assembling global forcing vector, F , is performed in a similar to global
stiffness matrix way. Three methods of assembling could be used de-
pending on the possibility to vectorize calculations. Functions below im-
plement these methods.
 Programming Two-Dimensional Finite Element Method ■ 107

1 function F= forcingAssemb 1 (p,t)

2 np=size(p ,2) ; nt=size(t ,2) ;
3 k1=t(1 ,:) ; k2=t(2 ,:) ; k3=t(3 ,:) ;
4 % Fl - local forcing vector
5 %fj(m)= Fl(j) on element m,
6 f1=ones(nt ,1) ; F= sparse (k1 ,1,f1 ,np ,1) ;
7 f2=ones(nt ,1) ; F=F+ sparse (k2 ,1,f2 ,np ,1) ;
8 f3=ones(nt ,1) ; F=F+ sparse (k3 ,1,f3 ,np ,1) ;
9 end

Listing 5.8: Version of the code for assembling forcing vector which uses
fully vectorized approach.

1 function F= forcingAssemb 2 (p,t)

2 np=size(p ,2) ; nt=size(t ,2) ;
3 k1=t(1 ,:) ; k2=t(2 ,:) ; k3=t(3 ,:) ;
4 Fl=ones(nt ,3) ; % all local forcing vectors
5 F= sparse (k1 ,1,Fl(:,1) ,np ,1);
6 F=F+ sparse (k2 ,1,Fl(: ,2) ,np ,1) ;
7 F=F+ sparse (k3 ,1,Fl(: ,3) ,np ,1) ;
8 end

Listing 5.9: Version of the code for assembling forcing vector which uses
fully vectorized approach with improved memory usage efficiency.

1 function F= forcingAssemb 3 (p,t)

2 np=size(p ,2); nt=size(t ,2) ; ntep =3;
3 F= zeros (np ,1) ;
4 for k=1: nt
5 I=t(1: ntep ,k) ;
6 Fl=ones(ntep ,1) ;
7 F(I)=F(I)+Fl ;
8 end
9 end

Listing 5.10: Version of the code for assembling forcing vector with finite
elements of arbitrary shape.

To test performance let us run the following script

% testing forcing vector assembling functions
time 1 =[] ; time 2 =[] ; time 3 =[] ; % assembling times
nt =[] ; np =[] ;
108 ■ Computational Framework for the Finite Element Method

for nx =[10 50 100]

% set a mesh on the domain
[p,~,t]= poimesh (’squareg ’,nx ,nx) ;
np=[np size(p ,2)] ; nt =[ nt size(t ,2)] ;
tic ; F= forcingAssemb 1 (p,t) ; time 1 =[ time 1 toc] ;
tic ; F= forcingAssemb 2 (p,t) ; time 2 =[ time 2 toc] ;
tic ; F= forcingAssemb 3 (p,t) ; time 3 =[ time 3 toc] ;
end
disp(’np nt ver 1 ver 2 ver 3 ’)
disp ([np ’ nt ’ time 1 ’ time 2 ’ time 3 ’])

which results in table 5.2. It follows from table 5.2 that computational
cost for the third method five times higher compared with first or second
method.

5.3 CALCULATING LOCAL STIFFNESS MATRICES

Let us consider calculating local stiffness matrix corresponding to a tri-
angular element τ (here we drop the index l implying that τ could be
any element from τl defined above). Components of the local matrix Āαβ
with indices α, β = 1, 2, 3 are defined as
Z


Āαβ = c∇φiβ · ∇φiα + b · ∇φiβ φiα + aφiβ φiα dx. (5.1)
τ

Here, i1 , i2 and i3 are the vertices indices of the element τ , and

φi1 , φi2 and φi3 are the corresponding basis functions (note that
(i1 , i2 , i3 ) is a column of matrix t). Figure 5.1 shows the element τ with
notation. To compute integral (5.1) we need expressions for the basis
functions and their gradients along with numerical method for integral
calculation.

TABLE 5.2: Summary of the computational efficiency test for the algo-
rithm of assembling global forcing vector. Last three columns contain
CPU time for the corresponding version of the algorithm.

np nt ver 1 ver 2 ver 3

121 200 0.0 0.00098 0.00879
2601 5000 0.00098 0.00098 0.13281
10201 20000 0.00293 0.00195 0.52637
 Programming Two-Dimensional Finite Element Method ■ 109

FIGURE 5.1: Triangular element τ and basis function φi1 .

We consider two possible methods of calculating integral (5.1). First

method is based on the assumption that coefficients c(x), b(x) and a(x)
are constant over the element τ and equal to the values computed at the
element’s centre of mass, pτ = (pi1 +pi2 +pi3 )/3. In this case the integral
is computed analytically (provided expressions for the basis functions are
known) through the formula
Z


Āαβ = c(pτ )∇φiβ · ∇φiα + b(pτ ) · ∇φiβ φiα + a(pτ )φiβ φiα dx.
τ
(5.2)
Second method makes use of the quadrature formula with one node
which is faithful representation for linear polynomial integrand


Āαβ = |τ | c∇φiβ · ∇φiα + b · ∇φiβ φiα + aφiβ φiα (pτ ), (5.3)

where |τ | is the area of the element τ .

Next, we consider representation of the basis functions on the element
τ . To obtain expressions for the basis functions we use an approach which
is equally applicable to any type of triangular elements with straight line
edges (for example, triangular elements with six nodes or G2 elements).
The main idea is to consider a canonical element τ̂ in the coordinate
system x̂ = (x̂1 , x̂2 ) on which basis functions take simple known form.
Then the basis functions for the element τ are derived through coor-
dinate transformation. To illustrate this approach, let us consider two
elements shown in figure 5.2, where the canonical element has vertices
coordinates pˆ1 = (0, 0), pˆ2 = (1, 0), pˆ3 = (0, 1) and an arbitrary
110 ■ Computational Framework for the Finite Element Method

FIGURE 5.2: Canonical element τ̂ and original G1 mesh element τ .

three-nodes element τ has vertices p1 , p2 and p3 . In this case, the fol-

lowing functions

φ̂1 (x̂) = 1 − x̂1 x̂2 , φ̂2 (x̂) = x̂1 , φ̂3 (x̂) = x̂2
represent basis functions on element τ̂ , and it is clear that φ̂i (pˆj ) = δij .
Transformation from τ̂ to τ is given by

x = p1 φ̂1 + p2 φ̂1 + p3 φ̂1 = p1 + x̂1 (p2 − p1 ) + x̂2 (p3 − p1 ). (5.4)

Indeed, this is an affine transformation which maps vertices of τ̂ to the

vertices of τ with preserving orientation of the canonical element and
(0, 0) → p1 , (1, 0) → p2 , (0, 1) → p3 . After introducing notation
 
(p2 − p1 )1 (p3 − p1 )1
Bτ = , (5.5)
(p2 − p1 )2 (p3 − p1 )2

transformation can be rewritten in matrix form

x = Bτ x̂ + p1 : τ̂ → τ (5.6)

with Jacobian determinant Jτ = det Bτ > 0. As a result, the area of

element τ is defined as
Z Z
1
|τ | = dx = det Bτ dx̂ = |τ̂ | det Bτ = Jτ .
2
τ τ

Inverse transformation has a form of x̂ = Bτ−1 (x − p1 ) with

   
1 (p3 − p1 )2 −(p3 − p1 )1 d˜ −b̃
Bτ−1 = = .
det Bτ −(p2 − p1 )2 (p2 − p1 )1 −c̃ ã
 Programming Two-Dimensional Finite Element Method ■ 111

Consequently,

x̂1 = d˜(x1 − (p1 )1 ) − b̃ (x2 − (p1 )2 ) ,

x̂2 = −c̃ (x1 − (p1 )1 ) + ã (x2 − (p1 )2 ) .

Basis functions φi (x) on the element τ are obtained from the ba-
sis functions on the element τ̂ through the transformation φi (x) =
φ̂i (Bτ−1 (x − p1 )). As a result,

φ1 (x) = 1 − φ2 (x) − φ3 (x),

φ2 (x) = d˜(x1 − (p1 )1 ) − b̃ (x2 − (p1 )2 ) ,
φ3 (x) = −c̃ (x1 − (p1 )1 ) + ã (x2 − (p1 )2 ) .

Respectively, gradients of the basis functions have the form

     
c̃ − d˜ d˜ −c̃
∇φ1 = , ∇φ2 = , ∇φ3 = .
b̃ − ã −b̃ ã

It is worth noting that φi (pτ ) = 1/3, i = 1, 2, 3, and for gradients we

have
∇φi (x) = Bτ−1 ∇
T ˆ
φ̂i (x̂).
Also, the following expressions are valid for the elements τ of any type
X
mτ X
mτ
φi (x) = 1, ∇φi (x) = (0, 0)T , x ∈ τ,
i=1 i=1

where mτ is the number of interpolation nodes belonging to the element

τ.
By this point, we have obtained all expressions to calculate elements
of the local stiffness matrix. Now, let us consider methods for calculation
of the integral (5.1) mentioned above. Since the basis φiα are linear
functions, then ∇φiα are constants and (5.1) can be rewritten as
Z Z
Āαβ = c(pτ )∇φiβ · ∇φiα dx + b(pτ ) · ∇φiβ φiα dx
τ τ
Z
+ a(pτ ) φiβ φiα dx = |τ |c(pτ )∇φiβ · ∇φiα
τ
Z Z
+ b(pτ ) · ∇φiβ Jτ φ̂iα dx̂ + a(pτ )Jτ φ̂iβ φ̂iα dx̂. (5.7)
τ̂ τ̂
112 ■ Computational Framework for the Finite Element Method

First integral on the right hand side of the expression (5.7) being calcu-
lated either analytically or numerically using quadrature formula with
one node results in the value of 1/6, and we come to the expression
  Z
1
Āαβ = |τ | c(pτ )∇φiβ · ∇φiα + b(pτ ) · ∇φiβ + a(pτ )Jτ φ̂iβ φ̂iα dx̂.
3
τ̂
The last integral results in different answers depending on the applied
calculation methods. When using quadrature formula the answer is
Z Z 1 1

18
φ̂iβ φ̂iα dx̂ = φ̂iβ (pˆτ ) φ̂iα (pˆτ ) dx̂ = 1 18 ,
1
18 18
τ̂ τ̂
but applying analytical integration gives
Z 1 1

φ̂iβ φ̂iα dx̂ = 12
1
24
1 .
24 12
τ̂
Next, we consider calculation of the local forcing vector on the ele-
ment τ Z
F̄α = f (x)φiα (x)dx.
τ
Both, analytical integration and quadrature method, lead to the same
result, namely
1
F̄α = Jτ f (pτ ), α = 1, 2, 3.
6
Regarding calculation boundary integrals
Z Z
S̄αβ = σ(x)φiα φiβ dx, M̄α = µ(x)φiα (x)dx, (5.8)
e e
which are associated with the boundary conditions on the edge e having
the vertex indices i1 and i2 , we can apply both approaches mentioned
above. For the components of the vector M we come to the same expres-
sion regardless of the integration method, M̄α = |e|/2µ(pe ), α = 1, 2,
where |e| is the length of the edge e and pe is the midpoint of the edge.
For the matrix S̄ we obtain two results depending on the calculation
method. In case of analytical integration we have
1 1
S̄αβ = |e|µ(pe ) 13 61 .
6 3

Integration using quadrature formula gives S̄αβ = (|e|/4)µ(pe ), where

the fact φiα (pe ) = 1/2 is taken into account.
 Programming Two-Dimensional Finite Element Method ■ 113

5.4 CALCULATING EQUATION COEFFICIENTS

Stiffness matrices depend on the coefficients of the partial differential
equation (c, b, a, f ) and we need to decide how to incorporate calculation
of these coefficients into FEM. Note that the equation coefficients could
be piecewise functions on subdomains. Recall that the domain Ω where
the solution is sought could consist of subdomains. Each subdomain is
supposed to have unique label, sdl, and this label can be retrieved from
the connectivity matrix t so that sdl=t(4,:). As such, each element ’knows’
about subdomain to which it belongs. We can construct a function which
takes as an input subdomain label sdl and performs calculation of the
coefficient, for example, if we have three subdomains Ω1 , Ω2 , Ω3 , and
coefficient c is defined as


1, p ∈ Ω1 ,
c(p) = x21 + x2 , p ∈ Ω2 ,


sin(x1 + x2 ), p ∈ Ω3 ,

then the function in listing 5.11 calculates the coefficient c.

1 function f= c coeff def (x1 ,x2 ,sdl)
2 f= zeros (size(x1)) ;
3 % 1-st subdomain
4 I=find(sdl ==1); f(I)=1;
5 % 2-nd subdomain
6 I=find(sdl ==2); f(I)=x1(I ).^2+ x2(I) ;
7 % 3-d subdomain
8 I=find(sdl ==3); f(I)= sin(x1(I)+x2(I)) ;
9 end

Listing 5.11: MATLAB code for calculating equation coefficient.

This function can be called at any time when coefficient values need
to be calculated. It is worth noting that this is a vectorized function
which allows to calculate coefficients over all subdomain points.

5.5 CALCULATING GLOBAL STIFFNESS MATRIX AND FORCING

VECTOR
In section 5.3 we obtained expression for calculating local stiffness ma-
trices and local force vectors for the G1 mesh. Now, let us incorporate
this information into the algorithms provided in sections 5.1 and 5.2. We
114 ■ Computational Framework for the Finite Element Method

provide two versions of the algorithm: vectorized and non-vectorized. Let

us start with non-vectorized version given in listing 5.12.
1 function [A,F]= assemblingAF nv (p,t,c,a,b1 ,b2 ,f)
2 % Non-vectorized assembling algorithm.
3 % The following call is allowed :
4 % A=assemblingAF_nv(p,t,c,a,b1,b2)
5 np=size(p ,2) ; nt=size(t ,2) ;
6 Al= zeros (nt ,3 ,3) ; % all local stiffness matrix
7 F= zeros (np ,1) ; % global force vector
8 for k=1: nt
9 % mesh point indices
10 k1=t(1,k) ; k2=t(2,k) ; k3=t(3,k) ;
11 sdl=t(4,k) ; % subdomain labels
12 % barycenter of the triangle
13 x1=(p(1,k1)+p(1,k2 )+p(1,k3 ))/3 ;
14 x2=(p(2,k1)+p(2,k2 )+p(2,k3 ))/3 ;
15 % gradient of the basis functions, multiplied by J
16 g1 x1 =p(2,k2)−p(2,k3) ; g1 x2 =p(1,k3)−p(1,k2) ;
17 g2 x1 =p(2,k3)−p(2,k1) ; g2 x2 =p(1,k1)−p(1,k3) ;
18 g3 x1 =p(2,k1)−p(2,k2) ; g3 x2 =p(1,k2)−p(1,k1) ;
19 J=abs( g3 x2.∗ g2 x1−g3 x1.∗ g2 x2 ) ; % J=2*area
20 % evaluate c , b , a on triangles barycenter
21 cf= feval (c,x1 ,x2 ,sdl) ;
22 af= feval (a,x1 ,x2 ,sdl) ;
23 b1f= feval (b1 ,x1 ,x2 ,sdl) ;
24 b2f= feval (b2 ,x1 ,x2 ,sdl) ;
25 % diagonal and off-diagonal elements of mass matrix
26 ao=(af/24). ∗ J ; ad=4∗ ao ; % ’exact’ integration
27 % ao=(af/18).*J ; ad=3*ao ; % quadrature rule
28 % b contributions
29 b1f=b1f /6 ; b2f=b2f /6 ;
30 bg1=b1f.∗ g1 x1 +b2f.∗ g1 x2 ;
31 bg2=b1f.∗ g2 x1 +b2f.∗ g2 x2 ;
32 bg3=b1f.∗ g3 x1 +b2f.∗ g3 x2 ;
33 % coefficients of the stiffness matrix
34 cf=(0.5 ∗ cf )./J ;
35 a12=cf.∗( g1 x1.∗ g2 x1 + g1 x2.∗ g2 x2 )+ ao ;
36 a23=cf.∗( g2 x1.∗ g3 x1 + g2 x2.∗ g3 x2 )+ ao ;
37 a31=cf.∗( g3 x1.∗ g1 x1 + g3 x2.∗ g1 x2 )+ ao ;
 Programming Two-Dimensional Finite Element Method ■ 115

38 Al(k ,: ,:)=[ad−a31−a12+bg1 a12+bg2 a31+bg3

39 a12+bg1 ad−a12−a23+bg2 a23+bg3
40 a31+bg1 a23+bg2 ad−a23−a31+bg3] ;
41 if nargout ==2
42 ff= feval (f,x1 ,x2 ,sdl) ;
43 I=[k1;k2;k3] ;
44 F(I)=F(I)+ff∗J/6 ;
45 end
46 end
47 A= sparse (np ,np) ; % global stiffness matrix
48 for i=1:3
49 for j=1:3
50 A=A+ sparse (t(i,:) ,t(j ,:) , Al(:,i,j),np ,np) ;
51 end
52 end
53 if nargout ==1
54 F=[] ;
55 end
56 end

Listing 5.12: MATLAB code for non-vectorized version of the algorithm

for calculating elements and assembling FEM matrices.
Analysis of the function assemblingAF nv() shows that in order to vector-
ize it we need to avoid using loop and assemble local stiffness matrices
on place once they have been calculated. As a result, we come to the
vectorized version of the algorithm (see listing 5.13).
1 function [A,F]= assemblingAF (p,t,c,a,b1 ,b2 ,f)
2 % Vectorized assembling algorithm.
3 % The following call is allowed :
4 % A=assemblingAF(p,t,c,a,b1,b2)
5 np=size(p ,2) ;
6 k1=t(1 ,:) ; k2=t(2 ,:) ; k3=t(3 ,:) ; % mesh point indices
7 sdl=t(4 ,:) ; % subdomain labels
8 % barycenter of the triangles
9 x1=(p(1,k1)+p(1,k2 )+p(1,k3 ))/3 ;
10 x2=(p(2,k1)+p(2,k2 )+p(2,k3 ))/3 ;
11 % gradient of the basis functions, multiplied by J
12 g1 x1 =p(2,k2)−p(2,k3) ; g1 x2 =p(1,k3)−p(1,k2) ;
13 g2 x1 =p(2,k3)−p(2,k1) ; g2 x2 =p(1,k1)−p(1,k3) ;
14 g3 x1 =p(2,k1)−p(2,k2) ; g3 x2 =p(1,k2)−p(1,k1) ;
116 ■ Computational Framework for the Finite Element Method

15 J=abs( g3 x2.∗ g2 x1−g3 x1.∗ g2 x2 ) ; % J=2*area

16 % evaluate c , b , a on triangles barycenter
17 cf= feval (c,x1 ,x2 ,sdl) ;
18 af= feval (a,x1 ,x2 ,sdl) ;
19 b1f= feval (b1 ,x1 ,x2 ,sdl) ;
20 b2f= feval (b2 ,x1 ,x2 ,sdl) ;
21 % diagonal and off diagonal elements of mass matrix
22 ao=( af/24). ∗ J ; ad=4∗ ao ; % ’exact’ integration
23 % ao=(af/18).*J ; ad=3*ao ; % quadrature rule
24 % coefficients of the stiffness matrix
25 cf =(0.5 ∗ cf )./J ;
26 a12=cf.∗( g1 x1.∗ g2 x1 + g1 x2.∗ g2 x2 )+ ao ;
27 a23=cf.∗( g2 x1.∗ g3 x1 + g2 x2.∗ g3 x2 )+ ao ;
28 a31=cf.∗( g3 x1.∗ g1 x1 + g3 x2.∗ g1 x2 )+ ao ;
29 if all(b1f ==0) && all( b2f ==0) % symmetric problem
30 A= sparse (k1 ,k2 ,a12 ,np ,np) ;
31 A=A+ sparse (k2 ,k3 ,a23 ,np ,np) ;
32 A=A+ sparse (k3 ,k1 ,a31 ,np ,np) ;
33 A=A+A.’;
34 A=A+ sparse (k1 ,k1 ,ad−a31−a12 ,np ,np) ;
35 A=A+ sparse (k2 ,k2 ,ad−a12−a23 ,np ,np) ;
36 A=A+ sparse (k3 ,k3 ,ad−a23−a31 ,np ,np) ;
37 else
38 % b contributions
39 b1f=b1f /6 ; b2f=b2f /6 ;
40 bg1=b1f.∗ g1 x1 +b2f.∗ g1 x2 ;
41 bg2=b1f.∗ g2 x1 +b2f.∗ g2 x2 ;
42 bg3=b1f.∗ g3 x1 +b2f.∗ g3 x2 ;
43 A= sparse (k1 ,k2 ,a12+bg2 ,np ,np) ;
44 A=A+ sparse (k2 ,k3 ,a23+bg3 ,np ,np) ;
45 A=A+ sparse (k3 ,k1 ,a31+bg1 ,np ,np) ;
46 A=A+ sparse (k2 ,k1 ,a12+bg1 ,np ,np) ;
47 A=A+ sparse (k3 ,k2 ,a23+bg2 ,np ,np) ;
48 A=A+ sparse (k1 ,k3 ,a31+bg3 ,np ,np) ;
49 A=A+ sparse (k1 ,k1 ,ad−a31−a12+bg1 ,np ,np) ;
50 A=A+ sparse (k2 ,k2 ,ad−a12−a23+bg2 ,np ,np) ;
51 A=A+ sparse (k3 ,k3 ,ad−a23−a31+bg3 ,np ,np) ;
52 end
53 if nargout ==2
54 ff= feval (f,x1 ,x2 ,sdl) ;
 Programming Two-Dimensional Finite Element Method ■ 117

55 ff=(ff/6). ∗ J ;
56 F= sparse (k1 ,1,ff ,np ,1) ;
57 F=F+ sparse (k2 ,1,ff ,np ,1) ;
58 F=F+ sparse (k3 ,1,ff ,np ,1) ;
59 else
60 F=[] ;
61 end
62 end

Listing 5.13: MATLAB code for the vectorized version of the algorithm
for calculating elements and assembling FEM matrices.

Let us compare computational costs of these two functions. We take

a domain having three subdomains with geometry defined by matrix
geometryMatrix (see figure 4.1) and specify coefficients of the PDE as fol-
lows:
1 function f= a coeff (x1 ,x2 ,sdl)
2 f= zeros (size(x1)) ;
3 % 1-st subdomain
4 I=find(sdl ==1); f(I)=x2(I ).^2;
5 % 2-nd subdomain
6 I=find(sdl ==2); f(I)=x2(I).^2 ;
7 % 3-d subdomain
8 I=find(sdl ==3); f(I)=x2(I).^2 ;
9 end

Listing 5.14: Coding coefficient a of the PDE.

1 function f= b1 coeff (x1 ,x2 ,sdl)

2 f= zeros (size(x1)) ;
3 % 1-st subdomain
4 I=find(sdl ==1); f(I)=x1(I)+ x2(I);
5 % 2-nd subdomain
6 I=find(sdl ==2); f(I)=x1(I)−x2(I) ;
7 % 3-d subdomain
8 I=find(sdl ==3); f(I)=x1(I).∗ x2(I) ;
9 end

Listing 5.15: Coding first component of the coefficient b of the PDE.

1 function f= b2 coeff (x1 ,x2 ,sdl)

2 f= zeros (size(x1)) ;
118 ■ Computational Framework for the Finite Element Method

3 % 1-st subdomain
4 I=find(sdl ==1); f(I)=1;
5 % 2-nd subdomain
6 I=find(sdl ==2); f(I)=1 ;
7 % 3-d subdomain
8 I=find(sdl ==3); f(I)=1 ;
9 end

Listing 5.16: Coding second component of the coefficient b of the PDE.

1 function f= c coeff (x1 ,x2 ,sdl)

2 f= zeros (size(x1)) ;
3 % 1-st subdomain
4 I=find(sdl ==1); f(I)=1;
5 % 2-nd subdomain
6 I=find(sdl ==2); f(I)=x1(I ).^2+ x2(I) ;
7 % 3-d subdomain
8 I=find(sdl ==3); f(I)= sin(x1(I)+x2(I)) ;
9 end

Listing 5.17: Coding coefficient c of the PDE.

1 function f= f coeff (x1 ,x2 ,sdl)

2 f= zeros (size(x1)) ;
3 % 1-st subdomain
4 I=find(sdl ==1); f(I)=1;
5 % 2-nd subdomain
6 I=find(sdl ==2); f(I)=x1(I ).^2+ x2(I) ;
7 % 3-d subdomain
8 I=find(sdl ==3); f(I)= sin(x1(I)+x2(I)) ;
9 end

Listing 5.18: Coding right hand side, f , of the PDE.

Then, we run the script shown in listing 5.19 to measure CPU time
for three meshes with different number of nodes.
1 function testAssemblingAF
2 time =[] ; time nv =[] ; % assembling time
3 nt =[] ; np =[] ;
4 g= geometryMatrix ;
5 % PDE coefficients;
6 c= @c coeff ;
 Programming Two-Dimensional Finite Element Method ■ 119

7 a= @a coeff ;
8 b1= @b1 coeff ;
9 b2= @b2 coeff ;
10 f= @f coeff ;
11 for h=[0.1 0.05 0.02]
12 [p,e,t]= initmesh (g,’hmax ’,h) ;
13 np=[np size(p ,2)] ; nt =[ nt size(t ,2)] ;
14 tic ;
15 [A,F]= assemblingAF (p,t,c,a,b1 ,b2 ,f) ;
16 time =[ time toc ];
17 tic ;
18 [A,F]= assemblingAF nv (p,t,c,a,b1 ,b2 ,f) ;
19 time nv =[ time nv toc ];
20 end
21 disp (’ np nt assemblingAF assemblingAF nv ’)
22 disp ([np ’ nt ’ time ’ time nv ’])
23 end

Listing 5.19: MATLAB code for testing efficiency of vectorized and non-
vectorized FEM assembling algorithms.
As a result, we come to table 5.3 which shows that vectorized version
outperforms non-vectorized one, that is predictable due to more efficient
memory management of the vectorized calculations in MATLAB.

TABLE 5.3: Summary of the computational efficiency test for assembling

global stiffness matrix and forcing vector. Last two columns contain CPU
time for the corresponding algorithm version.

np nt assemblingAF assemblingAF nv
704 1312 0.00391 1.08008
2670 5148 0.00781 3.73047
16473 32466 0.05566 23.62988

Python implementation of the function assemblingAF() can be found in

Appendix E.1 where corresponding explanations are provided.

5.6 CALCULATING BOUNDARY CONDITIONS

Below, we describe one of the possible methods of calculating boundary
conditions. Later, we make use of this approach to incorporate boundary
conditions into final FEM matrix.
120 ■ Computational Framework for the Finite Element Method

Recall that the boundary Γ of the problem domain Ω is supposed

to be split into two parts, ΓD and ΓR , on which different boundary
conditions could be defined (see section 3.1). Boundary parts ΓD and
ΓR , in turn, are union of the corresponding boundary segments defined
in geometry matrix. We associate each segment with either function uD
(for the Dirichlet boundary ΓD ) or with pair of functions (σ, µ) (for
the Robin boundary ΓR ). Thereby, we define conditions on ΓD and ΓR
separately.
Suppose that ΓD is non-empty and consists of the boundary segments
with indices (i1 , i2 , . . . , id ) and function uD could be different for each
segment. We define a function uD(x1,x2,sdl) in the way described in section
5.4. As a result, Dirichlet boundary conditions are defined by the list of
boundary segment indices bsD=[i1 , i2 , .. , id ] and by corresponding
function (likewise in section 5.4). Note that we need to bear in mind
that sdl parameter in a function has now meaning of the local index. For
instance, supposing we have three Dirichlet boundary segments with
indices 5, 2 and 7, then bsD = [5 2 7]. If uD = 1 for the fifth and seventh
segments, uD = x1 + x2 for the second segment, then we can define the
function uD as shown in listing 5.20.
1 function f=uD(x1 ,x2 ,sdl)
2 f= zeros (size(x1)) ;
3 % 1-st segment (local enumeration)
4 I=find(sdl ==1); f(I)=1;
5 % 2-nd segment
6 I=find(sdl ==2); f(I)=x1(I)+ x2(I) ;
7 % 3-d segment
8 I=find(sdl ==3); f(I)=1;
9 end

Listing 5.20: MATLAB code for defining Dirichlet BC.

If there is no Dirichlet boundary conditions, then bcD=[] and uD=[]; if

ΓD = Γ then bsD=inf.
Likewise, we define boundary conditions on ΓR through the list of
indices bsR and corresponding functions sg and mu for (σ, µ). In this case,
if σ = µ = 0 then this segment is not indicated in the list; if ΓR = Γ
then bsR=inf. Finally, if ΓD = ∅, ΓR = Γ and σ = µ = 0 then bsN=inf,
sg=[], mu=[].
For convenience, we pack data (bsD,uD,bsR,sg,mu) into structure bc with
corresponding fields.
 Programming Two-Dimensional Finite Element Method ■ 121

5.7 ASSEMBLING BOUNDARY CONDITIONS

Now, we gather all the necessary data to form the FEM system defined
by (3.7)
X X
Ãij uj = qi , qi = F̃i − Ãij uDj , i ∈ IU ,
j∈IU j∈ID

n n
where the matrix à = {Ãij }i,j=1
p
= A + S , F̃ = {F̃i }i=1
p
= F + M , ID
are the indices of the points with Dirichlet boundary conditions, and IU
are the rest points.
Function assemblingAF() (see section 5.5) calculates matrix A and vec-
tor F and we need a similar function to calculate S and M . In addition,
this function would enable us calculating vector U D with np elements
such that all its elements are equal to zero apart from elements with
indices j ∈ ID having value of uDj .
Matrix ÃIU = {Ã}i,j∈IU is obtained from the matrix à by deleting
rows and columns with indices belonging to the set ID . To perform this
operation we introduce a matrix N ∼ (np × m) where m is the number
of elements in the set IU and

N T · (u1 , u2 , · · · , unp )T = (ui1 , ui2 , · · · , uiU )T .

Matrix N can be defined as N=sparse([i1,i2,..,in],1:m,1,np,m). Conse-

quently, if S, M , N , and uD are calculated, then matrix à and vector q
are defined through the following expressions

ÃIU = N T (A + S)N, q = N T ((F + M ) − (A + S)U D ).

Note that after solving the system ÃIU u = q the final vector of solution
at the node points can be obtained as U = N u + U D (complementing
vector u by the boundary values U D ). As a result, we come to the
function assemblingBC() in listing 5.21 which calculates contributions from
the boundary elements.
1 function [N,S,UD ,M]= assemblingBC (bc ,p,e)
2 % The following call is also allowed :
3 % [N,S]=assemblingBC(bc,p,e)
4 % [N,S,UD]=assemblingBC(bc,p,e)
5 np=size(p ,2) ;
6 S= sparse (np ,np) ; M= sparse (np ,1) ; N= speye (np ,np) ;
7 UD= sparse (np ,1) ;
122 ■ Computational Framework for the Finite Element Method

8 if all(bc.bsR == inf) && ( numel(bc.sg )==0) && ( numel (bc.mu )==0)

9 return % all boundary are homogeneous Robin BC
10 end
11 e=e(:,e(6 ,:)==0 | e (7 ,:)==0) ; % all boundary edges
12 k=e(5 ,:) ;
13 [bsg ,~]= find( sparse (k,k,1,np ,np )) ; % boundary segment indices
14 nbsg= numel(bsg) ;
15 % set localal enumeration of boundary segments
16 local= zeros (1, nbsg) ;
17 % set Robin boundary conditions
18 if nargout >=2
19 bsR=bc.bsR ;
20 if numel (bsR)>0
21 if bsR == inf , bsR=bsg ; end % all BC are mixed
22 local(bsR )=1: numel (bsR) ;
23 % find boudary edges with Robin b.c.
24 eR=e([1 2 5], ismember (k,bsR )) ;
25 k1=eR (1 ,:) ; k2=eR (2 ,:) ; % corner point indices
26 x1=0.5 ∗ (p(1,k1)+p(1,k2 )) ; x2=0.5 ∗ (p(2,k1 )+p(2,k2 )) ;
27 h=sqrt ((p(1,k2)−p(1,k1 )).^2+( p(2,k2)−p(2,k1 )).^2) ;
28 sdl=local(eR (3 ,:)) ;
29 % evaluate sigma and mu on edges barycenter
30 sf= feval (bc.sg ,x1 ,x2 ,sdl) ;
31 mf= feval (bc.mu ,x1 ,x2 ,sdl) ;
32 % diagonal and off diagonal elements
33 so=(sf/6). ∗ h ; sd=2∗ so ; % ’exact’ integration
34 %so=(sf/4).*h ; sd = so ; % quadrature rule
35 S= sparse (k1 ,k2 ,so ,np ,np) ;
36 S=S+ sparse (k2 ,k1 ,so ,np ,np) ;
37 S=S+ sparse (k1 ,k1 ,sd ,np ,np) ;
38 S=S+ sparse (k2 ,k2 ,sd ,np ,np) ;
39 if nargout ==4
40 mf= feval (bc.mu ,x1 ,x2 ,sdl) ;
41 mf=(mf/2). ∗ h ;
42 M= sparse (k1 ,1,mf ,np ,1) ;
43 M=M+ sparse (k2 ,1,mf ,np ,1) ;
44 end
45 end
46 end
47 % set Dirichlet boundary conditions
 Programming Two-Dimensional Finite Element Method ■ 123

48 bsD=bc.bsD ;
49 if numel (bsD)>0
50 if bsD == inf
51 bsD=bsg ;
52 end % all b.c. are the Dirichlet one
53 local(bsD )=1: numel (bsD) ;
54 if all(local ==0)
55 disp (’error. bsD+bsR ~= number of boundary segments ’)
56 end
57 eD=e([1 2 5], ismember (k,bsD )) ; % Dirichlet BC edges
58 sdl=local(eD (3 ,:)) ;
59 k1=eD (1 ,:) ; k2=eD (2 ,:) ; % indices of corner points
60 iD=[k1 k2] ;
61 [id ,~]= find( sparse (iD ,iD ,1,np ,np )) ; % Dirichlet point indices
62 iN=ones (1,np) ; iN(id )= zeros (1, numel (id )) ;
63 iN=find(iN) ; % indices of non-Dirichlet points
64 niN=numel(iN) ;
65 N= sparse (iN ,1: niN ,1,np ,niN) ;
66 if nargout >=3 % evaluate UD on Dirichlet points
67 UD(k1)= feval (bc.uD ,p(1,k1),p(2,k1),sdl) ;
68 UD(k2)= feval (bc.uD ,p(1,k2),p(2,k2),sdl) ;
69 end
70 end
71 end

Listing 5.21: MATLAB code for calculating and assembling BC.

For clarification, MATLAB function t=ismember(a,b) returns Boolean
vector such that t(k)=1 if a(k) ∈ b and t(k)=0 if a(k) ̸∈ b.
Functions described above allow us forming and solving FEM system.
As a final step, we provide a function assemblingPDE() in listing 5.22 which
assembles a PDE problem and solves it using FEM. Depending on the
number of output arguments, it returns either FEM matrices or a final
solution vector.
1 function [A,F,N,UD ,S,M]= assemblingPDE (bc ,p,e,t,c,a,b1 ,b2 ,f)
2 %[A,F,N,UD,S,M]=assemblingPDE(bc,p,e,t,c,a,b1,b2,f) - returns
3 % FEM matrices.
4 % u=assemblingPDE(bc,p,e,t,c,a,b1,b2,f) - returns
5 % FEM solution represented as a column vector.
6 if nargout ==6
7 [A,F]= assemblingAF (p,t,c,a,b1 ,b2 ,f) ;
124 ■ Computational Framework for the Finite Element Method

8 [N,S,UD ,M]= assemblingBC (bc ,p,e) ;

9 elseif nargout ==1
10 [A,F]= assemblingAF (p,t,c,a,b1 ,b2 ,f) ;
11 [N,S,UD ,M]= assemblingBC (bc ,p,e) ;
12 if size(N ,2)== size(p ,2) % no Dirichlet boundary conditions
13 A=A+S;
14 F=F+M;
15 else
16 Nt=N.’;
17 A=A+S;
18 F=Nt ∗((F+M)−A∗UD) ;
19 A=Nt∗A∗N;
20 end
21 u=A\F;
22 A=N∗u+UD; % returns A=u
23 else
24 error (’Wrong number of output parameters .’ ) ;
25 end
26 end

Listing 5.22: MATLAB code for assembling FEM matrices and solving
a PDE problem.

Functions assemblingAF() and assemblingPDE() translated into Python

programming language can be found in Appendix E.2.

5.8 SOLVING EXAMPLE PROBLEM

Let us apply function assemblingPDE() to solve an example problem. We
consider PDE of the form

−∇ · (c(x)∇u) + b(x) · ∇u + a(x)u = f (x), x = (x1 , x2 ) ∈ Ω,

with boundary conditions

u(x) = uD (x), x ∈ ΓD ;
c(x)∇u · ν(x) + σ(x)u = µ(x), x ∈ ΓR ,

where Ω is a circle of the unity radius. Figure 5.3 shows boundaries of

the circle having four segments, where ΓD comprises segments 1 and 3,
and ΓR comprises segments 2 and 4.
 Programming Two-Dimensional Finite Element Method ■ 125

FIGURE 5.3: Geometry for the example problem.

We define coefficients

c = 2 + x1 + x2 ,
a = x1 + x2 ,
b = (x1 , x2 ),
f = −8 − 6(x1 + x2 ) + (2 + x1 + x2 )(x21 + x22 ),

and boundary conditions

uD = x21 + x22 ,
(
0, on 2nd segment,
σ=
2, on 4th segment ,
(
2(2 + x1 + x2 )uD , on 2nd segment,
µ=
2(2 + x1 + x2 + 1)uD , on 4th segment.

Boundary conditions σ and µ can be coded through the functions

1 function f= u D (x1 ,x2 ,sdl)
2 f= zeros (size(x1)) ;
126 ■ Computational Framework for the Finite Element Method

3 % segments in local numeration:

4 % 1-st segment
5 I=find(sdl ==1); f(I)=x1(I ).^2+ x2(I ).^2;
6 % 2-nd segment
7 I=find(sdl ==2); f(I)=x1(I ).^2+ x2(I).^2 ;
8 end

Listing 5.23: Coding Dirichlet BC for an example problem.

1 function f= sigma(x1 ,x2 ,sdl)

2 f= zeros (size(x1)) ;
3 % segments in local numeration:
4 % 1-st segment
5 I=find(sdl ==1); f(I)=0;
6 % 2-nd segment
7 I=find(sdl ==2); f(I)=2 ;
8 end

Listing 5.24: Coding first term of Robin BC for an example problem.

1 function f=mu(x1 ,x2 ,sdl)

2 f= zeros (size(x1)) ;
3 % segments in local numeration:
4 % 1-st segment
5 I=find(sdl ==1);
6 f(I)=2 ∗ (2+x1(I)+x2(I)). ∗ (x1(I ).^2+ x2(I ).^2) ;
7 % 2-nd segment
8 I=find(sdl ==2);
9 f(I)=2 ∗ (2+x1(I)+x2(I)+1). ∗ (x1(I ).^2+ x2(I ).^2) ;
10 end

Listing 5.25: Coding second term of Robin BC for an example problem.

It is easy to see that solution to this problem is given by function

u = x21 + x22 . We utilize function assemblingPDE() to solve this problem
numerically on the meshes with h = [0.5 0.1 0.05 0.02]. Since the exact
solution is known we can find an absolute error

err = max|u(x) − uh (x)|,

x∈Th

and relative error, errh = err/h2 . Function testPDE in listing 5.26 solves
this problem and calculates FEM solution errors.
 Programming Two-Dimensional Finite Element Method ■ 127

1 function testPDE
2 clear all ; close all ; clc
3 g=’circleg ’ ; np =[] ; nt =[] ; errh2 =[] ; err =[] ;
4 t assemblingAF =[] ; t assemblingBC =[] ; t solving =[] ;
5 for h=[0.5 0.1 0.05 0.02]
6 [p,e,t]= initmesh (g,’hmax ’,h) ;
7 exact =@(x1 ,x2 ,sdl) x1 .^2+ x2 .^2; % exact solution
8 x1=p(1 ,:) ; x2=p(2 ,:) ;
9 u exact =exact(x1 ,x2 ,1) ’;
10 % PDE coefficients
11 c=@(x1 ,x2 ,sdl) 2+ x1+x2 ;
12 a=@(x1 ,x2 ,sdl) x1+x2 ;
13 f=@(x1 ,x2 ,sdl) −8−6∗(x1+x2 )+(2+ x1+x2).∗(x1 .^2+ x2 .^2) ;
14 b1=@(x1 ,x2 ,sdl) x1 ;
15 b2=@(x1 ,x2 ,sdl) x2 ;
16 % boundary conditions
17 bc.bsD =[1 3] ; bc.uD= @u D ;
18 bc.bsR =[2 4] ; bc.sg= @sigma ; bc.mu=@mu ;
19 tic
20 [A,F]= assemblingAF (p,t,c,a,b1 ,b2 ,f) ;
21 t assemblingAF =[ t assemblingAF toc] ;
22 tic
23 [N,S,UD ,M]= assemblingBC (bc ,p,e) ;
24 t assemblingBC =[ t assemblingBC toc] ;
25 tic
26 u= assemblingPDE (bc ,p,e,t,c,a,b1 ,b2 ,f) ;
27 t solving =[ t solving toc] ;
28 np=[np size(p ,2)] ; nt =[ nt size(t ,2)] ;
29 err =[ err norm( u exact−u,inf )] ;
30 errh2 =[ errh2 norm( u exact−u,inf )/h^2] ;
31 end
32 disp (’np assemblingAF assemblingBC solving ’)
33 disp ( [np ’ t assemblingAF ’ t assemblingBC ’ t solving ’] )
34 err
35 errh2
36 end

Listing 5.26: MATLAB code for solving example problem.

As a result we obtain tables 5.4 and 5.5 summarizing testing data.

Data for error magnitudes in table 5.5 indicate that the problem has
128 ■ Computational Framework for the Finite Element Method

TABLE 5.4: Summary of the solving test problem. Last three columns
contain CPU time for the corresponding functions.

np assemblingAF assemblingBC solving

33 0.00195 0.00586 0.00293
544 0.00195 0.00195 0.00683
2169 0.00586 0.00195 0.02344
13525 0.05859 0.00683 0.31348

TABLE 5.5: Errors when solving the test problem numerically.

np 33 544 2169 13525

err 0.07266 0.00252 0.00093 0.00013
errh2 0.29066 0.25173 0.37120 0.32498

been solved successfully. Absolute error decreases with mesh resolution

refining while relative error remains stable with slight fluctuation.
Python version of the code for solving example problem can be found
in Appendix E.3.
 CHAPTER 6

Nonlinear Basis
Functions

ere we consider G2 mesh and obtain expressions for calculation of

H basis functions for mesh triangular elements with straight as well
as curvilinear edges. Analysis of how to deduce expression for calculat-
ing elements of stiffness matrix is given here. We provide mathematical
formulations and expressions without giving MATLAB implementations
codes. Based on the content of this chapter, coding functions can be eas-
ily composed. Basically, we outline techniques to extend existing FEM
framework for G1 mesh to FEM with G2 mesh.

6.1 QUADRATIC BASIS FUNCTIONS FOR LINEAR TRIANGULAR

ELEMENTS
Methodology to obtain basis functions for the G2 triangles with straight
edges is similar to one of G1 meshes with the difference in number of
interpolation nodes.
Let us consider a canonical triangle element τ̂ in the coordinate sys-
tem x̂ = (x̂1 , x̂2 ) having six interpolation nodes p̂i , i = 1, . . . , 6 (here
pˆ4 , pˆ5 , and pˆ6 are midpoints). Then G2 are all polynomials of the second
order on the element τ̂ (see figure 6.1 with original triangle element and
corresponding basis element).
If x̂3 = 1 − x̂1 − x̂2 , then basis in Ĝ2 is defined by the following
functions
 
1
φ̂1 = x̂3 (2x̂3 − 1), φ̂2 = x̂1 (2x̂1 − 1), φ̂3 = x̂2 2x̂2 − ,
2 (6.1)
φ̂4 = 4x̂1 x̂3 , φ̂5 = 4x̂1 x̂2 , φ̂6 = 4x̂2 x̂3 ,
DOI: 10.1201/9781003265979-6 129
130 ■ Computational Framework for the Finite Element Method

FIGURE 6.1: Canonical element τ̂ and original G2 mesh element τ .

and for arbitrary function ẑ ∈ Ĝ2 is valid

X
6
ẑ(x̂) = ẑ(p̂i )φ̂i (x̂), x̂ ∈ τ̂ .
i=1

Coordinate transformation τ̂ → τ is defined by (see (5.4) – (5.6))

x = Bτ x̂ + p1 , (6.2)

and, in addition, points p̂i are transformed into points pi , i = 1, . . . , 6.

Inverse transformation is defined by x̂ = Bτ−1 (x − p1 ) and functions
φi (x) = φ̂i (Bτ−1 (x − p1 )) represent a basis in G2 . As a result, ẑ(x̂)
transforms into z(x) such that

X
6
z(x) = z(pi )φi (x), x ∈ τ. (6.3)
i=1

It is worth noting here that unlike G1 mesh, basis functions for G2 mesh
are nonlinear functions, namely, of the second order. This fact results in
slightly more complicated calculations of its gradients.

6.2 QUADRATIC BASIS FUNCTIONS FOR CURVILINEAR

TRIANGULAR ELEMENTS
Usually, curvilinear elements are used as mesh elements adjoining the
boundary to approximate curvilinear geometry in most precise way. Fig-
ure 6.2 shows G2 canonical element τ̂ (basis functions for τ̂ are defined by
(6.1)) and corresponding curvilinear element τ . Points pi , i = 1, . . . , 6
form the element so that each three points define a parabolic curve.
 Nonlinear Basis Functions ■ 131

FIGURE 6.2: Canonical element τ̂ and original curvilinear G2 mesh ele-

ment τ .

For example, it is possible to plot a unique parabola through nodes

p2 , p3 and p5 . As a result, the element τ can be expressed through the
functions of second order, or, in other words, through basis functions
(6.1). We come to the transformation

X
6
x= pi φ̂i (x̂), x̂ ∈ τ̂ (6.4)
i=1

which transforms τ̂ into τ , and points p̂i are transformed into pi . Note
that if nodes of the element τ lie on the straight line, then transformation
(6.4) reduces to linear form (6.2). As such, the difference between linear
and curvilinear triangle elements is the way of transformation from τ̂ to
τ.
Likewise linear G2 elements, to represent any function defined on
curvilinear element τ through the basis function we utilize the expression
(6.3) where basis functions now are not polynomials of the second order
but function of the x being itself second-order polynomial.

6.3 STIFFNESS MATRIX WITH QUADRATIC BASIS FUNCTIONS

Let us consider calculation of the local stiffness matrix defined on the
G2 mesh elements (see (5.1))
Z
Āαβ = (c∇φβ · ∇φα + b · ∇φβ φα + aφβ φα ) dx. (6.5)
τ

Method of calculation of the integral (6.5) considered below is applicable

to both, curvilinear and linear, G2 elements.
132 ■ Computational Framework for the Finite Element Method

First, we define Jacobian matrix J(x) with x = x(x̂) =

(x1 (x̂), x2 (x̂))T ,  
∂x1 ∂x2
 x̂1 ∂ x̂1 
J(x̂) =  ∂
∂x1 ∂x2  (x̂).
∂ x̂2 ∂ x̂2
Next, we substitute element τ by τ̂ in the expression (6.5). By doing this
we have

c(x) → ĉ(x̂) = c(x(x̂)), φα (x) → φ̂α (x̂)

∇ → J −1 (x̂)∇,
ˆ ˆ = (∂/∂ x̂1 , ∂/∂ x̂2 )T , dx = |J(x̂)|dx̂,
∇

where basis functions φ̂α (x̂) are defined by (6.1), and

Z 
Āαβ = ĉ(x̂)J −1 (x̂)∇
ˆ φ̂β · J −1 (x̂)∇
ˆ φ̂α
τ̂

+b̂(x̂) · J −1 (x̂)∇
ˆ φ̂β φ̂α + â(x̂)φ̂β φ̂α |J(x̂)|dx̂. (6.6)

To compute integral (6.6) we apply quadrature rule. Let us denote the

integrand as ẑ(x̂), then
Z X
q
Āαβ = ẑ(x̂)dx̂ ≈ γ̂i ẑ(d̂i ),
τ̂ i=1

where coefficients γ̂i and nodes d̂i , i = 1, . . . , q depend on particular

chosen quadrature rule. Using quadrature with polynomials of the second
order suffice for G2 mesh.
When calculating integral (6.6) we make use of some properties of the
G2 mesh. Firstly, when computing Āαβ over triangle with straight edges,
matrix J −1 = B −T does not depend on x̂ and Āαβ can be computed
only once. However, in case of curvilinear triangular elements, Jacobian
J −1 (x̂) needs to be calculated q times. Secondly, we can facilitate cal-
culation of (6.6) by introducing matrices D̂(d̂i ) ∼ (2 × 6)
n o6
D̂(d̂i ) = ∇ˆ φ̂β (d̂i ) , D(d̂i ) = J −1 (d̂i )D̂(d̂i ),
β=1
 Nonlinear Basis Functions ■ 133

column-vectors n o6
φ̂(d̂i ) = φ̂β (d̂i ) ,
β=1

and coefficients γ(d̂i ) = γ̂i |J(d̂i )| such that

X
q X
q 
Āαβ = γ̂i ẑ(d̂i ) = γ(d̂i ) ĉ(d̂i )D β (d̂i ) · D α (d̂i )
i=1 i=1
  
+ b̂(d̂i ) · D β (d̂i ) + â(d̂i )φ̂β (d̂i ) φ̂α (d̂i ) ,

where D α (d̂i ) is the column of D(d̂i ) with index α. Since x · y = xT y ,

xy T = {xi yj }ni,j=1 , x, y ∈ Rn , then local stiffness matrix can be ex-
pressed as

X
q 
Ā = γ(d̂i ) ĉ(d̂i )DT (d̂i )D(d̂i )
i=1
 
+φ̂(d̂i ) b̂(d̂i )D(d̂i ) + â(d̂i )φ̂T (d̂i ) .

The local forcing vector is calculated analogously, namely,

X
q
F̄ = γ(d̂i )fˆ(d̂i )φ̂(d̂i ).
i=1

It is worth noting that the following is valid for the curvilinear tri-
angular element (see 6.4)

fˆ(d̂i ) = f (X φ̂(d̂i )), J(d̂i ) = D̂(d̂i )X T , X2×6 = (p1 , . . . , p6 ),

where X is the matrix with interpolation nodes of the finite element τ .

Let us provide numerical values of coefficients γ(d̂i ) for two particular
quadrature rules. First one contains three nodes (q = 3), it interpolates
exactly polynomials of the second order (G2 mesh) and has the following
nodes and coefficients:
 
0.5 0.5 0 1

dˆ = , γ̂ = 1 1 1 .
0 0.5 0.5 6
134 ■ Computational Framework for the Finite Element Method

Second one contains six points and interpolates exactly polynomials

of the fourth order. Its nodes and coefficients are given by

a1 = 0.09157621350977073, a2 = 0.09157621350977073,
b1 = 0.4459484909159649, b2 = 0.4459484909159649,
a3 = 1 − a1 − a2 , b3 = 1 − b1 − b2 ,
 
a1 a 1 a3 b1 b1 b3
dˆ = ,
a2 a3 a2 b2 b3 b2
γ1 = 0.1099517436553218, γ2 = 0.2233815896780115,
1

γ̂ = γ1 γ1 γ1 γ2 γ2 γ2 .
2
Now, we consider calculation of the boundary matrix S̄ = {S̄αβ } and
boundary vector M̄ = {M̄α } (see expression 5.8). Let e be the boundary
edge with endpoints p1 , p2 and midpoint p3 , and ê = {θ̂ ∈ [0, 1]} is a
basis edge having endpoints pˆ1 = 0, pˆ2 = 1 and midpoint pˆ3 = 0.5.
Then, basis functions defined on the edge can be expressed as

φ̂1 (θ̂) = (1 − 2θ̂)(1 − θ̂), φ̂2 (θ̂) = θ̂(2θ̂ − 1), φ̂3 (θ̂) = 4θ̂(1 − θ̂).

Expression

x = xe (θ̂) = p1 φ̂1 (θ̂) + p2 φ̂2 (θ̂) + p3 φ̂3 (θ̂)

defines transformation ê → e (pˆk → pk , k = 1, 2, 3) and parametric

representation of the edge as well. It is easy to see, that in case of straight
line edge the midpoint p3 = (p1 + p2 )/2 and xe (θ̂) = p1 (1 − θ̂) +
p2 θ̂. Boundary integrals (5.8) for calculation of S̄αβ and M̄α rewritten
in terms of θ̂ over the basis edge ê have the form of one-dimensional
integrals
Z1
S̄αβ = σ(xe (θ̂))φ̂α (θ̂)φ̂β (θ̂)l(θ̂)dθ̂,
0
(6.7)
Z1
M̄α = µ(xe (θ̂))φ̂α (θ̂)l(θ̂)dθ̂,
0
q
where l(θ̂) = (x′1 (θ̂))2 + (x′2 (θ̂))2 . For the straight line edge, l(θ̂) =
|p2 − p1 |, and l is the length of edge.
 Nonlinear Basis Functions ■ 135

To calculate one-dimensional integral, let us utilize quadrature rule

Z1 X
q
ẑ(θ̂)dθ̂ ≈ γ̂i ẑ(dˆi ).
0 i=1

Likewise calculation of two-dimensional integral (6.6), we introduce

n o3 n o3
column-vectors φ̂(dˆi ) = φ̂β (dˆi ) , dφ̂(dˆi ) = φ̂′β (dˆi ) and ma-
β=1 β=1
trix of nodes coordinates X2×3 = (p1 , p2 , p3 ). Then, x′ (dˆi ) = Xdφ̂(dˆi )
and l(dˆi ) = |Xdφ̂(dˆi )| is the length of the vector Xdφ̂(dˆi ). Having in-
troduced this, we come to the expressions for the matrix S and vector
M
Xq
S= γ(dˆi )σ(X φ̂(dˆi ))φ̂(dˆi )φ̂T (dˆi ),
i=1
(6.8)
Xq
M̄ = γ(dˆi )µ(X φ̂(dˆi ))φ̂(dˆi ),
i=1

where γ(dˆi ) = γ̂i |Xdφ̂(dˆi )|.

In conclusion, we provide coefficients for two particular quadrature
rules defined on [0, 1] which interpolates exactly polynomials of the third
order. The first one is Gauss quadrature:
 p 
γ̂1 = γ̂2 = 0.5, dˆ1 = 0.5 1 − 1/3 ,
 p  (6.9)
dˆ2 = 0.5 1 + 1/3 , q = 2.

The second one is Simpson quadrature

γ̂1 = γ̂3 = 1/6, γ̂2 = 4/6, dˆ1 = 0,

(6.10)
dˆ2 = 0.5, dˆ3 = 1, q = 3.

Using either (6.9) or (6.10) allows calculating boundary integrals (6.7)

numerically and obtaining corresponding matrices (6.8).
Conclusion

n this book we have considered creating computational framework for

I the linear finite element method (FEM) with application to solving
ordinary and partial differential equations having mixed boundary con-
ditions. Each step of the FEM algorithm is described in detail and pro-
gramming codes in MATLAB and Python are composed. Although there
exists various software packages implementing FEM, understanding the
basics of the FEM algorithm is important to utilize these packages. Ex-
planations of the FEM algorithm and computational framework given
in this book not only help to understand basics of the method but to
provide guidance of how to build customized code for solving a problem
using FEM. The latter is important since it allows to develop coding
skills and to become more flexible with solving any nonstandard prob-
lem where standard FEM packages could fail to solve (or simply these
packages are not available). Apart from this, coding functions from this
book can be extended or modified to build improved FEM framework
with some specific features if required.
Of course, we have only considered simple case of linear FEM, but
it could be starting point to build more sophisticated algorithms. For
example, solving nonlinear PDE results in FEM system which requires
applying numerical methods to solve nonlinear systems. Creating FEM
programming codes for three-dimensional case could be the next step a
reader starts to look at.

137
 APPENDIX A

Variational Formulation
of a Boundary Value
Problem

ere we discuss variational approach to solve BVP. Variational

H methods are used in many applications where a problem can be
expressed in terms of so-called variational principles. In accordance with
one of these principles, function u(x) being a solution to a BVP at the
same time must be a stationary point of a variational functional
Zs1
J(u) = F (x, u, u′ )dx,
s0

where s0 and s1 are constants, u(x) is a twice continuously differentiable

function and function F is twice continuously differentiable with respect
to its arguments. A stationary point is a function u∗ (x) which makes
J(u) stationary, or when the first-order change in J(u) with respect to
the function u(x) vanishes. Usually, variational functional has a certain
meaning, for example, it could be a potential energy and a stationary
point is a function that minimizes the energy. It is known from varia-
tional calculus that a stationary point is solution to the Euler-Lagrange
equation
d ∂F ∂F
− ′
+ = 0. (A.1)
dx ∂u ∂u
If equation (A.1) is complemented with some boundary conditions
u(s0 ) = us0 , u(s1 ) = us1 , (A.2)

DOI: 10.1201/9781003265979-A 139

140 ■ Computational Framework for the Finite Element Method

then we see that finding a stationary point of J(u) is equivalent to solving

BVP (A.1) – (A.2).
As an example, let us consider the functional
Zs1
1
2
J(u) = c(x) u′ (x) + a(x)u2 (x) − f (x)u(x)dx, (A.3)
2
s0

where c(x), a(x) and f (x) are piecewise continuous functions and c(x) >
0, b(x) > 0. A variational problem is to find a function u(x) which
minimizes J(u).
J(u) → min, u(s0 ) = us0 , u(s1 ) = us1 . (A.4)
Then, the Euler-Lagrange equation takes the form

′
− c(x)u′ (x) + a(x)u(x) = f (x). (A.5)
It can be shown that stationary point in this case is a function which
minimizes (A.3). As a result, solving (A.3) – (A.4) is equivalent to solving
BVP (A.5) – (A.2).
In practice, the BVP (A.5) – (A.2) is replaced by the integral expres-
sion (A.3) for which a minimization problem is considered with some ap-
proximation of unknown function. In the context of FEM, the unknown
function u is represented through linear combination of some known
functions, φi (x), and coefficients, αi , as follows:
X
N
u(x) = αi φi (x). (A.6)
i=1

By substituting (A.6) into (A.3) we come to the problem of minimization

of multivariate function J(αi φi (x)) with respect to variables αi . Accord-
ing to the first-order necessary condition for a minimum, variables αi can
be found from equations
!
∂ XN
J αi φi = 0.
∂αi
i=1

By adding to these equations conditions (A.2) we come to a system of

equations for finding coefficients αi which defines solution (A.6).
One limitation of the variational approach to solve BVP is that it
is applicable only in case when a given differential equation represents
Euler-Lagrange equation which is not always achievable. For example,
BVP (1.1) is not allowing variational formulation. Instead, projective
method can be used which is considered throughout this book.
 APPENDIX B

Discussion of Global
Interpolating
Polynomial

et us consider a global approximating polynomial, Pm (x), of the

L order m defined on the interval [s0 , s1 ] which interpolates a function
f (x). Set of interpolation nodes forms a sequence

s0 = x1 < x2 < · · · < xm+1 = s1 .

We want to analyse what happens when number of nodes increases (for

example, to improve function approximation accuracy). Below, various
types of approximation errors are considered, and it is shown how in-
creasing number of interpolation nodes (and accordingly the degree of
polynomial Pm ) leads to accumulation of these errors.
Convergence with increasing number of nodes. Suppose that
we have chosen some strategy of increasing polynomial degree, m, by
introducing new nodes according to some rule. The question arises,
whether it is always true that such polynomials converge to the source
function, or

∆(Pm ) = max |f (x) − Pm (x)| −−−−→ 0.

[s0 ,s1 ] m→∞

The short answer is not. To illustrate this, let us consider the Runge
function1 f (x) = 1/(1 + 25x2 ), x ∈ [−1, 1], and a simple strategy which
1
Given example is referred to Runge’s phenomenon.

DOI: 10.1201/9781003265979-B 141

142 ■ Computational Framework for the Finite Element Method

1 1

0.8
0.8

0.6
0.6

0.4

0.4
0.2

0.2
0

0 -0.2
-1 -0.5 0 0.5 1 -1 -0.5 0 0.5 1

(a) (b)
2 8

1.5 6

1 4

0.5 2

0 0

-0.5 -2
-1 -0.5 0 0.5 1 -1 -0.5 0 0.5 1

(c) (d)

FIGURE B.1: Example of approximation divergence with increasing

polynomial degree, m, for uniformly distributed interpolation nodes
when (a) m = 3; (b) m = 6; (c) m = 10; (d) m = 14. Here, the
source function is f (x) = 1/(1 + 25x2 ) (solid line), and approximation
is performed using Lagrange basis functions (dashed line).

consists of having uniformly distributed nodes with the step h = 2/m,

that is xi = −1 + (i − 1)h, i = 1, . . . , m + 1. The polynomial degree
increases with increasing m and the result of applying this strategy with
m = {6, 10, 14} is shown in figure B.1. It can be seen that when m
increases, approximation in the central part of the interval shows perfect
result; however, polynomials diverge in the end regions, 0.73 ⪅ |x| ≤ 1.
We conclude that uniform distribution of nodes could potentially lead
to approximation divergence. To understand why the node distribution
is of importance, let us consider the approximation error, ∆(Pm ), which
can be estimated as
|f (m+1) (ξ)|
∆(Pm ) ≤ max |ωm+1 (x)|,
(m + 1)! [s0 ,s1 ]
 Discussion of Global Interpolation ■ 143

2 0.01

1.5
0.005

0.5

-0.005
0

-0.5 -0.01
-1 -0.5 0 0.5 1 -1 -0.5 0 0.5 1

(a) (b)

FIGURE B.2: Influence of the interpolation node distribution on the

approximation error. Plot (a) shows the source function f (x) = 1/(1 +
25x2 ) (solid line), approximating polynomial of degree m = 10 having
uniform node distribution (dashed line) and the polynomial which nodes
are roots of the Chebyshev polynomial of the second kind (dotted line).
Plot (b) illustrates dependence of the error function, ωm+1 , on the node
distribution. Here, the solid line corresponds to the uniform distribu-
tion and the dashed line corresponds to the nodes being the Chebyshev
polynomial roots.

where
ωm+1 (x) = (x − x1 )(x − x2 ) · · · (x − xm+1 ),
and ξ ∈ [s0 , s1 ]. It can be seen that the error depends on function ωm+1
which, in turn, depends on the relative nodes location. The problem of
divergence can be resolved by choosing nodes to be roots of an orthogonal
polynomial, for example, taking nodes to be xi = − cos(π(i−1)/m), 1 ≤
i ≤ m + 1 improves convergence (see figure B.2).2
Although taking orthogonal polynomial roots as interpolation nodes
is a good strategy, practically it could be inapplicable in some cases,
for example, when interpolation nodes are prescribed through a table of
function values which leaves no freedom of changing the nodes distribu-
tion.
Error of input data and approximation accuracy. Another
source of polynomial approximation error arises from the fact that the
function values at the interpolation nodes, fi = f (xi ), are specified or
2
Nodes xi = − cos(π(i − 1)/m), 1 ≤ i ≤ m + 1 are roots of the orthogonal
′
polynomial of the form (1−x2 )Um−1 (x) where Um−1 (x) is the Chebyshev polynomial
of the second kind of order m − 1.
144 ■ Computational Framework for the Finite Element Method

calculated with some errors, ϵi , that is fi∗ = fi + ϵi . As a result, polyno-

mial Pm∗ (x) constructed from the nodes f ∗ inevitably contains errors as
i
well
X
m+1
∗
Pm (x) − Pm (x) = ϵj φj (x),
j=1

where φj (x) is a Lagrange basis function. If ϵ∗ = max{ϵi }, then the

following estimation takes place

X
m+1
∗
max |Pm (x) − Pm (x)| ≤ Λm ϵ∗ , Λm = max |φj (x)|.
[s0 ,s1 ] [s0 ,s1 ]
j=1

Here, Λm is called the Lebesgue constant. It can be seen that the con-
stant Λm represents the factor by which approximation error increases
when the input data error is introduced. Sensitivity of the approxima-
tion method to the errors of input data is characterized by a conditional
number which can be defined by the Lebesgue constant. The value of
Λm depends only on nodes distribution but not on the interval length.
Asymptotic estimation shows that the Lebesgue constant grows logarith-
mically with m → ∞ if Chebyshev nodes are used. On the other hand,
it grows exponentially in the case of equidistant nodes. The former fact
leads to conclusion, that it is recommended to avoid using high order
global interpolation polynomials having equidistant nodes distribution.
Alternative approach is to use a piecewise local interpolation when the
interval [s0 , s1 ] is split into subintervals and function f is approximated
by interpolating polynomial of low order on each subinterval.
 APPENDIX C

Interpolatory
Quadrature Formulas

Q uadrature formulas are used to approximate integrals of func-

tions which are not computed exactly. The most common quadra-
ture formulas look like
Zs1 X
n
f dx ≈ γi f (xi ).
s0 i=1

Here xi are called nodes of the formula and γi are called weights.

Definition C.1 Interpolatory quadrature is a type of quadrature rule

when the integrand is approximated by another function, usually by in-
terpolating polynomial, integral of which can be computed exactly.

In other words, if φi (x) are basis functions, then

Zs1 Zs1 X
n X
n Zs1 X
n
f dx ≈ f (xi )φi (x) = f (xi ) φi (x)dx = γi f (xi ).
s0 s0 i=1 i=1 s0 i=1
| {z }
γi

Definition C.2 The order of precision of a quadrature formula is the

maximum degree of the polynomials which are integrated exactly by the
formula.

DOI: 10.1201/9781003265979-C 145

146 ■ Computational Framework for the Finite Element Method

FIGURE C.1: Illustration of rectangle and trapezoid quadrature rules.

Obviously, if basis functions are integrated exactly then the order of

precision of an interpolatory formula will be at least n − 1. Well-known
rectangle formula, trapezoidal rule and Simpson rule are interpolatory
quadrature rules corresponding to the polynomials of the zeroth, first
and second orders, respectively.
It is seen from the above formula that the precision of quadrature
formula can be increased by increasing number of interpolating nodes
(degree of interpolating polynomial). However, if there is a freedom in
choosing distribution of nodes then the precision could be increased
through particular choice of nodes location with fixed number n. This
can be illustrated as follows: Suppose we have a function f defined on the
interval which is approximated by a linear polynomial with two nodes,
x1 and x2 (see figure C.1). Then the trapezoid quadrature rule gives a
value of the integral equalling the area ABCD and this rule has the first
order of precision. On the other hand, if we consider a rectangle formula
with a freedom of choice of interpolation node, x∗1 , we can find location of
x∗1 so that the area AEF D (result of rectangle formula) would be equal
to the area ABCD. In this situation, the rectangle formula results not
in the zeroth order of precision but in the first order. This is achieved
through the particular choice of node location.

Definition C.3 An interpolatory quadrature rule having the highest or-

der of precision with the given number of nodes is called Gaussian
quadrature. Given n number of nodes, the highest precision order of
2n − 1 can be reached.
 Interpolatory Quadrature Formulas ■ 147

There are several algorithms for computing the nodes xi and weights
wi of Gaussian quadrature rule and one of them is given below. We start
by considering a quadrature for the interval [−1, 1] with n nodes1

Z1 X
n
f dx ≈ γi f (xi ).
−1 i=1

Note that this formula is exact for the polynomial of some degree N if
and only if it is exact for the set of functions f = 1, x, x2 , . . . , xN . This is
equivalent to the fact that nodes and weights must satisfy the following
system of nonlinear equations

X
n Z1
1 − (−1)k+1
γi xki = xk dx = , k = 0, . . . , N.
k+1
i=1 −1

It can be shown that the system has unique solution if the number of
unknowns is equal to the number of equations, so N = 2n − 1. For
example, Gaussian quadrature with two nodes corresponds to n = 1 and
N = 3. Weights and nodes are found from the system
Z1
γ1 + γ2 = dx = 2,
−1
Z1
γ1 x1 + γ2 x2 = xdx = 0,
−1
Z1
2
γ1 x21 + γ1 x22 = x2 dx = ,
3
−1
Z1
γ1 x31 + γ1 x32 = x3 dx = 0.
−1

1
Integration over an arbitrary interval, [s0 , s1 ], can be obtained from the integra-
tion over the interval [−1, 1] through the transformation x̃ = (s0 +s1 )/2+x(s1 −s0 )/2
Zs1
s1 − s0 X
n
f dx ≈ γi f (x̃i ).
2 i=1
s0
148 ■ Computational Framework for the Finite Element Method
√ √
By solving it, we find the values: γ1 = γ2 = 1, x1 = −1/ 3, x2 = 1/ 3.
As a result we obtain Gaussian quadrature with two nodes being exact
for polynomials of the third order

Z1    
1 1
f dx ≈ f −√ +f √ .
3 3
−1

Nodes and weights for larger values of m can be found tabulated in many
numerical analysis books.
Conditional number of interpolatory quadrature formulas.
When computing integrals, an integrand is often known approximately
with some error (for example, it could be computed with some rounding
error or measured with error). As a result, instead of exact value of
the integrand, f , approximated value is available, f ∗ = f + ϵ, having
some error ϵ. Let us estimate sensitivity of interpolatory quadrature with
respect to input data, or equivalently, defined a quadrature conditional
number, ν . If we assume that |f (x) − f ∗ (x)| < ϵ∗ ∀x ∈ [s0 , s1 ], then
 n 
X X
n  X
n Xn
 
 γi f (xi ) − γi f ∗ (xi ) ≤ ϵ∗ |γi | = νϵ∗ , ν = |γi |.
 
i=1 i=1 i=1 i=1

As such, perturbing input data lead to increasing quadrature error by

factor ν which is a conditional number. One important observation re-
garding the conditional number is that
X
n X
n
ν= |γi | ≥ γi ,
i=1 i=1

which means that if all weights are positive we obtain the smallest condi-
tional number; otherwise, we come to an ill-conditional quadrature. All
weights of Gaussian quadrature are positive which guarantees stability
with respect to input data errors.
 APPENDIX D

Quadrature Rules and

Orthogonal Polynomials

n general case, Gaussian quadrature rule for integral numerical calcu-

I lation can be derived using property of orthogonal polynomials. Here,
we provide some basics of the orthogonal polynomials theory and give
generic formulas to calculate quadrature nodes and weights. Let us start
with a definition.

Definition D.1 A family of polynomials {Pn (x)}∞ n=0 , x ∈ (s0 , s1 ), is

called a sequence of orthogonal polynomials with a weight ω(x) if the
following holds
Zs1
Pm (x) ∈ Gm , ω(x)Pi (x)Pj (x)dx = 0, i ̸= j.
s0

It is easy to see that orthogonal polynomials are defined up to con-

stant multipliers. Choice of multiplier values can be dictated by some
normalization, for example, they can be chosen so that to obtain unity
leading polynomial coefficient. An overview of the most important prop-
erties of the orthogonal polynomials is given below.
1. The polynomial Pn (t) has n real distinctive roots which are within
the interval of orthogonality.
2. The sequence of orthogonal polynomials satisfies a recurrence re-
lation of the form

Pk+1 (x) = (ak x − bk )Pk (x) − ck Pk−1 (x), k ≥ 0, P−1 (x) = 0.

DOI: 10.1201/9781003265979-D 149

150 ■ Computational Framework for the Finite Element Method

3. Polynomial roots, {xk }mk=1 , are the eigenvalues of the following

tridiagonal matrix
 √ 
√α0 β1 √
 β1 α1 β2 
 
 . . . 
An =  .. .. .. , (D.1)
 p p 
 βn−2 p αn−2 βn−1 
βn−1 αn−1

where
bk ck
αk = , k ≥ 0, βk = , k ≥ 1. (D.2)
ak ak−1 ak

4. Polynomial roots, {xk }nk=1 , are the nodes of Gauss Jacobi quadra-
ture
Zs1 Xn
f (x)ω(x)dx ≈ γk f (xk ), (D.3)
s0 k=1

where all γk > 0 and the quadrature is exact if f is a polynomial of

order 2n − 1. Vector of quadrature weights, γ = {γk }m k=1 , is found
from the expression
Zs1
2
γk = U1k m0 , m0 = ω(x)dx, (D.4)
s0

where U1k is the first row of the matrix U , columns of which are
normalized eigenvectors (i.e., eigenvectors with unity Euclidean
norm) of the matrix An , and An = U ΛU −1 , Λ = diag(x1 , . . . , xn ).

An important family of orthogonal polynomials are Jacobi polyno-

mials determined by the weight function of the form

ω(x) = (1 − x)α (1 + x)β , (s0 , s1 ) = (−1, 1), α, β > −1.

In this case, orthogonal polynomials depend on parameters {α, β} and

first two polynomials can be expressed as

(α,β) (α,β) 1
P0 (x) = 1, P1 (x) = ((α + β + 2) x + α − β) .
2
 Quadrature Rules and Orthogonal Polynomials ■ 151

Coefficients of recurrent formula are found through

(2k + α + β + 1)(2k + α + β + 2)
ak = , (D.5)
2(k + 1)(k + α + β + 1)
(β 2 − α2 )(2k + α + β + 1)
bk = ,
2(k + 1)(k + α + β + 1)(2k + α + β)
(k + α)(k + β)(2k + α + β + 2)
ck = .
(k + 1)(k + α + β + 1)(2k + α + β)

Integral in (D.4) can be found as follows:

Γ(α + 1)Γ(β + 1)
m0 = 2α+β+1 , (D.6)
Γ(α + β + 2)

where Γ(x) is a gamma function which is defined as Γ(x) = (x − 1)!

for any positive integer x. Derivatives of polynomials can be determined
through the expression
d (α,β) 1 (α+1,β+1)
Pn = (m + α + β + 1)Pn−1 (x). (D.7)
dx 2
Let us indicate some particular cases. When α = β = −1/2 we
obtain Chebyshev polynomials of the first type, Tn . Parameters α =
(0,0)
β = 0 correspond to Legendre polynomials, Ln = Pn , which represent
an important class of polynomials for obtaining quadrature rules. It is
worth indicating that when considering Legendre polynomials, we have
ω(x) = 1 and the quadrature (D.3) transforms into Gaussian quadrature
rule over the interval [−1, 1]

Z1 X
n
f (x)dx ≈ γk f (xk ),
−1 k=1

By substituting α = 0 and β = 0 into (D.5) and (D.6) we find the

matrix coefficients (D.2) to be αk = 0, βk = k 2 /(4k 2 − 1), and the
integral m0 = 2. As a result, quadrature weights to be γk = 2U1k 2 and

corresponding quadrature nodes are the eigenvalues of matrix An .

The nodes of the Gaussian quadrature, being the zeros of Legendre
polynomials, do not encompass the boundaries −1 and 1 of the interval
[−1, 1]. In some circumstance, it is desirable to include these points in
the boundaries. This is possible at the price of reducing by 2 units the
152 ■ Computational Framework for the Finite Element Method

degree of exactness of the Gaussian quadrature which results in Lobatto

quadrature

Z1 X
n−1
2 2
f (x)dx ≈ f (−1) + γk f (xk ) + f (1).
n(n − 1) n(n − 1)
−1 k=2

Similar to the Gaussian quadrature problem stated previously, in Lo-

batto quadrature we constrain x1 = −1 and xn = 1, which means we
now have less degree of freedom and the Lobatto quadrature is exact for
polynomials of order 2m − 3. In this case, quadrature nodes are roots
of the polynomial (1 − x2 )L′n−1 (x). Indeed, x1 and xn are the roots of
(1 − x2 ), and nodes x2 , . . . , xn−1 , are the n − 2 zeros of the polynomial
L′n−1 , or equivalently the points where the polynomial Ln−1 is extremal.
From (D.7) we see that roots of L′n−1 are roots of Pn−2 , and by sub-
(1,1)

stituting α = 1 and β = 1 into (D.5) and (D.6) we find the matrix

coefficients (D.2) to be αk = 0, βk = k(k + 1)/((2k + 1)(2k + 3)), and
the integral m0 = 4/3. Once quadrature weights, γ̃k , for L′n−1 are found,
corresponding weights for (1 − x2 )L′n−1 are defined as γk = γ̃k /(1 − x2k ).
 APPENDIX E

Computational
Framework in Python

E.1 ASSEMBLING MATRICES

How to calculate and assemble FEM matrices is explained in sections
5.3–5.5 where MATLAB function assemba() for the vectorized version of
the assembling algorithm is given. It is straightforward to translate this
function into Python with some minor changes.
Below we provide Python code for matrix calculating and assem-
bling algorithm utilizing sparse matrices. It follows the structure of the
MATLAB code given in section 5.5.
1 import numpy
2 import scipy. sparse as sparse
3 def assemblingAF (p,t,c,a,b1 ,b2 ,f=None ):
4 # assemblingAF - vectorized algorithm of the assembling
5 #stiffness matrix A and forcing vector F for the G1 mesh.
6 # Stiffness matrix A is associated with the PDE operator
7 # -div(c*grad(u)) + b*grad(u)+a*u
8 #The following call is allowed :
9 # A=assemblingAF(p,t,c,a,b1,b2)
10 #
11 np=p.shape [1]
12 # mesh point indices
13 k1=t[0 ,:]
14 k2=t[1 ,:]
15 k3=t[2 ,:]

DOI: 10.1201/9781003265979-E 153

154 ■ Computational Framework for the Finite Element Method

16 sdl=t[3 ,:] # subdomain labels

17 # barycenter of the triangles
18 x1=(p[0,k1]+p[0,k2 ]+p[0,k3 ])/3
19 x2=(p[1,k1]+p[1,k2 ]+p[1,k3 ])/3
20 # gradient of the basis functions, multiplied by J
21 g1 x1 =p[1,k2]−p[1,k3]
22 g1 x2 =p[0,k3]−p[0,k2]
23 g2 x1 =p[1,k3]−p[1,k1]
24 g2 x2 =p[0,k1]−p[0,k3]
25 g3 x1 =p[1,k1]−p[1,k2]
26 g3 x2 =p[0,k2]−p[0,k1]
27 J=abs( g3 x2 ∗ g2 x1−g3 x1 ∗ g2 x2 ) # J=2*area
28 # evaluate c , b , a on triangles barycenter
29 cf=c(x1 ,x2 ,sdl)
30 af=a(x1 ,x2 ,sdl)
31 b1f=b1(x1 ,x2 ,sdl)
32 b2f=b2(x1 ,x2 ,sdl)
33 # diagonal and off diagonal elements of mass matrix
34 ao=(af/24) ∗ J
35 ad=4∗ ao # ’exact’ integration
36 # ao=(af/18).*J ; ad=3*ao ; # quadrature rule
37 # coefficients of the stiffness matrix
38 cf =(0.5 ∗ cf)/J
39 a12=cf ∗(g1 x1 ∗ g2 x1 + g1 x2 ∗ g2 x2 )+ ao
40 a23=cf ∗(g2 x1 ∗ g3 x1 + g2 x2 ∗ g3 x2 )+ ao
41 a31=cf ∗(g3 x1 ∗ g1 x1 + g3 x2 ∗ g1 x2 )+ ao
42 A=[]
43 F=[]
44 if all(b1f ==0) and all(b2f ==0): # symmetric problem
45 A= sparse . coo matrix ((a12 ,(k1 ,k2)), shape =(np ,np))
46 A=A+ sparse . coo matrix ((a23 ,(k2 ,k3)), shape =(np ,np ))
47 A=A+ sparse . coo matrix ((a31 ,(k3 ,k1)), shape =(np ,np ))
48 A=A+ sparse . coo matrix . transpose (A)
49 A=A+ sparse . coo matrix ((ad−a31−a12 ,(k1 ,k1)), shape =(np ,np ))
50 A=A+ sparse . coo matrix ((ad−a12−a23 ,(k2 ,k2)), shape =(np ,np ))
51 A=A+ sparse . coo matrix ((ad−a23−a31 ,(k3 ,k3)), shape =(np ,np ))
52 else:
53 # b contributions
54 b1f=b1f /6
55 b2f=b2f /6
 Computational Framework in Python ■ 155

56 bg1=b1f∗ g1 x1 +b2f∗ g1 x2
57 bg2=b1f∗ g2 x1 +b2f∗ g2 x2
58 bg3=b1f∗ g3 x1 +b2f∗ g3 x2
59 A= sparse . coo matrix (( a12+bg2 ,(k1 ,k2)), shape =(np ,np ))
60 A=A+ sparse . coo matrix (( a23+bg3 ,(k2 ,k3)), shape =(np ,np ))
61 A=A+ sparse . coo matrix (( a31+bg1 ,(k3 ,k1)), shape =(np ,np ))
62 A=A+ sparse . coo matrix (( a12+bg1 ,(k2 ,k1)), shape =(np ,np ))
63 A=A+ sparse . coo matrix (( a23+bg2 ,(k3 ,k2)), shape =(np ,np ))
64 A=A+ sparse . coo matrix (( a31+bg3 ,(k1 ,k3)), shape =(np ,np ))
65 A=A+ sparse . coo matrix ((ad−a31−a12+bg1 ,(k1 ,k1)), \
66 shape =(np ,np ))
67 A=A+ sparse . coo matrix ((ad−a12−a23+bg2 ,(k2 ,k2)), \
68 shape =(np ,np ))
69 A=A+ sparse . coo matrix ((ad−a23−a31+bg3 ,(k3 ,k3)), \
70 shape =(np ,np ))
71 if f!= None:
72 ff=f(x1 ,x2 ,sdl)
73 ff=(ff/6)∗ J
74 k zero =numpy. zeros (k1. shape )
75 F= sparse . coo matrix ((ff ,(k1 , k zero )), shape =(np ,1))
76 F=F+ sparse . coo matrix ((ff ,(k2 , k zero )), shape =(np ,1))
77 F=F+ sparse . coo matrix ((ff ,(k3 , k zero )), shape =(np ,1))
78 return A,F
79 else: return A

Listing E.1: Python code for assembling stiffness matrices.

E.2 ASSEMBLING BOUNDARY CONDITIONS

Implementation of boundary condition calculation in Python is based
on the approach described in section 5.6. We use dictionary struc-
ture containing list of boundary segments and corresponding function
names defined on these segments. For example, by defining the function
uD(x1,x2,sdl)

1 def uD(x1 ,x2 ,sdl ):

2 f=numpy.zeros(x1. shape)
3 # segments in local numeration:
4 # 1-st segment
5 I=sdl ==0
6 f[I]= numpy. square (x1[I])+ numpy . square (x2[I])
156 ■ Computational Framework for the Finite Element Method

7 # 2-nd segment
8 I=sdl ==1
9 f[I]= numpy. square (x1[I])+ numpy . square (x2[I])
10 return f

Listing E.2: Python code for defining BC.

we can specify Dirichlet boundary conditions on the first and third seg-
ments as
bc={}
bc["bsD"]=[1 , 3]
bc["uD"]= uD

Python implementation of the function assemblingBC() given below per-

forms assembling boundary conditions and repeat the logic of the corre-
sponding MATLAB function.
1 import numpy
2 import scipy. sparse as sparse
3 def assemblingBC (bc ,p,e, nargout ):
4 # assemblingBC - assembling boundary conditions
5 # The following call is also allowed :
6 # N,S = assemblingBC(bc,p,e,nargout)
7 # N,S,UD = assemblingBC(bc,p,e,nargout)
8 np=p.shape [1]
9 S=[]
10 M=[]
11 N= sparse .eye(np)
12 UD =[]
13 if (bc["bsR"]== None) and \
14 (bc["sg"]== None) and \
15 (bc["mu"]== None ):
16 return # all boundaries are homogeneous Robin b.c.
17 e=e[:, numpy. logical or (e[5 ,:]==0 ,e [6 ,:]==0)] #boundary edges
18 k=e[4 ,:]
19 bsg=numpy. transpose ( numpy. nonzero ( \
20 sparse . coo matrix ( \
21 (numpy .ones(len(k)) ,(k,k)), shape =(np ,np ))))[: ,0]
22 nbsg=len(bsg)
23 # set local numeration of boundary segments
24 local=numpy.zeros (( nbsg ))
25 # set mixed boundary conditions
 Computational Framework in Python ■ 157

26 if nargout >=2:
27 bsR=bc["bsR"]
28 if len(bsR)>0:
29 if bsR == None: # all BC are mixed
30 bsR=bsg
31 local[bsR ]= range (0, len(bsR ))
32 # find boudary edges with mixed b.c.
33 eR=e[:, numpy .isin(k,bsR )]
34 eR=eR[[0, 1, 4] ,:]
35 k1=eR [0 ,:]
36 k2=eR [1 ,:] # indices of starting points and endpoints
37 x1=0.5 ∗ (p[0,k1 ]+p[0,k2 ])
38 x2=0.5 ∗ (p[1,k1 ]+p[1,k2 ])
39 h=numpy.sqrt( numpy . square (p[0,k2]−p[0,k1 ])
40 +numpy . square (p[1,k2]−p[1,k1 ])) # edges length
41 sdl= local [eR [2 ,:]]
42 # evaluate sigma , mu on edges barycenter
43 sf=bc["sg"](x1 ,x2 ,sdl)
44 mf=bc["mu"](x1 ,x2 ,sdl)
45 # ’exact’ integration
46 so=( sf/6)∗ h
47 sd=2∗ so
48 # quadrature rule
49 #so=(sf/4)*h
50 #sd = so
51 S= sparse . coo matrix ((so ,(k1 ,k2)), shape =(np ,np ))
52 S=S+ sparse . coo matrix ((so ,(k2 ,k1)), shape =(np ,np ))
53 S=S+ sparse . coo matrix ((sd ,(k1 ,k1)), shape =(np ,np ))
54 S=S+ sparse . coo matrix ((sd ,(k2 ,k2)), shape =(np ,np ))
55 if nargout ==4:
56 mf=bc["mu"](x1 ,x2 ,sdl)
57 mf=(mf/2)∗ h
58 k zero = numpy . zeros (k1. shape )
59 M= sparse . coo matrix ((mf ,(k1 , k zero )), \
60 shape =(np ,1))
61 M=M+ sparse . coo matrix ((mf ,(k2 , k zero )), \
62 shape =(np ,1))
63 # set Dirichlet boundary conditions
64 bsD=bc["bsD"]
65 if len(bsD)>0:
158 ■ Computational Framework for the Finite Element Method

66 if bsD == None: # all b.c. are Dirichlet

67 bsD=bsg
68 local[bsD ]= range (0, len(bsD ))
69 if all(local ==0):
70 print (’error . bsD+bsR ~= number of boundary segments ’)
71 eD=e[:, numpy.isin(k,bsD )] # boudary with Dirichlet BC
72 eD=eD[[0, 1, 4] ,:]
73 sdl= local[eD [2 ,:]]
74 # indices of start and end points
75 k1=eD [0 ,:]
76 k2=eD [1 ,:]
77 iD=numpy. concatenate ([k1 , k2]) # Dirichlet points indices
78 i d =numpy. transpose ( numpy . nonzero (
79 sparse . coo matrix (
80 (numpy .ones(len(iD )) ,(iD ,iD)), \
81 shape =(np ,np ))))[: ,0]
82 # iN - indices of nonDirichlet points
83 iN=numpy.ones (( np ))
84 iN[ i d ]= numpy .zeros (( len( i d )))
85 iN=numpy. transpose ( numpy . nonzero (iN )). flatten ()
86 niN=len(iN)
87 N= sparse . coo matrix (( numpy .ones(niN), \
88 (iN , range (0, niN ))) , shape =(np ,niN ))
89 if nargout >=3: # evaluate UD on Dirichlet points
90 UD= sparse . csr matrix ((1, np ))
91 UD[0,k1]= bc["uD"](p[0,k1],p[1,k1],sdl)
92 UD[0,k2]= bc["uD"](p[0,k2],p[1,k2],sdl)
93 UD=UD. reshape ((np ,1))
94 if nargout ==2: return N,S
95 elif nargout ==3: return N,S,UD
96 elif nargout ==4: return N,S,UD ,M
97 else:print (’assemblingBC : Wrong number of output parameters .’)

Listing E.3: Python code for assembling BC.

Here, we need to explain how to implement in Python some MAT-

LAB functions. For instance, MATLAB function find(a) which finds in-
dices and values of nonzero elements of the array a can be represented
in Python as function numpy.nonzero(a) which returns a tuple of arrays,
one for each dimension of a, containing the indices of the nonzero ele-
ments in that dimension. To group the indices by element, rather than
 Computational Framework in Python ■ 159

dimension, we can use numpy.transpose(numpy.nonzero(a)) which results in

two-dimensional array of indices with a row for each nonzero element.
Logical operations over Boolean arrays can be performed through special
functions of the numpy package, for example, function numpy.logical or(x1,x2)
applies logical OR to the elements of x1 and x2. MATLAB function
ismember(x1,x2) corresponds to Python function numpy.isin(x1,x2) which re-
turns a Boolean array of the same shape as array x1 that is True where an
element of x1 is in x2 and False otherwise. Listing E.4 shows a function
assemblingPDE() code for solving a PDE problem. Function spsolve() is used
here to solve linear system of sparse matrices.
1 import numpy
2 import scipy. sparse as sparse
3 from scipy . sparse . linalg import spsolve
4 def assemblingPDE (bc ,p,e,t,c,a,b1 ,b2 ,f, nargout ):
5 # A,F,N,UD,S,M=assemblingPDE(bc,p,e,t,c,a,b1,b2,f,nargout) -
6 #returns FEM matrices of the PDE problem.
7 # u=assemblingPDE(bc,p,e,t,c,a,b1,b2,f,nargout) -
8 #returns solution to the PDE problem
9 A=[]; F=[] ; UD =[]; S=[]; M=[]
10 if nargout ==6:
11 A,F= assemblingAF (p,t,c,a,b1 ,b2 ,f)
12 N,S,UD ,M= assemblingBC (bc ,p,e ,4)
13 return A,F,N,UD ,S,M
14 elif ( nargout == 1):
15 A,F= assemblingAF (p,t,c,a,b1 ,b2 ,f)
16 N,S,UD ,M= assemblingBC (bc ,p,e ,4)
17 if N.shape [1]== p. shape [1]: # no Dirichlet BC
18 A=A+S; F=F+M
19 else:
20 Nt= sparse . coo matrix . transpose (N)
21 A=A+S
22 F=Nt @ ((F+M)−A @ UD)
23 A=Nt @ A @ N
24 u= sparse . linalg . spsolve (A,F)
25 u=( sparse . coo matrix (u)). reshape ((u.shape [0] ,1))
26 return (N @ u+UD)
27 else: print (’assembpde : Wrong number of output parameters .’)

Listing E.4: Python code for solving PDE.

160 ■ Computational Framework for the Finite Element Method

E.3 SOLVING EXAMPLE PROBLEM

As a final step, let us create a Python code for solving the example
problem formulated in section 5.8. The code is self-documented and easy
to read.
1 import pygmsh
2 import numpy
3 import scipy. sparse as sparse
4 from scipy . sparse . linalg import spsolve
5 #geometry definition
6 def disk(h):
7 geom = pygmsh . built in . Geometry ()
8 # cirlcle
9 cirlcle p0 = geom. add point ([0.0 , 0.0 , 0.0] , h) #center
10 cirlcle p1 = geom. add point([−1.0, 0.0 , 0.0] , h)
11 cirlcle p2 = geom. add point ([0.0 , −1.0, 0.0] , h)
12 cirlcle p3 = geom. add point ([1.0 , 0.0 , 0.0] , h)
13 cirlcle p4 = geom. add point ([0.0 , 1.0 , 0.0] , h)
14
15 arc 1 =geom. add circle arc ( cirlcle p1 , cirlcle p0 , cirlcle p2 )
16 arc 2 =geom. add circle arc ( cirlcle p2 , cirlcle p0 , cirlcle p3 )
17 arc 3 =geom. add circle arc ( cirlcle p3 , cirlcle p0 , cirlcle p4 )
18 arc 4 =geom. add circle arc ( cirlcle p4 , cirlcle p0 , cirlcle p1 )
19
20 circle = geom. add line loop ([ arc 1 , arc 2 , arc 3 , arc 4 ])
21 disk = geom. add plane surface ( circle )
22 #make boundary and area physical
23 geom labels={}
24 group id =geom. TAKEN PHYSICALGROUP IDS
25 ph disk = geom. add physical surface (disk , label ="1")
26 geom labels [ group id[−1]]="1"
27 p h a r c 1 = geom. add physical line ( arc 1 ,label ="1:L1:R0")
28 geom labels [ group id[−1]]="1: L1:R0"
29 p h a r c 2 = geom. add physical line ( arc 2 ,label ="2:L1:R0")
30 geom labels [ group id[−1]]="2: L1:R0"
31 p h a r c 3 = geom. add physical line ( arc 3 ,label ="3:L1:R0")
32 geom labels [ group id[−1]]="3: L1:R0"
33 p h a r c 4 = geom. add physical line ( arc 4 ,label ="4:L1:R0")
34 geom labels [ group id[−1]]="4: L1:R0"
35 return geom , geom labels
 Computational Framework in Python ■ 161

36
37 # boundary conditions
38 def uD(x1 ,x2 ,sdl ):
39 f=numpy.zeros(x1. shape )
40 I=sdl ==0
41 f[I]= numpy. square (x1[I])+ numpy . square (x2[I])
42 I=sdl ==1
43 f[I]= numpy. square (x1[I])+ numpy . square (x2[I])
44 return f
45
46 def sigma(x1 ,x2 ,sdl ):
47 f=numpy.zeros(x1. shape )
48 I=sdl ==0
49 f[I]=0
50 I=sdl ==1
51 f[I]=2
52 return f
53
54 def mu(x1 ,x2 ,sdl ):
55 f=numpy.zeros(x1. shape )
56 I=sdl ==0
57 f[I]=2 ∗ (2+x1[I]+x2[I])∗(numpy . square (x1[I])+ \
58 numpy . square (x2[I]))
59 I=sdl ==1
60 f[I]=2 ∗ (2+x1[I]+x2[I]+1) ∗ ( numpy . square (x1[I])+ \
61 numpy . square (x2[I]))
62 return f
63
64 #main function
65 def testPDE ():
66 np =[] ; nt =[] ; errh2 =[] ; err =[] ;
67 for h in [0.5 , 0.1 , 0.05 , 0.02]:
68 geom , geom labels =mg.disk(h)
69 p,t,e = generateMesh (geom , geom labels )
70 p=numpy. transpose (p)
71 t=numpy. transpose (t)
72 e=numpy. transpose (e)
73 x1=p[0 ,:]
74 x2=p[1 ,:]
75 def exact(x1 ,x2 ,sdl ):
162 ■ Computational Framework for the Finite Element Method

76 return numpy . square (x1 )+ numpy . square (x2)

77 def c(x1 ,x2 ,sdl ): return 2+ x1+x2
78 def a(x1 ,x2 ,sdl ): return x1+x2
79 def f(x1 ,x2 ,sdl ):
80 return −8−6∗(x1+x2 )+(2+ x1+x2)∗ \
81 ( numpy . square (x1 )+ numpy. square (x2 ))
82 def b1(x1 ,x2 ,sdl ): return x1
83 def b2(x1 ,x2 ,sdl ): return x2
84 u exact =numpy . transpose ( exact (x1 ,x2 ,1))
85 bc={}
86 bc["bsD"]=[1 , 3]
87 bc["uD"]=uD
88 bc["bsR"]=[4 , 2]
89 bc["sg"]= sigma
90 bc["mu"]=mu
91 A,F= assemblingAF (p,t,c,a,b1 ,b2 ,f)
92 N,S,UD ,M= assemblingBC (bc ,p,e ,4)
93 u= assemblingPDE (bc ,p,e,t,c,a,b1 ,b2 ,f ,1). toarray ()
94 u exact = u exact . reshape (u. shape )
95 np. append (p.shape [1])
96 nt. append (t.shape [1])
97 h2=h∗h
98 err. append ( numpy . linalg .norm( u exact−u, numpy .inf ))
99 errh2. append ( numpy . linalg .norm( u exact−u, numpy .inf )/ h2)
100 print (’{:<10s}{:<10s }{:^10s }{:^10s}’. format (
101 "np","nt","err"," errh2 "))
102 print ()
103 for i in range (len(err )):
104 print (’{:<10d}{:<10d }{ :^10.5f }{ :^10.5f}’. format (
105 np[i],nt[i],err[i],errh2 [i]))

Listing E.5: Python code for solving example problem.

Here, geometry is defined in function disk() and BC are specified in

functions uD(), sigma() and mu(). Function testPDE() when called calculates
solution values and prints solution error in various norms.
Bibliography

[1] G. Dhatt, G. Touzot, and E. Lefrancois. Finite Element Method.

London, UK: ISTE Ltd, 2012.
[2] A.J.M. Ferreira. MATLAB Codes for Finite Element Analysis.
Vol. 157. Solid Mechanics and Its Applications. Springer, 2009.
[3] Mark S. Gockenbach. Understanding and Implementing the Finite
Element Method. Society for Industrial and Applied Mathematics,
2006.
[4] E. Jones, T. Oliphant, P. Peterson, et al. SciPy: Open Source Sci-
entific Tools for Python. 2001. url: http://www.scipy.org/.
[5] Gang Li. Introduction to the Finite Element Method and Implemen-
tation with MATLAB. Cambridge University Press, 2020.
[6] MATLAB and Partial Differential Equation Toolbox Release 2019a.
Natick, Massachusetts, USA, 2019. url: http://www.mathworks.
com/.
[7] Travis E. Oliphant. A Guide to NumPy. USA: Trelgol Publishing,
2006.

163
Index

Approximate solution 14, 71 Global stiffness matrix 17, 27,

Assembling boundary 73, 74
conditions 51, 121
Assembling global matrices 29, Integral equation 7, 71
75, 101 Interpolating matrix 32
Interpolating polynomial 9, 73
Barycentric formula 10 Interpolation condition 9
Basis functions 9, 10, 15, 30, 72 Interpolation nodes 9
Boundary value problem 3, 70 Interpolatory quadrature 145
Canonical element 30, 109
Lagrange spline 13
Chebyshev polynomials 151
Lobatto quadrature 35, 152
Classical solution 4
Local forcing vector 28, 75, 112
Connectivity matrix 74, 85
Local stiffness matrix 28, 75,
Differentiating matrix 32 108
Dirichlet boundary condition 3,
70 Neumann boundary condition 3

Edge matrix 75, 85 Orthogonal polynomials 149

Extended local forcing vector Orthogonal projection 5
29, 75
Extended local stiffness matrix Point coordinates matrix 85
28, 75 Projective method 5

Finite element method xiii, 8, Quadrature precision order 145

14 Quadrature rule 31, 34
Finite elements 13, 71, 72
Robin boundary condition 3, 70
Gaussian quadrature 34, 146,
151 Sparse matrix 42
Global forcing vector 17, 28, 73,
74 Weak solution 7

165