Starting in the spring 2013, I videotaped the lectures
for my *MATH 676: Finite element methods in scientific
computing* course
at the KAMU TV studio at
Texas A&M. These are lectures
on many aspects of scientific computing, software,
and the practical aspects of the finite element method, as
well as their implementation in the
deal.II software library. Support
for creating these videos was also provided by the
National Science Foundation and
the Computational
Infrastructure in Geodynamics.

The videos are part of a broader effort to develop a modern way of teaching Computational Science and Engineering (CS&E) courses. If you are interested in adapting our approach, you may be interested in this paper I wrote with a number of education researchers about the structure of such courses and how they work.

**Note 1:** In some of the videos, I demonstrate code or user
interfaces. If you can't read the text, change the
video quality by clicking on the "gear" symbol at the
bottom right of the YouTube player.

**Note 2:**
deal.II is an
actively developed library, and in the course of this
development we occasionally deprecate and remove
functionality. In some cases, this implies that we also
change tutorial programs, but the nature of videos is that
this is not reflected in something that may have been
recorded years ago. If in doubt, consult
the *current* version of the tutorial.

Table of contents | |
---|---|

Lecture 1 | Course overview; why consider existing software libraries |

Lecture 2 | A real brief overview of deal.II |

Lecture 2.9 | A (very brief) introduction to Linux. Part 1: The command line |

Lecture 2.91 | A (very brief) introduction to Linux. Part 2: Compiling programs |

Lecture 3 | Obtaining and installing deal.II |

Lecture 3.9 NEW | The ideas behind the finite element method. Part 1: Approximation |

Lecture 3.91 NEW | The ideas behind the finite element method. Part 2: Theory of (piecewise) polynomial approximation |

Lecture 3.92 NEW | The ideas behind the finite element method. Part 3: Piecewise polynomial approximation in 2d/3d |

Lecture 3.93 NEW | The ideas behind the finite element method. Part 4: Finding an approximation |

Lecture 3.95 NEW | The ideas behind the finite element method. Part 6: Error estimates for the Laplace equation |

Lecture 3.98 NEW | The ideas behind the finite element method. Part 9: Sparsity as a key property |

Lecture 4 | The building blocks of a finite element code |

Lecture 5 | step-1, part 1: Simple meshes |

Lecture 6 | step-1, part 2: Playing with meshes |

Lecture 7 | Learning to use modern tools, part 1 – Eclipse: an Integrated Development Environment (IDE), fragment 1 |

Lecture 8 | Learning to use modern tools, part 1 – Eclipse: an Integrated Development Environment (IDE), fragment 2 |

Lecture 8.01 | Learning to use modern tools, part 1 – Eclipse: an Integrated Development Environment (IDE). Update: Direct project setup via CMake |

Lecture 9 | step-2: Degrees of freedom, sparsity in finite element matrices |

Lecture 10 | step-3: A first Laplace solver |

Lecture 11 | Learning to use modern tools, part 2 – Visit: a visualization tool |

Lecture 12 | A little bit of C++: Templates |

Lecture 13 | step-4: A dimension-independent Laplace solver |

Lecture 14 | step-5: Computing on successively refined meshes |

Lecture 15 | Adaptively refined meshes |

Lecture 16 | Hanging nodes and other constraints |

Lecture 17 | step-6: Adaptive meshes |

Lecture 17.25 | Generating adaptively refined meshes: Simple refinement indicators |

Lecture 17.5 | Generating adaptively refined meshes: Which cells to refine |

Lecture 17.75 | Generating adaptively refined meshes: A posteriori error estimators |

Lecture 18 | Debug vs. optimized mode |

Lecture 19 | Problems with more than one solution variable |

Lecture 20 | step-20: The mixed Laplace equation |

Lecture 21 | Block structured solvers for vector-valued problems |

Lecture 21.5 | Boundary conditions. Part 1: Theory |

Lecture 21.55 | Boundary conditions. Part 2: Neumann and Robin boundary conditions |

Lecture 21.6 | Boundary conditions. Part 3a: Homogenous Dirichlet boundary conditions |

Lecture 21.65 | Boundary conditions. Part 3b: Inhomogenous Dirichlet boundary conditions |

Lecture 22 | Some data structure design considerations |

Lecture 23 | Learning to use modern tools, part 3 – doxygen: a documentation tool |

Lecture 24 | Best programming practices: Defensive programming and other ways to avoid bugs |

Lecture 25 | More on debugging using Eclipse's built-in debugger |

Lecture 26 | Time dependent problems: A taxonomy |

Lecture 27 | Time discretizations for parabolic problems |

Lecture 28 | Time discretizations for second-order hyperbolic problems |

Lecture 29 | The step-26 tutorial program -- the heat equation. Part 1: The basics |

Lecture 30 | The step-26 tutorial program -- the heat equation. Part 2: Adaptive meshes for time dependent problems |

Lecture 30.25 | Time discretizations for advection-diffusion and other problems: IMEX, operator splitting, and other ideas |

Lecture 31 | First-order hyperbolic systems |

Lecture 31.5 | Nonlinear problems, part 1: Introduction |

Lecture 31.55 | Nonlinear problems, part 2: Newton's method for PDEs |

Lecture 31.6 | Nonlinear problems, part 3: Newton's method for the minimal surface equation, step-15 |

Lecture 31.65 | Nonlinear problems, part 4: Fixed point/Picard iteration for the minimal surface equation |

Lecture 31.7 | Nonlinear problems, part 5: Pseudo-time stepping for the minimal surface equation |

Lecture 32 | Learning to use modern tools, part 4 – Paraview, an alternative visualization tool |

Lecture 32.5 | Learning to use modern tools, part 5a: Version control systems (VCSs), Subversion |

Lecture 32.55 | Learning to use modern tools, part 5a1: Version control systems (VCSs), Subversion – undoing, branching and merging |

Lecture 32.75 | Learning to use modern tools, part 5b: Version control systems (VCSs), git |

Lecture 32.8 | Learning to use modern tools, part 5b1: Version control systems (VCSs), Using git and github in practice |

Lecture 33 | Which element to use. Part 1: "Simple" problems |

Lecture 33.25 | Which element to use. Part 2: Saddle-points problems |

Lecture 33.5 | Which quadrature formula to use |

Lecture 34 | What solver to use |

Lecture 35 | What preconditioner to use — Introduction and Parts 1+2: Simple preconditioners for simple problems |

Lecture 37 | What preconditioner to use — Part 4: Simple preconditioners for complex problems |

Lecture 38 | What preconditioner to use — Part 5: Complex ("physics-based"/"block") preconditioners for complex problems |

Lecture 39 | Parallelization: Introduction |

Lecture 40 | Parallelization on a single, shared memory machine |

Lecture 41 | Parallelization on a cluster of distributed memory machines — Part 1: Introduction to MPI |

Lecture 41.25 | Parallelization on a cluster of distributed memory machines — Part 2: Debugging with MPI |

Lecture 41.5 | Parallelization on a cluster of distributed memory machines — Part 3: Distributed computing in deal.II and step-40 |

Lecture 41.75 | Parallelization on a cluster of distributed memory machines — Part 4: Parallel solvers and preconditioners |

Lecture 42 | Beyond computational methods — Part 1: Workflows in scientific computing |

Lecture 43 | Beyond computational methods — Part 2: Issues with developing large software |