## Courses at TU Delft (2013-present)

### ATHENS: Introduction into Finite Elements and Algorithms

#### Course description

This course which is part of the ATHENS Programme provides understanding in the basic principles of the finite element method (FEM) for solving canonical elliptic and parabolic partial differential equations modeling diffusion and transport phenomena. Unlike courses elaborating the mathematical foundations of the FEM on one hand, and those focussing on a particular software package for solving advanced engineering applications on the other end of the spectrum, this course discusses the algorithmic aspects of the FEM. Starting from either a boundary or initial value problem, the variational formulation is derived to be able to subsequentially discretize the problem in space and time. The element-by-element construction of the discrete problem and algorithms to solve it are presented. At the end of this course students will have gained the theoretical knowledge and constructed a software framework enabling them to build their own finite element solver package.

I have been giving the following guest lectures:

### AESB2210: Mathematics 5

#### Course description

This introductory course on numerical methods mathematics mainly deals with numerical methods for the approximate solution of differential equations which are typically used to model real-world phenomena (e.g., the time-dependent expansion of heat in a metal beam or the deformation of a membrane under constant load). The following topics are discussed:

• Floating point numbers/arithmetic and rounding errors;
• Numerical differentiation (divided finite differences);
• Single-step time stepping methods for linear and non-linear scalar problems and systems of equations (explicit/implicit, (numerical) stability, convergence, global/local errors, amplification of errors, test equation/system);
• Runge-Kutta methods (including theoretical analysis);
• Interpolation/extrapolation (Lagrange interpolation, Spline interpolation);
• Numerical methods for boundary value problems in 1D (boundary conditions, stabilization of convective terms);
• Iterative solution of non-linear problems (fixed point iteration, Newton-Raphson method).

The course contains both theoretical exercises as well as practical programming sessions during which some of the presented algorithms shall be implemented in Matlab.

#### Literature

• C. Vuik, F.J. Vermolen, M.B. van Gijzen, M.J. Vuik, Numerical Methods for Ordinary Differential Equations. Delft Academic Press/VSSD, second edition, 2015.

#### Literature

• C. Vuik, F.J. Vermolen, M.B. van Gijzen, M.J. Vuik, Numerical Methods for Ordinary Differential Equations. Delft Academic Press/VSSD, second edition, 2015.

#### Literature

• C. Vuik, P. van Beek, F. Vermolen, J. van Kan, Numerical Methods for Ordinary Differential Equations. VSSD, first edition, 2007.

### Seminar: From the basics of modern OOP to parallel scientific programming in C++11

#### Motivation

MATLAB, Python & Co. are very good tools for developing prototypes and for testing new scientific ideas 'within a minute'. Their mathematical notation and the wealth of excellent add-ons addressing all types of mathematical problems make it easy to implement numerical algorithms without struggling with technical details. For instance, the solution of a linear system of equations is as easy as typing


x=A\b


The downside of this programmers' comfort zone is threefold:

Firstly, you hardly know what your code is doing 'under the hood' so that you have to trust the add-on providers that their routines are implemented correctly. Even then you cannot be totally sure that you are using these toolboxes in the correct way and they won't tell you.

Secondly, it is wishful thinking that you can exploit the full power of modern computers by naively calling some 'parallelised' or 'CUDA-enabled' black-box routines. Doing so, you can be lucky if the code still produces correct results and is not slower than before.

Thirdly, if you start using low-level programming techniques such as loops, branching, etc. then the nature of interpreted programming language strikes back making your code unpractically slow.

If you already encountered one or more of these problems then it is time to learn scientific programming in a language like C++11. Like C and Fortran, C++11 is a compiled programming language that allows you to express your algorithms in low-level but still human-readable notation and transform it into hardware-optimised machine code using a compiler. It is an insistent rumor that such languages are difficult to learn, that using them is time-consuming and, in general, that you have to be a computer nerd to program in C++. Starting with the right choice of development tools and extensions, solving a linear system of equations is as easy as typing


SparseMatrix<double> A(n,n);
Vector<double> x(n), b(n);
cg.compute(A);
x=cg.solve(b);


But this time, you have full control over all internals and can adjust them to your particular needs.

#### Mission

This seminar is not a typical C++ programming course that aims at discussing all aspects of the language at length, including legacy techniques that lead to hardly-readable codes. It is about design concepts and practical aspects of modern scientific programming thereby using C++11 as a vehicle only.

This seminar follows a pragmatic problem-oriented approach. Starting from a concrete problem description like 'How to design and develop an efficient linear solver for Ax=b?', only those aspects of the language will be introduced that are really needed to master the problem or make its implementation much more flexible and efficient. We explicitly focus on the recent language standard.

C++11, which introduced several very powerful and easy to use concepts for modern scientific programming and overcomes many of the drawbacks and pitfalls of previous standards.

The second mission of this seminar is to introduce concepts of parallel programming using OpenMP following the same pragmatic problem-oriented approach. It is a common misunderstanding that parallelisation is the second step in code development once a sequential implementation is completed. In this seminar, parallelisation is considered integral part of the design and development process. Writing parallel code is rather easy, making it run fast is a challenge. In essence, the way how data is stored and the way how algorithms are parallelised need to harmonise and that can be best assured starting from the design of the code.

The third aim of this seminar is to demonstrate a possible workflow for efficient code development using established tools for editing, refactoring, compiling, debugging, and profiling the code. Modern multi-core hardware as well as practical scientific codes are too complex to edit them in a standard text editor, compile the source code 'by hand' and identify bugs and efficiency bottlenecks just from visual inspection. We will introduce and utilise several specialised software tools that manage the entire build and testing process and assist us in finding bottlenecks and pitfalls of the parallelisation. The aim is to get familiar with such tools and make them a regular part of the daily programming work.

#### Audience and prerequisites

This seminar addresses PhD and Master students from disciplines such as (but not limited to) Applied Mathematics, Aerospace Engineering, Civil Engineering and Geosciences, who are interested in learning scientific programming for real-world problems. Some background in numerical mathematics is expected and basic programming experience (e.g. in MATLAB) is required to be able to follow the course.

#### Course schedule

The first part of this seminar is organised as lectures (2h per week) with integrated programming exercises following a fixed schedule to introduce and practice the basic concepts. Afterwards, we will apply these concepts (and introduce new ones if required) to solve concrete problems suggested by the participants (2h per week).

#### ECTS and GS points

Master students can obtain 3 ECTS points for actively participating in this course and finishing a final programming project. PhD students obtain 1 GS points per 8 hours participation (no final programming project required).

#### Time and place

The seminar takes place every Tuesday between 13:30 and 15:30 in the Laboratory Room at the fifth floor. The first session is on Tuesday, 08.09.2015.

#### Assignments

1. Homework no.1
2. Homework no.2
3. Homework no.3
4. Homework no.4
5. Take home exam (The relevant section 3.4 from the book Numerical Methods in Scientific Computing by J. van Kan, A. Segal, F. Vermolen can be downloaded here)

#### Literature

• Git version control system
• A good and easy to understand introduction can be found in the Getting Started tutorial.
• A detailed description of all GIT features is given in the Git Pro book by Scott Chacon and Ben Straub which is available online as free eBook.
• CMake
• A practical introduction to CMake can be found in the CMake Tutorial.
• C++11

All source code examples from the course are available at https://gitlab.com/mmoelle1/cpp11-seminar.git which you can either browse online or copy to your local harddisk via:

                    git clone https://gitlab.com/mmoelle1/cpp11-seminar.git cpp11-seminar

Please make sure that you get the latest version of the source code right before the session by running
                    git pull

from inside the directory cpp11-seminar.

#### Software

This seminar is supported by Intel via the Intel Educator program. This support is greatly acknowledged. Via the Intel Educator program, participants of this course have access to the complete portfolio of Intel software development products on the computers in the Laboratory Room.

It is not allowed to transfer Intel software licenses to computers other than the ones in the Laboratory Room. If you intent to use your own laptop please make sure that you install at least the following alternative software tools

1. cmake (version 3.x is recommended but version 2.8 and above will also work)
2. git (version 2.x is recommended)
3. doxygen
4. GNU C++ compiler version 4.8.x or above (4.9.x or 5.2.x is recommended since the support of C++11-features has been significantly improved)

Please note that this minimal requirement allows you to compile and run all examples of the course. However, advanced topics such as debugging and profiling applications will be done using Intel tools which lack an open-source counterpart.

##### Linux

Additional software under Linux can be installed via a package manager (apt, yum, yast2, ...) that is shipped with the distribution. Please check with the documentation of your distribution how to install the required packages.

##### Mac OS X

A simple way to install all required packages under Mac OS X is to download and install Homebrew following the instruction on the web and run

                  
brew update
brew install cmake
brew install doxygen --with-graphviz
brew install git
brew install gcc --without-multilib


to install the required packages. Since Homebrew installs/compiles packages from source installation can take several hours. Please note that clang (the C++ compiler shipped with Mac OS X) does not support OpenMP which will be used for parallelization during this course. Therefore, installation of the GNU C++ compiler is required.

##### Windows

Windows users may want to try the Cygwin project which aims at providing a collection of GNU tools under Windows.

### Seminar: Numerical Algorithms for Quantum Computers

#### Time and place

The seminar will take place as follows:

• 10.02.2015: Lipkenszaal 36-LB 01.150, EWI building (13:00-15:00)
• 17.02.2015: Timmanzaal 36-LB 01.170, EWI building (13:00-15:00)>/li>
• 03.03.2015: Timmanzaal 36-LB 01.170, EWI building (13:00-15:00)
• 17.03.2015: Timmanzaal 36-LB 01.170, EWI building (13:00-15:00)
• 24.03.2015: Coffeeroom 36-HB 05.230, EWI building (13:15-14:15)
• 31.03.2015: Coffeeroom 36-HB 05.230, EWI building (13:15-14:15)
• 07.04.2015: Coffeeroom 36-HB 05.230, EWI building (13:15-14:15)
• 14.04.2015: Timmanzaal 36-LB 01.170, EWI building (13:00-15:00)
• 21.04.2015: Coffeeroom 36-HB 05.230, EWI building (13:00-15:00)
• 28.04.2015: Timmanzaal 36-LB 01.170, EWI building (13:00-15:00)
• 12.05.2015: Timmanzaal 36-LB 01.170, EWI building (cancelled !!!)
• 19.05.2015: Coffeeroom 36-HB 05.230, EWI building (13:00-15:00)
• 26.05.2015: Snijderszaal 36-LB 01.010, EWI building (13:00-15:00)
• 09.06.2015: Coffeeroom 36-HB 05.230, EWI building (13:00-15:00)
• 30.06.2015: Coffeeroom 36-HB 05.230, EWI building (13:00-15:00)
• 07.07.2015: Coffeeroom 36-HB 05.230, EWI building (13:00-15:00)

#### GS points

Participation is valued by 1 GS point per 8h active participation (including presentation of seminar topics).

#### Course description

Quantum computing is a big topic since many years getting new impetus every now and then by announcements like

Despite many years of active research, universal quantum computers are not yet available but there is hope that such devices might become available within the next decade. With the joint effort of academia and industry concentrated at QuTech, TU Delft might even be among the first to succeed.

This seminar will not focus on how to build a quantum computer (leaving this topic to specialists in this field) but on the slightly provocative question is quantum computing of any use for numerical analysis. To answer this question one first has to understand the main theoretical principles of quantum computing: quantum superposition and quantum entanglement (see the Quantum Computing Primer for a general overview).

In contrast to classical computer (those based on transistors representing data in binary digits, that is, either '0' or '1'), in quantum computing information is encoded in so-called quantum bits or qubits which represent the linear superposition of the two pure states $$|0\rangle$$ and $$|1\rangle$$ using the Dirac notation also termed Bra-Ket notation. That is, $$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle,\quad \alpha,\beta\in\mathbb{C},\quad|\alpha|^2+|\beta|^2=1,$$ where the two complex numbers $$\alpha$$ and $$\beta$$ are the probability amplitudes. By measuring the qubit state $$|\psi\rangle$$ the outcome is $$|0\rangle$$ and $$|1\rangle$$ with probability $$|\alpha|^2$$ and $$|\beta|^2$$, respectively. Similarly to classical computers which make use of registers and gates (e.g., AND, OR, XOR, NOT, etc.), a number of qubits taken together form a qubit register and it is possible to perform calculations by manipulating the qubits within a register. There are a number of well-known quantum gates such as the Hadamard gate, the Toffoli gate or the phase shift gate. Making use of the Toffoli gate, the logical functions AND, OR, XOR, and NOT can be realized on quantum computers.

A common misunderstanding is that quantum computers will be able to solve all problems of the universe much faster than classical computers can do. This is not true and, even worse, the advent of quantum computers will not solve a single problem without a reasonable algorithm. It is true that quantum superposition makes it possible to carry out an algorithm (e.g., the evaluation of a function) for all input data simultaneously. This special feature is termed quantum parallelism (for a nice illustration follow this link). However, to obtain a definite output the qubit (register) has to be measured, whereby the superposition of states is destroyed. It should be clear that special care has to be taken, to obtain the desired output with a sufficiently high probability rather than just one out of all possible outputs.

For some problems, so-called quantum algorithms are known which solve a particular problem provably faster than any classical super-computer can ever do. Some of the most prominent quantum algorithms are

• Shor's algorithm for integer factorization;
• Grover's algorithm for searching an unordered list;
• Deutsch-Jozsa's algorithm for solving a black-box problem.

However, none of the above algorithms has a direct relation to classical topics of numerical analysis such as numerical integration, differentiation, the solution of differential quations, or linear and nonlinear systems of equations. In this seminar, we will start with a brief introduction to quantum computing for non-physisists and review existing quantum algorithms with direct application in numerical analysis. A preliminary list of topics to be discussed is as follows:

Depending on the interest of participants other topics related to numerical analysis can also be discussed.

#### Schedule of presentations

• Session 1: Liesbeth Florentie presented the content of sections 1-3 from the paper 'Introduction to Quantum Computing for Non-Physicists' [1], 17.02.2015.
• Session 2: Koen Groot presented the content of sections 4-5 from the paper 'Introduction to Quantum Computing for Non-Physicists' [1]. In addition, we applied the new theoretical techniques and solve several practical examples, 03.03.2015.
• Session 3: Seb Harrevelt presented Shor's factorization algorithm based on section 6 from the paper 'Introduction to Quantum Computing for Non-Physicists' [1]. A good introduction to Shor's factorization algorithm is also given in the EdX online course (see Week 6: Lectures 9-10). In addition, Matthias gave a short introduction to the quantum simulator jQuantum, 17.03.2015.
• Session 4: Together we discuss lectures 1-4 from the EdX course 'BerkeleyX CS-101x Quantum Mechanics and Quantum Computation' by Umesh Vazirani and solve the given assignments, 24.03.2015.
• Session 5: Together we discuss lectures 5-6 from the EdX course 'BerkeleyX CS-101x Quantum Mechanics and Quantum Computation' by Umesh Vazirani and solve the given assignments, 31.03.2015.
• Session 6: Together we discuss lectures 7-8 from the EdX course 'BerkeleyX CS-101x Quantum Mechanics and Quantum Computation' by Umesh Vazirani and solve the given assignments, 07.04.2015.
• Session 7: Together we discuss lectures 9-10 from the EdX course 'BerkeleyX CS-101x Quantum Mechanics and Quantum Computation' by Umesh Vazirani and solve the given assignments, 14.04.2015.
• Session 8: Together we discuss lecture 11 from the EdX course 'BerkeleyX CS-101x Quantum Mechanics and Quantum Computation' by Umesh Vazirani and solve the given assignments, 21.04.2015.
• Session 9: Romain Thomas will present the basic ideas of the paper [2] on a quantum algorithm for solving linear systems of equations. Helpful extra information, illustrations, etc. can be found in the papers [3,4,5]. There is also a wikipedia on this subject with additional references, 28.04.2015.
• Session 10: Matthias Möller presented a worked out example on how to solve a 2x2 linear system $$Ax=b$$ using the quantum algorithm by Harrow et al. [2] following the practical implementation by Barz et al. in [4], 19.05.2015.
• Session 11: Thea Vuik presented worked out examples on how to solve a 2x2 linear system $$Ax=b$$ using the quantum algorithm by Harrow et al. [2] following the practical implementation by Cai et al. in [3], 26.05.2015.
• Session 12: Menel Rahrah presented a quantum algorithm for solving linear differential equations based on the publication by Berry [6], 09.06.2015.
• Session 13: Koen Groet presented an overview of numerical algorithms that have been considered on quantum computers based in the publications by Heinrich [7] (and possibly [8] if high-dimensional integration is presented), 30.06.2015.

#### Literature

1. E. Rieffel, and W. Polak. An Introduction to Quantum Computing for Non-Physicists. [arXiv:quant-ph/9809016v2], 19 Jan 2000. Paper is published in: ACM Computing Survey (CSUR), Volume 32, Issue 2, Sept. 2000, Pages 300-335 [Link to ACM Digital Library available at TU Delft]
2. A.W. Harrow, A. Hassidim, S. Lloyd. Quantum algorithm for solving linear systems of equations. [arXiv:0811.3171], 30 Sep 2009. Paper is published in: Phys. Rev. Lett. 103, 150502 (2009) [Link]
3. X.-D. Cai, C. Weedbrook, Z.-E. Su, M.-C. Chen, Mile Gu, M.-J. Zhu, Li Li, Nai-Le Liu, Chao-Yang Lu, and Jian-Wei Pan. Experimental Quantum Computing to Solve Systems of Linear Equations. Phys. Rev. Lett. 110, 230501 (2013) [Link]
4. S. Barz, I. Kassal, M. Ringbauer,Y.O. Lipp,B. Dakić, A. Aspuru-Guzik, and P. Walther. A two-qubit photonic quantum processor and its application to solving systems of linear equations. [arXiv:1302.1210v1], 5 Feb 2013. Paper is published in: Scientific Reports 4, Article number: 6115 [Link].
5. J. Pan, Y. Cao, X. Yao, Z. Li, C. Ju, X. Peng, S. Kais, J. Du. Experimental realization of quantum algorithm for solving linear systems of equations. [arXiv:1302.1946], 8 Feb 2013. Paper is published in: Phys. Rev. A 89, 022313 (2014) [Link]
6. D.W. Berry. High-order quantum algorithm for solving linear differential equations. [arXiv:1010.2745v2 ], 28 Jan 2014. Paper is published in: J. Phys. A: Math. Theor. 47, 105301 (2014) [Link]
7. S. Heinrich. Numerical Analysis on a Quantum Computer. Large-Scale Scientific Computing Lecture Notes in Computer Science Volume 3743, 2006, pp. 28-39. [Link]
8. S. Heinrich. From Monte Carlo to Quantum Computation. [arXiv:quant-ph/0112152 ], 23 Dec 2001. Paper submitted to the Proceedings of the 3rd IMACS Seminar on Monte Carlo Methods MCM2001, Salzburg. 15 pages.

• The online-education platform EdX offers the archieved course 'BerkeleyX CS-101x Quantum Mechanics and Quantum Computation' by Umesh Vazirani. This course gives a very detailed introduction to Quantum Computing. You might want to register for this course and read through the course notes/lecture slides. There are also some helpful assignments which we will consider as part of our assignments.

#### Software

This list of open-source QC software packages will be updated continuously even after the seminar has officially ended.
• jQuantum is a quantum computer simulator written in Java. This program is designed to enable development as well as demonstrations of quantum algorithms.
• Quantum++ is a C++11 general purpose quantum computing library, composed solely of template header files. A description of the library is given in the publication Vlad Gheorghiu. Quantum++ - A C++11 quantum computing library [arXiv:1412.4704], 15 Dec 2014.

### Seminar: Isogeometric Finite Elements

#### Time and place

The seminar will take place every second Tuesday between 13:00 and 15:00. In contrast to previous announcements the first session will be Septemer 9.

• 09.09.2014: HB 05.230, EWI building
• 23.09.2014: LH 00.440 (Feldmannzaal), EWI building
• 07.10.2014: HB 05.230, EWI building
• 21.10.2014: HB 05.230, EWI building
• 04.11.2014: HB 01, Lecture hall Chip, EWI building
• 18.11.2014: HB 05.230, EWI building
• 02.12.2014: HB 05.230, EWI building
• 16.12.2014: HB 05.230, EWI building
• 13.01.2015: HB 05.230, EWI building
• 27.01.2015: HB 05.230, EWI building

Further dates and locations will be announced in time.

#### GS points

Participation is valued by 1 GS point per 8h active participation (including presentation of seminar topics).

#### Course description

Isogeometric Analysis is one of todays hot topics in Applied Mathematics and starts to make its way into industrial applications. This research direction is motivated by the 'gap between the worlds of finite element analysis (FEA) and computer-aided design (CAD)' [1]. Engineering designs are typically constructed with the aid of sophisticated CAD-tools that make use of B-splines or NURBS. In order to perform a numerical FE-analysis the geometry of the CAD-model needs to be transformed into the finite element framework making use of a completely different geometry description. Isogeometric finite elements aim at closing this gap by using a common geometry model for construction and analysis.

This course starts with an introcution to isogeometric analysis based on the textbook [1] (Ch. 1-3) and the introductory chapters 1-4 from [2]. An incomplete list of advanced topics that can be discussed afterwards is as follows:

• adaptive refinement using hierarchical B-splines; Ch. 5 in [2]
• alternative approaches towards adaptive refinement: T-splines [1,3,7], ...
• efficient quadrature rules for NURBS-based IGA [4]
• theoretical analysis of IGA [5,6]
• implementation aspects of IGA
• multigrid methods for IGA
• collocation methods
• applications solved with IGA; Ch. 4-10 in [1]

#### Kick-off meeting

The kick-off meeting for this seminar for PhD-students and interested staff members will be held 12.06.2014 in the Lipkenszaal 36-LB 01.150 at 13:00-14:00.

#### Schedule of presentations

• Presentation given during the kick-off meeting 12.06.2014.
• Introduction to B-splines (sections 2.1.1-2.1.3 from [1] and parts from [8]) by X. Li, lecture notes, 09.09.2014.
• Refinement with B-splines (section 2.1.4 from [1]) by M.J. Vuik, notes,
Introduction to NURBS (section 2.2 from [1] and [10]) by X. Li, 23.09.2014.
• Discussion of practical assignments (Python3 implementation by Joost van Zwieten bsplines.py; Matlab implementation by Thea Vuik Assignments_Thea.zip and by Andrzej Jaeschke Assignments_Andrzej.zip); FE analysis in isogeometric analysis: weak formulation and matrix assembly by J. van Zwieten, 07.10.2014.
• Discussion of matrix assembly and aspects of implementation by J. van Zwieten, compatible isogeometric analysis by Marc Gerritsma (an application of compatible isogeometric analysis is given in this short paper), 21.10.2014; practical assignment by Andrzej Jaeschke Laplace1d_Andrzej.zip
• Discussion of isogeometric analysis on real geometries and techniques to perform the assembly of linear and bilinear forms efficiently by Matthias Möller, 04.11.2014.
• Discussion of discontinuous Galerkin isogeometric finite element methods based on [11], [12] by Thea Vuik, 18.11.2014. Recommended further reading [13].
• Discussion of continuous multi-patch isogeometric finite element methods with and without higher continuity at patch boundaries by Stevie-Ray Janssen, 02.12.2014.
• Discussion of assignments #4 and #5, 16.12.2014.
• Discussion of hierarchical B-Splines and adaptive refinement strategies in isogeometric finite elements by J. van Zwieten, 13.01.2015.

#### Assignments

The assignments strictly make use of the notation conventions introduced in reference [1] unless indicated otherwise.

##### Assignment #1 (09.09.-23.09.2014)
• Write a demo implementation (in Matlab, Python, etc.) which accepts a possibly non-uniform knot vector $$\Xi_1$$ of length $$n_1$$ and a polynomial degree $$p_1$$ and computes and displays the resulting B-spline basis functions $$N_{i,p}(\xi),i=1,2,\dots,n_1$$ as defined in (2.1)-(2.2) in [1]. As an example to verify the correctness of your code you may want to use the knot vectors $$\Xi_1=[0,0,0,1,2,3,4,4,5,5,5]$$ (with $$n_1=8, p_1=2$$) and $$\Xi_1=[0,0,0,0,0,1,2,2,3,3,3,4,4,4,4,5,5,5,5,5]$$ (with $$n_1=15, p_1=4$$) and compare the resulting B-spline basis functions with those given in Figure 2.5 and 2.6 from [1], respectively
• Extend your code to accept a set of control points $$\mathbf{B}_i\in\mathbb{R}^2, i=1,2,\dots,n_1$$ and display the resulting piecewise polynomial B-spline curve defined by expression (2.15), the control points and the mesh as in Figure 2.10 from [1].
• Extend your code to accept two knot vectors $$\Xi_1$$ and $$\Xi_2$$ of length $$n_1$$ and $$n_2$$ respectively, two polynomial degrees $$p_1$$ and $$p_2$$ and a set of control points $$\mathbf{B}_{i,j}\in\mathbb{R}^2,i=1,2,\dots,n_1,j=1,2,\dots,n_2$$. The code should compute and display the B-spline surface that is defined by equation (2.17) from [1]. A viable test case is defined in Table 2.1 and displayed in Figure 2.15 in the same reference.
##### Assignment #2 (23.09.-07.10.2014)
• Extend your one-dimensional code from the first assignment to enable knot insertion as discussed in the seminar session. A good description of the insertion of single knots can be found in Section 2.4 from [10]. It is somewhat easier to implement than the more general algorithm given in Section 2.1.4.1 from [1], that allows to insert more than one knot at a time. Test your implementation for the example given in Figure 2.19 from [1]. That is, $$\Xi=[0,0,0,1,1,1]$$, $$p=2$$ and a single new knot is inserted at position $$\xi=0.5$$.
• Extend your one-dimensional code to enable degree elevation as discussed in the seminar session. Test your implementation for the example given in Figure 2.21 from [1]. That is, $$\Xi=[0,0,0,1,1,1]$$, $$p=2$$ and the new degree is $$p=3$$.
##### Assignment #3 (07.10.-21.10.2014)
• Use your implementation of one-dimensional B-spline basis functions to implement a Galerkin isogeometric finite element method for the Poisson problem \begin{aligned} -\frac{\partial^2u}{\partial x^2} & = f(x) &&\quad \text{in }\Omega=(0,1),\\ u(0) & = 0 &&\quad \text{at }\Gamma_D=\{x=0\},\\ \partial_nu(1) & = 0 &&\quad \text{at } \Gamma_N=\{x=1\}, \end{aligned} whereby the load vector is given by $$f(x)=6(x+1)$$. It is easy to see that $$u_{ex}(x)=-x^3-3x^2+9x$$ is the exact solution that satisfies both the PDE and the Dirichlet and Neumann boundary conditions, respectively.
Write a function (in Matlab, Python, etc.) that accepts a given knot vector $$\Xi$$ of length $$n$$ and a polynomial degree $$p$$ and solves the above Poisson problem on the unit interval. Note that it is not necessary to consider control points in this assignment. Closely follow the numerical solution approach outlined in Section 3.3.1 from [1]. Since both the Dirichlet and the Neumann boundary conditions are homogeneous, neither the Dirichlet lift $$\left. u\right|_{\Gamma_D}=g=0$$ nor the boundary integral term resulting from integration by parts $$\int_{\Gamma_N}wh\, d\Gamma,\quad \text{with }h=0$$ has to be taken into account explicitly.
• Use your implementation to compute the approximate solution $$u^h$$ for different values of $$p=1,2,3,4$$ and different knot vectors $$\Xi$$ and compare it to the exact solution $$u_{ex}$$ in the $$L_1$$- and $$L_2$$-norm \begin{aligned} \|u_{ex}-u^h\|_1&:=\int_0^1\left|u_{ex}(x)-u^h(x)\right|\,dx,\\ \|u_{ex}-u^h\|_2&:=\left(\int_0^1\left(u_{ex}(x)-u^h(x)\right)^2\,dx\right)^{1/2}. \end{aligned}
##### Assignment #4 (21.10.-04.11.2014):
• Use your implementation of two-dimensional B-spline basis functions (from assignment #1) to implement a Galerkin isogeometric finite element method for the Poisson problem with homogeneous Dirichlet boundary conditions \begin{aligned} -\Delta u(x,y) & = f(x,y) &&\quad \text{in }\Omega_0=(0,1)\times(0,1),\\ u(x,y) & = 0 &&\quad \text{on } \partial\Omega_0, \end{aligned} whereby the load vector is given by $$f(x,y)=2\pi^2\sin(\pi x)\sin(\pi y).$$ It is easy to see that $$u_{ex}(x,y)=\sin(\pi x)\sin(\pi y)$$ is the exact solution that satisfies both the PDE and the homogeneous Dirichlet boundary conditions. In contrast to assignment #3, the exact solution is not a polynomial, and therefore, no approximation with higher-degree B-spline basis is expected to reproduce it exactly.
Write a function (in Matlab, Python, etc.) that accepts two knot vectors $$\Xi_1$$ and $$\Xi_2$$ of length $$n_1$$ and $$n_2$$, respectively, and two polynomial degrees $$p_1$$ and $$p_2$$ and solves the above Poisson problem on the unit square $$\Omega_0=(0,1)\times(0,1)$$.
Try to find a good strategy to assemble the linear and bilinear forms efficiently, e.g., by exploiting the fact the the region of overlapping supports of any pair of basis functions is known a priori since univariate B-splines have local supports $$\text{supp}(B_{i,p}(\xi))=[\xi_i,\xi_{i+p+1}).$$ Note that it is not necessary to consider control points in this assignment since the geometry is the unit square and the 'grid' is a simple tensor product.
• Use your implementation to compute the approximate solution $$u^h$$ for different values of $$(p_1,p_2)\in\{1,2,3\}$$ and different pairs of knot vectors $$(\Xi_1,\Xi_2)$$. Compare the approximate solutions $$u^h(x,y)$$ to the exact one $$u_{ex}$$ in the $$L_1$$- and $$L_2$$-norm \begin{aligned} \|u_{ex}-u^h\|_1&:=\int_0^1\int_0^1\left|u_{ex}(x,y)-u^h(x,y)\right|\,dx\, dy,\\ \|u_{ex}-u^h\|_2&:=\left(\int_0^1\int_0^1\left(u_{ex}(x,y)-u^h(x,y)\right)^2\,dx\, dy\right)^{1/2}. \end{aligned}
##### Assignment #5 (04.11.-02.12.2014):
• Use your implementation of assignment #4 and extend it to solve the two-dimensional Poisson problem with homogeneous Dirichlet boundary conditions \begin{aligned} -\Delta u(x,y) & = f(x,y) &&\quad \text{in }\Omega,\\ u(x,y) & = 0 &&\quad \text{on } \partial\Omega \end{aligned} on the physical domain shown in Figure 2.15 from [1]. The domain is defined by the biquadratic B-spline-based geometric mapping $$\mathbf{S}(\xi,\eta)=\sum_{i=1}^4\sum_{j=1}^3N_{i,2}(\xi)M_{j,2}(\eta)\mathbf{B}_{ij}.$$ The degrees of the B-spline functions are $$p_1=p_2=2$$, the two knot vectors read \begin{aligned} \Xi_1&=[0,0,0,0.5,1,1,1]\\ \Xi_2&=[0,0,0,1,1,1] \end{aligned} and the control points are as follows:  $$i$$ 1 1 1 2 2 2 3 3 3 4 4 4 $$j$$ 1 2 3 1 2 3 1 2 3 1 2 3 $$\mathbf{B}_{ij}$$ (0,0) (-1,0) (-2,0) (0,1) (-1,20) (-2,2) (1,1.5) (1,4) (1,5) (3,1.5) (3,4) (3,5)
For practical reasons, the load vectors $$f(x,y)$$ is defined directly in the parameter domain $$\Omega_0=(0,1)\times(0,1)$$ rather than in the physical space $$\Omega$$. That is $$f(\xi,\eta)=2\pi^2\sin(\pi \xi)\sin(\pi \eta).$$ This is to ensure that the solution attains the homogeneous Dirichlet boundary conditions along the entire boundary. You may want to use the assembly technique discussed in the lecture.
• Use your implementation to compute the approximate solution $$h^h$$ and visualize it both in the parameter domain $$\Omega_0$$ and (if possible) in the physical domain $$\Omega$$.

#### Literature

1. J.A. Cottrell, T.J.R. Hughes, and Y. Bazilevs. Isogeometric Analysis: Toward Integration of CAD and FEA. John Wiley & Sons, Ltd., 2009. [Link to version at TUDelft Library]
2. A.-V. Vuong. Adaptive Hierarchical Isogeometric Finite Element Methods. PhD thesis, TU München, 2011. [Link to version at TUDelft Library]
3. M. Dörfel, B. Jüttler, and S. Simeon. Adaptive isogeometric analysis by local h-refinement with T-splines. Comput. Methods Appl. Mech. Engrg., 199(5–8):264–275, 2010. [Link to version at TUDelft Library]
4. T.J.R. Hughes, A. Reali, and G. Sangalli. Efficient quadrature for nurbs-based isogeometric analysis. Computer Methods in Applied Mechanics and Engineering, 199(58):301-313, 2010. Computational Geometry and Analysis. [Link to version at TUDelft Library]
5. Y. Bazilevs, L. Beirao da Veiga, J. A. Cottrell, T. J. R. Hughes, and G. Sangalli. Isogeometric analysis: Approximation, stability and error estimations for h-refined meshes. Mathematical Models and Methods in Applied Sciences, 16(07):1031–1090, 2006. [Link to version at Publisher]
6. L. Beirao da Veiga, A. Buffa, J. Rivas, and G. Sangalli. Some estimates for h-p-k-refinement in isogeometric analysis. Numer. Math., 118:271–305, 2011. [Link to version at Publisher]
7. Y. Bazilevs, V.M. Calo, J.A. Cottrell, J.A Evans, T.J.R. Hughes, S. Lipton, M.A. Scott, and T.W. Sederberg. Isogeometric analysis using T-splines. Computer Methods in Applied Mechanics and Engineering, 199(5-8):229-263, 2010. [Link to version at TUDelft Library]
8. C. de Boor. A practical guide to splines. Springer, 2001. [Link to version at TUDelft Library]
9. V.P. Nguyen, St.P.A. Bordas, T.Rabczuk. Isogeometric analysis: an overview and computer implementation aspects [Link to http://arxiv.org/abs/1205.2129]
10. T.J.R. Hughes, J.A. Cottrell, Y. Bazilevs. Isogeometric analysis: CAD, finite elements, NURBS, exact geometry and mesh refinement. Comput. Methods Appl. Mech. Engrg. 194:4135–4195, 2005. [Link to version at TUDelft Library]
11. F. Brunero. Discontinuous Galerkin methods for isogeometric analysis. Mastersthesis, Universita degli Studi di Milano, 2012. [Link to electronic version]
12. U. Langer, A. Mantzaflaris, S.E. Moore, I. Toulopoulos. Multipatch Discontinuous Galerkin Isogeometric Analysis. arXiv:1411.2478 [math.NA].
13. U. Langer, S.E. Moore. Discontinuous Galerkin Isogeometric Analysis of Elliptic PDEs on Surfaces. arXiv:1402.1185 [math.NA].

#### IGA software

This list of open-source IGA software packages will be updated continuously even after the seminar has officially ended.

### WI1403LR: Linear Algebra

#### Supplementary material for group E14

Disclaimer: These slides do not represent the complete content of the lectures. During the lectures, extra material such as examples and proofs is written to the blackboard which cannot be found in the slides. It is therefore highly recommended to attend the lectures.

### WI3097TU/Minor: Numerical Methods for Differential Equations

#### Course description

This introductory course on numerical methods mathematics mainly deals with numerical methods for the approximate solution of differential equations which are typically used to model real-world phenomena (e.g., the time-dependent expansion of heat in a metal beam or the deformation of a membrane under constant load). The following topics are discussed:

• Floating point numbers/arithmetic and rounding errors;
• Numerical differentiation (divided finite differences);
• Single-step time stepping methods for linear and non-linear scalar problems and systems of equations (explicit/implicit, (numerical) stability, convergence, global/local errors, amplification of errors, test equation/system);
• Runge-Kutta methods (including theoretical analysis);
• Interpolation/extrapolation (Lagrange interpolation, Spline interpolation);
• Numerical methods for boundary value problems in 1D (boundary conditions, stabilization of convective terms);
• Iterative solution of non-linear problems (fixed point iteration, Newton-Raphson method).

The course contains both theoretical exercises as well as practical programming sessions during which some of the presented algorithms shall be implemented in Matlab.

#### Literature

• J. van Kan, G. Segal, and F. Vermolen, Numerical Methods in Scientific Computing. Delft Academic Press / VSSD, second edition, 2014.

To be announced

#### Literature

• J. van Kan, G. Segal, and F. Vermolen, Numerical Methods in Scientific Computing. Delft Academic Press / VSSD, second edition, 2014.

#### Literature

• C. Vuik, P. van Beek, F. Vermolen, J. van Kan, Numerical Methods for Ordinary Differential Equations. VSSD, first edition, 2007.
• C. Vuik, P. van Beek, F. Vermolen, J. van Kan, Numerieke Methoden voor Differentiaalvergelijkingen. VSSD, eerste editie, 2007.

#### Literature

• C. Vuik, P. van Beek, F. Vermolen, J. van Kan, Numerical Methods for Ordinary Differential Equations. VSSD, first edition, 2007.
• C. Vuik, P. van Beek, F. Vermolen, J. van Kan, Numerieke Methoden voor Differentiaalvergelijkingen. VSSD, eerste editie, 2007.

### WI4014TU: Numerical Analysis

#### Course description

This advanced numerical analysis course starts with a brief review of the theory of partial differential equations including their characterisation (elliptic, parabolic, hyperbolic) and the different types of boundary conditions. Next, we discuss finite difference methods (FDM) for their numerical solution in multiple space dimensions and continue with an introduction to the finite volume methods (FVM). For both approaches, we address the extension to curved boundaries. The main part of the lecture focusses on the finite element method (FEM). We start with a rigorous derivation of Ritz's method by relating classes of PDE problems (with symmetric positive definite linear differential operators) to equivalent minimisation problems which is solved numerically. Next, we discuss the extension to non-symmetric problems which leads to the concept of weak formulations, weak solutions and the Galerkin weighted residual method. We discuss aspects of boundary treatment, different types of finite elements (linear and higher-order finite elements in 1D and finite elements in 2D on triangles and quadrilaterals), numerical quadrature rules. We will address theoretical aspects as well as the implementation of the finite element method.

#### Literature

• C. Vuik, F.J. Vermolen, M.B. van Gijzen, M.J. Vuik, Numerical Methods for Ordinary Differential Equations. Delft Academic Press/VSSD, second edition, 2015.

To be announced

#### Literature

• C. Vuik, F.J. Vermolen, M.B. van Gijzen, M.J. Vuik, Numerical Methods for Ordinary Differential Equations. Delft Academic Press/VSSD, second edition, 2015.

#### Literature

• C. Vuik, P. van Beek, F. Vermolen, J. van Kan, Numerical Methods for Ordinary Differential Equations. VSSD, first edition, 2007.
• C. Vuik, P. van Beek, F. Vermolen, J. van Kan, Numerieke Methoden voor Differentiaalvergelijkingen. VSSD, eerste editie, 2007.

### WI4265TU: Parallel Programming

#### Course description

A practical introduction to parallel programming. The course explains the basic concepts of programming for parallel computers and focuses on three parallel programming models: the message passing model with MPI; the shared memory model with OpenMP; and the shared memory model with threads. All topics taught during the course will be applied in hands-on exercises.

The students will be able to design and implement parallel algorithms using a programming model that provides the best match with the algorithm. They will be able assess the performance of the implementation and solve all kinds of practical problems that will pop up during the implementation of the algorithm.

The course mixes theory with practical, hands-on exercises. These exercises enable the students to apply their newly learned knowledge in smaller and larger contexts, and thus provide an opportunity to really understand different aspects related to parallel programming. Some of the exercises involve implementing the same algorithm with different programming models so that the differences between those models become more apparent.

### WI4450TU: Special Topics in Computational Science and Engineering

#### Course description

The course discusses the state-of-the-art of a selected topic from computational science and engineering. This topic changes yearly.The first part of the course consists of self study, complemented by question and answer sessions. The second part of the course consists of lectures by specialists.

##### Q3-Q4 2016/17

The topic of the course is numerical linear algebra techniques for image reconstruction. During the course the image reconstruction problem is formulated for a number of applications (CT, MRI, radio astronomy, ...) and standard image reconstruction techniques are explained. Then a number of advanced linear algebra algorithms are discussed. As a project, a suitable image reconstruction algorithm is selected, implemented and evaluated to reconstruct an image from real data.

##### Q3-Q4 2015/16

The topic of the course is iso-geometric analysis, which is an advanced discretisation technique for practical engineering problems that combines ideas from the finite element method with concepts from computational geometry.

### WI4771TU: Object Oriented Scientific Programming with C++

#### Course description

This course is not a typical C++ programming course that aims at discussing all aspects of the programming language at length, including legacy techniques that lead to hardly-readable codes. It is about object-oriented design concepts and practical aspects of mod-ern scientific programming thereby using C++ as a vehicle only.

This course follows a pragmatic problem-oriented approach. Starting from a concrete problem description like 'How to design and develop an efficient linear solver for Ax=b?', only those aspects of the programming language will be introduced and discussed that are really needed to master the problem at hand or make its implementation much more flexible and efficient. We explicitly focus on the recent language standard C++11, which introduced several very powerful and easy to use concepts for modern scientific pro-gramming and overcomes many of the drawbacks and pitfalls of previous standards.

The second aim of this course is to demonstrate a possible workflow for efficient code development using established tools for editing, refactoring, compiling, debugging, and profiling the code. Scientific codes for practical use are quickly becoming too complex to edit them in a standard text editor, compile the source code 'by hand' manually figuring out the inter-file dependencies and identify bugs and efficiency bottlenecks just from visual inspection. We will introduce and utilise several software tools like CodeLite and CMake (possibly also Valgrind if time permits) that simplify these tasks.

#### Literature

• B. Stroustrup, A Tour of C++. Addison-Wesley, 2014.

#### Literature

• B. Stroustrup, A Tour of C++. Addison-Wesley, 2014.

## Courses at TU Dortmund (2009-2013)

### Computerorientiertes Problemlöses (Kompaktkurs)

#### Inhalt

Diese Veranstaltung stellt Softwarewerkzeuge zum Lösen von mathematischen Problemen vor und geht dabei insbesondere auf die Programmierumgebung MATLAB sowie deren OpenSource Klone GNU Octave ein. Grundlegende Programmierkonzepte (Umgang mit Variablen, Vektoren, Matrizen; Steuerung des Programmflusses durch bedingte Verzweigungen und Schleifen; grafische Aufbereitung von Ergebnissen) werden in der Vorlesung vorgestellt und sollen in den Übungen praktisch umgesetzt werden.

### Finite Elements for flow problems

#### Course description

This course will focus on finite element methods (FEM) for the numerical solution of flow problems. It is intended for practitioners who are interested in either understanding and using a commercial software or writing a simulation program themselves.

We start with a brief introduction of the finite element method (FEM) and apply it to steady convection-diffusion problems. An analysis of accuracy and stability in 1D will reveal the deficiencies of the standard Galerkin FEM being applied to convection-dominated problems. Classical stabilization techniques (streamline upwinding, streamline diffusion, Galerkin least-squares) will be presented which are designed to produce stable and accurate results to convective transport problems. The treatment of time-dependent problems will be addressed and the design of high-order accurate time-stepping schemes (Lax-Wendroff and Taylor-Galerkin method) will be discussed. Finally, an introduction to modern high-resolution schemes (TVD, flux correction) will be given.

Emphasis will be laid on practical aspects. Therefore, some numerical techniques shall be implemented as exercise.

### Hyperbolische Erhaltungsgleichungen

#### Inhalt

Auf den ersten Blick haben Tsunamis, Überschallflugzeuge und der Verkehrsfluss auf unseren Straßen nicht viel gemeinsam. Bei allen drei Beispielen spielen jedoch wellenartige Transportprozesse eine entscheidende Rolle. Häufig lassen sich diese mathematisch durch (nichtlineare) partielle Differentialgleichungen erster Ordnung für ein oder mehrere physikalische Erhaltungsgrößen (Masse, Impuls, Energie) beschreiben.

In der Vorlesung werden zunächst wichtige Grundlagen aus der Theorie hyperbolischer Erhaltungsgleichungen eingeführt (skalare Erhaltungsgleichungen, lineare und nichtlineare Systeme). Eine grundsätzliche Schwierigkeit bei der Lösung hyperbolischer Erhaltungsgleichungen ergibt sich daraus, dass selbst bei glatten Anfangswerten im Laufe der Zeit Unstetigkeiten entstehen können. Dies erfordert neben einem erweiterten Lösungsbegriff (schwache Lösungen) spezielle numerische Verfahren, die mit unstetigen Lösungen zurecht kommen und diese “sauber” reproduzieren können. In der Vorlesung wird dazu die Klasse der Finite Volumen Verfahren vorgestellt. Neben den “klassischen” Verfahren werden auch sog. hochauflösende Verfahren untersucht, die eine genauere Auflösung der Unstetigkeiten ermöglichen.

Um ein “Gespür” für die in der Vorlesung vorgestellten Verfahren zu gewinnen, sollen diese für einfache Testprobleme implementiert und untersucht werden. Dazu wird es in den Übungen praktische Aufgaben geben, die z.B. in Matlab umgesetzt werden können.

#### Literatur

• R.J. LeVeque, Numerical Methods for Conservation Laws, Birkhäuser, 1990.
• R.J. LeVeque, Finite Volume Methods for Hyperbolic Problems, Cambridge University Press, 2002.

### Introduction to Computational Fluid Dynamics

#### Course description

This introductory course deals with mathematical modeling and numerical simulation of various flow phenomena which play an important role in everyday life and are subject to extensive research in both academia and industry. The flow models to be considered give rise to partial differential equations which express the conservation of mass, momentum and energy. Their derivation, mathematical behavior, and the choice of boundary conditions will be presented before proceeding to the numerical solution tools, the main topic of this course. An introduction to classical finite difference, finite volume, and finite element methods will be given and the properties of the resulting schemes will be analysed in detail. The limitations of standard discretization techniques will be exposed and a number of state-of-the-art numerical algorithms(stabilized and high-resolution schemes for convection-dominated flows, nonlinear iteration schemes, projection / Schur Complement methods for the incompressible Navier-Stokes equations, operator-splitting tools and iterative solution of strongly coupled PDE systems) will be introduced to give a flavor of modern CFD tools available for a numerical investigation of complex applications.

#### Literature

• J. Donea and A. Huerta, Finite Element Methods for Flow Problems. John Wiley & Sons, 2003.
• J.H. Ferziger and M. Peric, Computational Methods for Fluid Dynamics. Springer, 1996.
• C. Hirsch, Numerical Computation of Internal and External Flows, Vol. I and II. John Wiley & Sons, 1990.
• D. Kuzmin, Free CFD book: A Guide to Numerical Methods for Transport Equations, University Erlangen-Nuremberg, 2010.
• R. Löhner, Applied CFD Techniques: An Introduction based on Finite Element Methods. John Wiley & Sons, 2008.
• P. Wesseling, Principles of Computational Fluid Dynamics. Springer, 2001.

### Mathematical and practical aspects of finite elements

#### Course description

This course is concerned with the finite element method (FEM) which is a computational technique for obtaining approximate solutions to partial differential equations arising in scientific and engineering applications. It is intended for practitioners who are interested in either understanding and using a commercial simulation software or writing a finite element code themselves. We start with a brief introduction of the underlying variational principle and discuss some theoretical results for finite elements. The main part of this lecture deals with mathematical aspects such as the choice of basis functions, numerical evaluation of integrals, assembly of the system matrix, and the numerical solution of linear systems. We will also address computational aspects such as matrix storage techniques and efficient data structures required for the practical implementation of the FEM. The generation of computational grids with good quality is a prerequisite for the success of numerical simulations. We will therefore discuss common mesh generation algorithms (Delaunay triangulation, advancing front) and techniques to improve the quality of the grid. In practice, the optimal grid is typically not known a priori so that the process of computing the numerical solution on a given mesh and adapting the grid accordingly needs to be repeated several times. Beside this so-called a posteriori mesh adaptation we will also consider the visualization of scientific data.

#### Literature

• J. E. Flaherty, Course Notes: Finite Element Analysis, http://www.cs.rpi.edu/~flaherje
• R. Löhner, Applied CFD Techniques. An Introduction based on Finite Element Methods, John Wiley & Sons 2008
• P. Solin, Partial Differential Equations and the Finite Element Method, John Wiley & Sons 2008

### Teil 1

#### Inhalt

Tsunami-Frühwarnsysteme, der tägliche Wetterbericht, die Entwicklung kraftstoffsparender Autos oder die Konstruktion lüfterloser Tablets; alle diese Disziplinen setzen voraus, dass unterschiedlichste Strömungsprobleme mittels numerischer Simulationen im Computer berechnet werden können. Diese Vorlesung führt in diesen allgemein als Computational Fluid Dynamics (CFD) bezeichneten Zweig der Numerik ein.

Zu Beginn geht es um die Modellierung von Strömungsproblemen mit Hilfe von partiellen Differentialgleichungen (Grundgleichungen der Strömungsmechanik; Eulersche/Lagrangesche Betrachtungsweise; differentielle/integrale Form von Erhaltungsgleichungen). Um eine Lösung dieser Gleichungen mit Hilfe von Computern “berechnen“ zu können, müssen sowohl Zeit- als auch Ortsableitungen diskretisiert werden, d.h. das “Problem“ wird durch eine endliche Anzahl an Unbekannten dargestellt die durch ein lineares oder nichtlineares Gleichungssystem miteinander gekoppelt sind. In der Vorlesung wird hierzu die Methode der Finiten Elemente vorgestellt sowie verschiedene Zeitschrittverfahren analysiert. Nach einer kurzen Einführung der mathematischen Grundlagen werden die wichtigsten Komponenten eines FEM-Strömungslöser betrachtet (Assemblierung von Matrizen/Vektoren; Implementierung von Randbedingungen; Defektkorrektur/Newton-Verfahren). Ferner werden gängige Stabilisierungstechniken diskutiert, die bei der numerischen Simulation von Transportproblemen mit dominierendem konvektiven Anteil (z.B. Wolkenbewegung bei starkem Wind) eine wichtige Rolle spielen (SUPG, edge-oriented stabilization; TVD/FCT; spezielle “stabilisierende“ Zeitschrittverfahren).

Zu der Vorlesung werden theoretische und praktische Übungsaufgaben ausgegeben, die alleine bzw. in kleinen Teams bearbeitet werden können. In den praktischen Aufgaben soll schrittweise ein eindimensionaler Finite-Elemente-Code programmiert werden.

### Teil 2

#### Inhalt

In dieser Vorlesung werden die im ersten Teil dieser Veranstaltung (011238) vorgestellten Orts- und Zeitdiskretisierungsverfahren (insbesondere die Finite-Elemente-Methode) auf komplexere Strömungsprobleme erweitert. Einen Schwerpunkt bildet dabei die numerische Behandlung von nichtlinearen Transportproblemen, bei denen selbst aus glatten Anfangswerten im Laufe der Zeit Unstetigkeiten (z.B. Schockwellen) entstehen können. Dies erfordert neben einem erweiterten Lösungsbegriff (schwache Lösungen) spezielle numerische Verfahren, die mit unstetigen Lösungen zurecht kommen und diese “sauber“ reproduzieren können. Ferner werden wir uns mit der Erweiterung der Finite-Elemente-Methode auf Systeme befassen. Neben der FEM Formulierung werden hier unterschiedliche Lösertechniken zur ge- bzw. entkoppelten Behandlung der Nichtlinearitäten diskutiert. Im letzten Teil der Vorlesung sollen anhand ausgewählter Beispiele weitere Komponenten von CFD-Simulationssoftware angesprochen werden (z.B. Erzeugung spezieller Rechengitter, Fehlerkontrolle und Gitteranpassung).

Zu der Vorlesung werden theoretische und praktische Übungsaufgaben ausgegeben, die alleine bzw. in kleinen Teams bearbeitet werden können.

### Oberseminar Numerische Simulation / IANUS

#### Inhalt

Behandelt werden Themen aus den Arbeitsgebieten “Numerik für PDEs”, “High Performance Computing” und “Wissenschaftliches Rechnen”. Diese Veranstaltung richtet sich an Diplomanden, Doktoranden, PostDocs und weitere Interessierte in diesen Fachgebieten.

IANUS ist die (un)regelmäßig stattfindende interdisziplinäre Vortragsreihe zu obigen Themen, die sich auch an Nicht-Numeriker und Nicht-Dortmunder wendet. Die Vorträge werden gesondert angekündigt.

#### Zeit und Ort

Donnerstag 16-18 Uhr in Raum M/1011

### Schülerzirkel: Eine kurze Einführung in Interpolation und Approximation mit Polynomen

Die Fakultät für Mathematik der Technischen Universität Dortmund veranstaltet zweimal jährlich (Frühjahr und Herbst) einen Schülerzirkel. Hier soll begabten und an Mathematik interessierten Schülerinnen und Schülern der Oberstufe die Möglichkeit geboten werden, erste Einblicke in die Hochschulmathematik zu erhalten, wobei eine aktive Mitwirkung der Teilnehmerinnen und Teilnehmer erwünscht ist.

Ein Thema des Schülerzirkels im Frühjahr 2012 beschäftigt sich mit der Frage:

Warum Postboten keine guten Rennfahrer sind - Eine kurze Einführung in Interpolation und Approximation mit Polynomen

Dazu gibt ein kleines Skript, welches den Inhalt der Vorlesungen - Dienstag, 13.03., Mittwoch, 14.03., und Donnerstag, 15.03.2012 - zusammenfasst.

### Seminar Numerische Simulation

#### Inhalt

Behandelt werden Themen aus den Arbeitsgebieten “Numerik für PDEs” und “Wissenschaftliches Rechnen”. Entsprechende Kenntnisse (d. h. mindestens die Vorlesungen Numerik I bzw. II) sind Voraussetzung.

#### Zeit und Ort

Donnerstag 14-16 Uhr in Raum M/1011

### Studienprojekt: Modellbildung und Simulation 2012

#### Inhalt

Das Studienprojekt Modellbildung und Simulation ist eine einjährige Veranstaltung für Technomathematiker, die sowohl aus einer Proseminar- und Seminarphase wie auch begleitenden Vorlesungen und Softwarepraktika besteht. In gemeinsamer Arbeit soll an einem projektspezifischen Numerics Lab gearbeitet werden. Die Veranstaltung vertieft Kenntnisse über Numerische Lösungsverfahren zu mathematischen Modellen der Ingenieurwissenschaften und bearbeitet praxisnahe Themenstellungen. Die im Modul “Einführung in die numerische Mathematik“ erworbenen Kenntnisse werden erweitert.

Die mathematischen Grundkenntnisse, die zur Arbeit an dem projektspezifischen Numerics Lab erforderlich sind, werden in der Vorlesung Numerische Methoden in der Strömungsmechanik vermittelt, welche für die Teilnehmer am Studienprojekt 2012 verpflichtend ist.

### Unstetige Galerkin Verfahren

#### Inhalt

Discontinuous Galerkin Verfahren zeichnen sich durch ihre große Flexibilität aus. Mit ihnen ist es sowohl möglich, in Bereichen mit glatten Lösungsprofile eine sehr hohe Approximationsgenauigkeit zu erzielen als auch Unstetigkeiten (wie z.B. Schockwellen) zufriedenstellend wiederzugeben. Diese Flexibilität erreichen DG-Verfahren dadurch, dass sie im Gegensatz zu kontinuierlichen Finite-Elemente-Methoden jegliche Stetigkeitsanforderungen über Elementgrenzen hinweg aufgeben. Dadurch wird es beispielsweise möglich, die Approximationsordnung in einem Element lokal zu erhöhen, ohne benachbarte Elemente berücksichtigen zu müssen.

Die Vorlesung gibt eine Einführung in Discontinuous Galerkin Verfahren und behandelt dabei sowohl die mathematischen Grundlagen (Herleitung der DG-Verfahren, numerische Eigenschaften wie Konsistenz sowie Erhaltungseigenschaften) als auch ihre praktische Implementierung in der C++ Finite Elemente Bibliothek deal.II. Daher werden bei allen Teilnehmern grundlegende C++ Kenntnisse vorausgesetzt, die ggf. noch vor Vorlesungsbeginn im (Programmierkurs C++) erworben werden können.