Computational Methods – WiSe 2025/2026

Computational Methods – WiSe 2025/2026#

Introduction#

Welcome! In this module you will learn a wide set of methods in the domain of computational engineering which will aid you in establishing practical skills in your engineering career.

This course bridges many topics which are traditionally taught separately in order to establish a cohesive framework which connects everything else that you have learned and/or will learn throughout the course of your graduate studies back to a practical framework that you are comfortable with using. The focus of this course is on what is inherently computational (and just as importantly what isn’t computational!), with theoretical depth limited to what is useful for practicing engineers to know in their everyday work. At the end of each unit further literature is suggested for more in-depth study. This course is intentionally structured in a such a way that concepts introduced are always given with code that can be played with, this is essential for learning these skillsets and establishing a practical working knowledge of all the methods introduced here. While the context and examples are focussed on space engineering, these methods are, of course, used in a wide variety of engineering disciplines.

Below you’ll find links to each unit’s notebook. Each unit is meant to be studied in a single week.

Syllabus#

Unit #	Title & key sub-topics
1	Model classification I – building blocks • Model classification and structure: • linear vs. non-linear • coupled vs. uncoupled • symmetry • static vs. dynamic
2	Model classification II – degrees of freedom • DOF analysis & constraints • Determined vs. under-/over-determined problems • Conservation rules & force balances
3	Model classification III – non-linearity & chaos • Fixed-, limit-cycle- & chaotic responses (logistic map, Feigenbaum) • Continuum mechanics as “infinite DOF” ⇒ discretisation need
4	Simulation I – algebraic systems • Linear solves (`scipy.linalg.solve`), conditioning & scaling • Non-linear solves (`fsolve`), Jacobians (`sympy`), Hessians & Newton
5	Simulation II – ODE / DAE systems • Explicit vs. implicit, stiffness, `solve_ivp` • Index-1 differential-algebraic equations
6	Simulation III – continuum / PDE intro • Method-of-lines; 1-D heat eqn • Coupled PDE systems
7	Optimization I – convex & linear • LP / QP (`scipy.optimize.linprog`) • Linear least-squares • Gradient-descent methods
8	Optimization II – non-linear programming • KKT, trust-region & SQP (`minimize`) • Non-linear least-squares, back-prop, SGD
9	Optimization III – global / derivative-free • Derivative-free & black-box methods • Bayesian optimisation, integer & discontinuous variables
10	Control I – classical feedback • Loop anatomy, stability margins • P/PI/PD/PID tuning (root-locus & frequency domain)
11	Control II – state-space & optimal linear • LTI form, controllability / observability • LQR, discrete Riccati, Kalman filter, LQG
12	Control III – model predictive & non-linear control • Linear & nonlinear MPC, warm-start • Successive linearisation, constraint handling • Intro to SINDy / DMDc for data-driven MPC
13	Control IV – reinforcement-learning foundations • MDPs, value & policy functions • Tabular & deep Q-learning, actor-critic • Safety envelopes & reward shaping
14	RL-based orbit station-keeping • Problem statement & environment definition • Agent training, evaluation, fuel trade-off • Frontiers: hierarchical RL, onboard edge compute

Prerequisites#

Students for this course are expected to have a foundation undergraduate engineering topics especially in calculus, linear algebra, differential equations and dynamics. While a background in more senior topics such as control, fluid mechanics and machine learning is beneficial, they are not essential since these topics are re-introduced and therefore self-contained for the purposes of completing this course. However, since only the computational aspects of these topics are covered, it is highly recommended for students to pursue external sources for a more in depth education on these topics. Basic python programming skills are an essential prequisite.

Course information#

Instructor contact information:

Stefan Endres (s.endres@iwt.uni-bremen.de) Lutz Mädler (lmaedler@iwt.uni-bremen.de)

Grading policy#

The final grade for this course is based on an oral exam at the end of the semester where you will present a project of your choice that applies the methods learned in this course. The project has to be done individually and present a unique solution. The oral exam will assess your understanding of the computational methods covered in the course and your ability to apply them to solve engineering problems.

AI policy#

It is allowed and encouraged to use LLMs for code generation and report generation as long as you fully understand everything you use (you are only assessed for your knowledge and ability to use computation methods to solve engineering problems, coding skills are not assessed although some skill is needed to connect all your solutions to solve problems in the final project). Only your presentation, quality of solutions and understanding will be assessed in the final exam.

Help with setting up your system, python environments and running these notebooks offline.#

Running the notebooks#

You can run the notebooks in two ways: (1) Binder (fully online, no install needed) or (2) local install with full control.

1. Launch instantly on Binder 🚀#

Click the “Launch Binder” badge at the top-right of any page (or the button below).
Binder will build a temporary Jupyter-Lab session in the cloud; nothing to install on your computer.

Note: The build takes a couple of minutes, a read-only preview appears first.
Leave the tab open: your interactive session will load automatically when ready.

2. Run locally on your system with conda#

macOS / Linux (Terminal) and Windows (PowerShell)#

Clone the repository and set up a local conda environment (once-off):

 git clone https://github.com/Leibniz-IWT/comp_eng.git
 cd comp_eng
 conda env create -f environment.yml     # creates “compeng”
 conda activate compeng

You can now start either jupyter lab or classic notebook, then every time you work on this course just reactive the virtual environment first:

Daily work flow (every time you start a new terminal session):

# First navigate to the project folder where you cloned the repository using `cd path/to/comp_eng`
git pull  # (in the base directory where you saved the project)
conda activate compeng  # Reactive the environment
jupyter lab          # or: jupyter notebook
# Once jupyter lab/notebook is running, open the notebook you want to work on

Your browser will open at http://localhost:8888, then launch for e.g. notebooks/01_model-classification.ipynb.

(Optional) Updating later: Pull the repo (git pull) and refresh the environment (conda env update -f environment.yml).
```
conda activate compeng
git pull
conda env update -f environment.yml
```

Note: For every new terminal session you need reactive the environment:
conda activate compeng before running Jupyter or you could run into trouble when your system conda reverts to the base environment

Windows with GitHub Desktop and Anaconda app#

In Windows, after installing git, you can either use powershell and follow the instructions above or the GitHub Desktop app:

In the GitHub Desktop app window:

File → Clone Repository… (Leibniz-IWT/comp_eng) → choose comp_eng.
(Optional) Repository → Open in Terminal (or Open in Git Bash).
(Optional) Run the same commands shown above.

If you really want to avoid command lines completely, you can also install the environment in the Anaconda GUI app:

Open Anaconda Navigator → Environments ↘︎ Import
Name: compeng
File: select environment.yml inside the cloned folder
Click Import
Open Jupyter Lab or Notebook as you normally would

Choose whichever option fits your workflow and personal taste: Binder for pure cloud environment, conda for local/off-line work.

Nomenclature#

In this course, we will use the following notation for variables, vectors, matrices, and functions except where otherwise stated. This is a common notation in engineering and scientific computing, and it is important to be familiar with it as you progress through the course.

Notation	Interpretation
\(x_i\)	Scalar static variable
\(\mathbf{x}\)	Column vector of static variables, \(\; \mathbf{x}=[x_1,\dots,x_n]^\top\)
\(\mathbf{X}\)	Matrix (rank-2 array) of static quantities, including scalar fields
\(\mathcal{X}\)	Set or domain in which \(\mathbf{x}\) lives (e.g. feasible design set)
\(y_i(t)\), \(y_i\)	Scalar dynamic variable (time-dependent); if \(t\) is omitted, instantaneous value is implied
\(\mathbf{y}(t)\)	State vector of dynamic variables, \(\; \mathbf{y}=[y_1,\dots,y_m]^\top\)
\(\mathbf{Y}\)	Matrix assembled from vectors \(\mathbf{y}(t)\) (e.g. trajectory snapshots)
\(\mathcal{Y}\)	Set of dynamic variables (e.g. admissible trajectories or outputs)
\(a_i\)	Scalar coefficient (always known fixed values)
\(\mathbf{a}\)	Vector of coefficients
\(\mathbf{A}\)	Coefficient matrix in a linear system \(\mathbf{A}\mathbf{x}=\mathbf{b}\)
\(p_i\)	Scalar parameter (fixed but possibly uncertain, e.g. found by solving optimization problems)
\(\mathbf{p}\)	Parameter vector
\(\mathbf{P}\)	Parameter matrix (if parameters are organised in matrix form)
\(\mathcal{P}\)	Parameter set (e.g. an optimization domain)
\(u_i\)	Scalar input (known value acting as input to a system, often by an operator or control actuator)
\(\mathbf{u}\)	Vector of input values or functions
\(\mathbf{U}\)	Input matrix (if inputs are organised in matrix form)
\(\mathcal{U}\)	Input set (e.g. a domain defining actuator input limits)
\(f(\cdot)\)	Scalar-valued function (mapping \(f: \mathbb{R}^n\!\to\!\mathbb{R}\))
\(\mathbf{f}(\cdot)\)	Vector-valued mapping (e.g. residual \(\mathbf{f}:\mathbb{R}^n\!\to\!\mathbb{R}^n\))
\(\mathbf{F}(\mathbf{X})\)	Algebraic system such as a vector of functions (e.g. \([ \mathbf{f}_1(\mathbf{x}), \mathbf{f}_2(\mathbf{x}), \dots. \mathbf{f}_n(\mathbf{x}) ]\) )
\(\mathcal{F}\)	Set of mappings (e.g. solution domain of a set of PDE equations)