Open Theses

Important remark on this page

The following list is by no means exhaustive or complete. There is always some student work to be done in various research projects, and many of these projects are not listed here. Don't hesitate to drop an email to any member of the chair asking for currently available topics in their field of research.

Abbreviations:

  • BA = Bachelorarbeit, Bachelor's Thesis
  • MA = Masterarbeit, Master's Thesis
  • GR = Guided Research
  • CSE = Computational Science and Engineering

Cloud Computing / Edge Computing / IoT / Distributed Systems

MA: Automatically detection of software performance regression induced by code changes

Background

Software performance is a decisive quality of software systems, which basically measures how fast and efficiently certain computing tasks can be computed. Poor performance may revoke user’s acceptance and is a frequent reason for software defects. Often, performance issues are detected late in the software development process after deployment. Effective and early identification of performance issues is crucial to lower maintenance effort and improve software system’s market success. Early identification requires continuous measurement integrated into the development process.

The goal of this Master’s Thesis is the design, prototypical implementation and evaluation of a test environment to automatically detect software performance regression induced by code changes. The approach shall be based on collected performance data during runtime. This runtime data may include various performance indicators, e.g., execution time, memory consumption, IO throughput, or threading information. Based on these data, static analysis shall be used to identify relevant changes in the software system’s performance. Finally, suitable visualizations shall point the user to the root causes of performance regression.

After the design and prototypical implementation of a test environment to detect performance regression in Java, the following research questions shall be answered:

  1. Which scope of runtime measurements are appropriate to achieve high statistical relevance and low overhead?
  2. Which abstractions of runtime data are effective for detecting performance regression?
  3. What can detection of continuous performance regression be integrated into existing development processes?

The prototypical implementation shall be integrated into an extensive automated testing infrastructure including unit tests, integration tests, and system tests.

Advisor:

Dr. Andreas Wilhelm, CQSE GmbH

 

Apply now by submitting your CV and grade report to Anshul Jindal  (anshul.jindal@tum.de), Prof. Dr. Michael Gerndt (gerndt@in.tum.de)  .

 

MA/GR: A Framework for Federated Learning using Serverless Computing

Background

Federated learning (FL) enables resource-constrained edge devices to learn a shared Machine Learning (ML) or Deep Neural Network (DNN) model, while keeping the training data local and providing privacy, security, and economic benefits. However, building a shared model for heterogeneous devices such as resource-constrained edge and cloud makes the efficient management of FL-clients challenging. Furthermore, with the rapid growth of FL-clients, the scaling of FL training process is also difficult.

Goals

  1. The aim of this work is to develop and implement a framework for federated learning on heterogeneous devices using FaaS based functions. We already have a baseline implementation which needs to be extended.
  2. Ensuring fault tolerance and scalability of different components in the FL system.
  3. Incorporating privacy and security in the framework.

Requirements

  • Good knowledge of ML and Deep learning.
  • Good Knowledge of Python.
  • English communication skills.
  • Knowledge aof FaaS platforms.
  • Minimum of 80 ECTS completed.

We offer:

  • Thesis in the area that is highly demanded by the industry
  • Our expertise in data science and systems areas
  • Supervision and support during the thesis
  • Access to the LRZ cloud
  • Opportunity to publish a research paper with your name on it

What we expect from you:

  • Devotion and persistence (= full-time thesis)
  • Critical thinking and initiativeness
  • Attendance of feedback discussions on the progress of your thesis

Apply now by submitting your CV and grade report to Mohak Chadha (mohak.chadha@tum.de) or Anshul Jindal  (anshul.jindal@tum.de) .

MA/GR: Evaluating Open Source Serverless Frameworks for Heterogeneous Edge Devices

Background

Serverless computing, with function-as-a-service (FaaS) is an attractive cloud model in which the user is not responsible for server deployment and infrastructure management, but only for writing the code and packaging it. In FaaS, an application is decomposed into simple, standalone functions that are deployed to a serverless platform for execution. Although originally designed for cloud enviornments serverless computing is gaining traction in Edge Computing. To avoid dependency with a specific vendor severeral open-source serverless frameworks have been proposed. However, their usage and viability on heterogeneous edge devices is still unclear.

Goals:

  1. The aim of this work is to evaluate and analyze the performance of different open source serverless frameworks on different heterogeneous edge devices such as FPGAs/Rasberry Pis etc. for particular usecases eg. Edge AI.

Requirements

  • Good Knowledge of Python.
  • Basic knowledge of FaaS platforms.
  • Knowledge of Docker, K8s, monitoring stack such as Prometheus

We offer:

  • Thesis in the area that is highly demanded by the industry
  • Our expertise in data science and systems areas
  • Supervision and support during the thesis
  • Access to different systems required for the work
  • Opportunity to publish a research paper with your name on it

What we expect from you:

  • Devotion and persistence (= full-time thesis)
  • Critical thinking and initiativeness
  • Attendance of feedback discussions on the progress of your thesis

Apply now by submitting your CV and grade report to Mohak Chadha (mohak.chadha@tum.de) or Anshul Jindal  (anshul.jindal@tum.de) .

 

BA/GR: Comparing Microservices and Serverless based Architectures for IoT Applications

Background

With the rise of the adoption of microservice architecture due to its agility, scalability, and resiliency for building the cloud-based applications and their deployment using containerization, DevOps were in demand for handling the development and operations together. However, nowadays serverless computing offers a new way of developing and deploying cloud-native applications. Serverless computing also called NoOps, offloads management and server configuration (operations work) from the user to the cloud provider and lets the user focus only on the product developments. Hence, there are debates regarding which deployment strategy to use.

Goals:

  1. The aim of this work is to evaluate and analyze the performance of a scalable application which receives and stores IoT sensor data based on microservice and FaaS based architectures.

Requirements

  • Good Knowledge of Javascript.
  • Basic knowledge of FaaS platforms. Knowledge of OpenWhisk is beneficial.
  • Knowledge of docker, K8s.
  • Load Testing tool such as k6.
  • Knowledge of GKE or AKS.
  • Basic knowledge of Kafka, MQTT, and Elastic Search.

We offer:

  • Thesis in the area that is highly demanded by the industry
  • Our expertise in data science and systems areas
  • Supervision and support during the thesis
  • Access to different systems required for the work
  • Opportunity to publish a research paper with your name on it

What we expect from you:

  • Devotion and persistence (= full-time thesis)
  • Critical thinking and initiativeness
  • Attendance of feedback discussions on the progress of your thesis

Apply now by submitting your CV and grade report to Mohak Chadha (mohak.chadha@tum.de) or Anshul Jindal  (anshul.jindal@tum.de) .

 

BA: Development of an Arduino-based Power Collection System

Background: 

As part of the SensE project (see https://sense.caps.in.tum.de ), we are exploring various architectures for the development of a sensor data processing system based on a collaborative Edge-Cloud paradigm. In this context, various model partitioning and load distribution schemes are evaluated. We want to develop a performance data collection system to study the tradeoffs for different schemes. 

Description: 

We intend to develop an Arduino-based power collection system. This system intends to collect and store power consumption data of various edge systems, e.g., Jetson Nano, NUCs and so on. The power data is collected using power meters, and the data is transferred to an Arduino board. The Arduino stores and sends the data to a database (DCDB: https://gitlab.lrz.de/dcdb/dcdb) for central storage and further analysis.

Tasks:

  1. HW and system setup
  2. Development of power collection in Arduino
  3. Integration of the data collection to DCDB through SysFS plugins

Contact: (amir.raoofy@tum.de)

 

BA: Sensor Data Annotation Framework

Background: 

Sensor data visualization and analysis is an important aspect in the data pipeline. As part of the SensE project (see https://sense.caps.in.tum.de ), we are exploring ways to improve the interactive visualization experience for domain experts. For this, we envision a framework where a user can add annotations to large amounts sensor data.

Description: 

When dealing with large amounts of sensor data, it is often useful to have annotations for certain aspects in the data. This can be either manual, user-provided domain knowledge or algorithmically generated automatic annotations.

In this thesis, you are going to develop a sensor data annotation framework consisting of data storage as well as visualization aspects that simplify the live users doing data analysis.

Your Tasks:

  1. Collect information about which types of annotations make sense and which approaches exist as state of the art
    • Questions of interest:
      • Annotation of points in time vs time ranges.
      • Different categories of tags?
      • Semantics for tags? (bad data, machine start, ...)
      • How to establish connections between annotation and data?
      • How to visualize large amounts of annotations (importance score?)?
  2. Evaluate which meta data needs to be stored and in which format it should be stored.
  3. Design and develop a framework architecture.
  4. Develop an approach for algorithmic data annotation.
  5. Build a demonstrator which shows your approach works.
  6. Create a set of typical use cases and evalute your prototype for these.

Contact: (roman.karlstetter@tum.de)

 

BA: Immersive visualization of large scale turbine sensor data

Background: 

Sensor data visualization is an important aspect in the data analysis pipeline. As part of the SensE project (see https://sense.caps.in.tum.de ), we are exploring innovative ways to visualize large amounts of sensor data.

Description: 

Sensors generate large amounts of data. Getting insights from data of many of such sensors, visualization quickly gets challenging and simple approaches fail to show all details in the data. For that reason, we want to investigate whether installations like CAVE at the LRZ can help to gain a deeper understanding of such sensor data.

Tasks:

  1. Get to know the LRZ CAVE environment
  2. Evaluate different types of visualization in the
  3. Design a system visualizing large scale sensor data in LRZ CAVE
  4. Evaluate the implementation

Contact: (roman.karlstetter@tum.de)

 

Others

MA: Power-Performance Optimization for HPC Systems with Emerging Memory Technologies

Background: High Performance Computing (HPC) systems are facing severe limitations in both power and memory bandwidth/capacity. By now, both limitations have been addressed individually: To optimize performance under a strict power constraint, Power Shifting, which allocates more power budget on the bottleneck component, and Co-Scheduling, which launches multiple jobs on one single node, are promising approaches; for memory bandwidth/capacity increase, the industry has begun to support Hybrid Memory Architecture that utilizes multiple different technologies (e.g., 3D stacked DRAM, Non-Volatile RAM) in one main memory. Approach: In this thesis, you will look at the combination of both technology trends and develop one (or both of) the following techniques: (1) Footprint-Aware Power Shifting and/or (2) Footprint-Aware Co-Scheduling. Both ideas are based on the same observation: in spite of the system software's efforts to optimize data allocations on a hybrid memory based system, the effective memory bandwidth decreases considerably when we scale the problem size of applications (e.g., using finer-grained or larger-scaled mesh models). As a result, the performance bottleneck changes among components depending on the footprint size, the memory consumption of the executed application, which then significantly affects the power-performance optimization strategies such as Power Shifting and Co-Scheduling. You will provide a basic solution for this emerging problem and develop a framework to realize it. More Information: Download Contact: Eishi Arima, Carsten Trinitis

Various MPI-Related Topics

Please Note: MPI is a high performance programming model and communication library designed for HPC applications. It is designed and standardised by the members of the MPI-Forum, which includes various research, academic and industrial institutions. The current chair of the MPI-Forum is Prof. Dr. Martin Schulz.  The following topics are all available as Master's Thesis and Guided Research. They will be advised and supervised by Prof. Dr. Martin Schulz himself, with help of researches from the chair. If you are very familiar with MPI and parallel programming, please don't hesitate to drop a mail to either Dai Yang or Prof. Dr. Martin Schulz.  These topics are mostly related to current research and active discussions in the MPI-Forum, which are subject of standardisation in the next years. Your contribution achieved in these topics may make you become contributor to the MPI-Standard, and your implementation may become a part of the code base of OpenMPI. Many of these topics require a collaboration with other MPI-Research bodies, such as the Lawrence Livermore National Laboratories and Innovative Computing Laboratory. Some of these topics may require you to attend MPI-Forum Meetings which is at late afternoon (due to time synchronisation worldwide). Generally, these advanced topics may require more effort to understand and may be more time consuming - but they are more prestigious, too. 

MA/GR: Porting LAIK to Elastic MPI & ULFM

LAIK is a new programming abstraction developed at LRR-TUM

  • Decouple data decompositionand computation, while hiding communication
  • Applications work on index spaces
  • Mapping of index spaces to nodes can be adaptive at runtime
  • Goal: dynamic process management and fault tolerance
  • Current status: works on standard MPI, but no dynamic support

Task 1: Port LAIK to Elastic MPI

  • New model developed locally that allows process additions and removal
  • Should be very straightforward

Task 2: Port LAIK to ULFM

  • Proposed MPI FT Standard for “shrinking” recovery, prototype available
  • Requires refactoring of code and evaluation of ULFM

Task 3: Compare performance with direct implementations of same models on MLEM

  • Medical image reconstruction code
  • Requires porting MLEM to both Elastic MPI and ULFM

Task 4: Comprehensive Evaluation

MA/GR: Lazy Non-Collective Shrinking in ULFM

ULFM (User-Level Fault Mitigation) is the current proposal for MPI Fault Tolerance

  • Failures make communicators unusable
  • Once detected, communicators an be “shrunk”
  • Detection is active and synchronous by capturing error codes
  • Shrinking is collective, typically after a global agreement
  • Problem: can lead to deadlocks

Alternative idea

  • Make shrinking lazy and with that non-collective
  • New, smaller communicators are created on the fly

Tasks:

  • Formalize non-collective shrinking idea
  • Propose API modifications to ULFM
  • Implement prototype in Open MPI
  • Evaluate performance
  • Create proposal that can be discussed in the MPI forum

MA/GR: A New FT Model with “Hole-Y” Shrinking

ULFM works on the classic MPI assumptions

  • Complete communicator must be working
  • No holes in the rank space are allowed
  • Collectives always work on all processes

Alternative: break these assumptions

  • A failure creates communicator with a hole
  • Point to point operations work as usual
  • Collectives work (after acknowledgement) on reduced process set

Tasks:

  • Formalize“hole-y” shrinking
  • Proposenew API
  • Implement prototype in Open MPI
  • Evaluate performance
  • Create proposal that can be discussed in the MPI Forum

MA/GR: Prototype for MPI_T_Events

With MPI 3.1, MPI added a second tools interface: MPI_T

  • Access to internal variables 
  • Query, read, write
  • Performance and configuration information
  • Missing: event information using callbacks
  • New proposal in the MPI Forum (driven by RWTH Aachen)
  • Add event support to MPI_T
  • Proposal is rather complete

Tasks:

  • Implement prototype in either Open MPI or MVAPICH
  • Identify a series of events that are of interest
  • Message queuing, memory allocation, transient faults, …
  • Implement events for these through MPI_T
  • Develop tool using MPI_T to write events into a common trace format
  • Performance evaluation

Possible collaboration with RWTH Aachen

 

MA/GR: Evaluation of PMIx on MPICH and SLURM

PMIxis a proposed resource management layer for runtimes (for Exascale)

  • Enables MPI runtime to communicate with resource managers
  • Come out of previous PMI efforts as well as the Open MPI community
  • Under active development / prototype available on Open MPI

Tasks: 

  • Implement PMIx on top of MPICH or MVAPICH
  • Integrate PMIx into SLURM
  • Evaluate implementation and compare to Open MPI implementation
  • Assess and possible extend interfaces for tools 
  • Query process sets

MA/GR: Active Messaging for Charm++ or Legion

MPI was originally intended as runtime support not as end user API

  • Several other programming models use it that way
  • However, often not first choice due to performance reasons
  • Especially task/actor based models require more asynchrony

Question: can more asynchronmodels be added to MPI

  • Example: active messages

Tasks:

  • Understand communication modes in an asynchronmodel
  • Charm++: actor based (UIUC)•Legion: task based (Stanford, LANL)
  • Propose extensions to MPI that capture this model better
  • Implement prototype in Open MPI or MVAPICH
  • Evaluation and Documentation

Possible collaboration with LLNL and/or BSC

MA/GR: Crazy Idea: Multi-MPI Support

MPI can and should be used for more than Compute

  • Could be runtime system for any communication
  • Example: traffic to visualization / desktops

Problem:

  • Different network requirements and layers
  • May require different MPI implementations
  • Common protocol is unlikely to be accepted

Idea: can we use a bridge node with two MPIs linked to it

  • User should see only two communicators, but same API

Tasks:

  • Implement this concept coupling two MPIs
  • Open MPI on compute cluster and TCP MPICH to desktop
  • Demonstrate using on-line visualization streaming to front-end
  • Document and provide evaluation
  • Warning: likely requires good understanding of linkers and loaders

Field-Programmable Gate Arrays

Field Programmable Gate Arrays (FPGAs) are considered to be the next generation of accelerators. Their advantages reach from improved energy efficiency for machine learning to faster routing decisions in network controllers. If you are interested in one of it, please send your CV and transcript record to the specified Email address.

Our chair offers various topics available in this area:

  • Direct network operations: Here, FPGAs are wired closer to the networking hardware itself, hence allows to overcome the network stack which a regular CPU-style communication would be exposed to. Your task would be to investigate FPGAs which can interact with the network closer than CPU-based approaches. ( martin.schreiber@tum.de )
  • Linear algebra: Your task would be to explore strategies to accelerate existing linear algebra routines on FPGA systems by taking into account applications requirements. ( martin.schreiber@tum.de )
  • Varying accuracy of computations: The granularity of current floating point computations is 16, 32, or 64 bit. Your work would be on tailoring the accuracy of computations towards what's really required. ( martin.schreiber@tum.de )
  • ODE solver: You would work on an automatic toolchain for solving ODEs originating from computationa biology. ( martin.schreiber@tum.de )
  • Data Mining: You would explore deployment of a class of data mining algorithms such as matrix profile and k-nearest neighbors for mining similarities, irregularities, and anomalies in datasets from various fields. ( amir.raoofy@tum.de )
  • Machine Learning: We are developing a benchmark to enable the evaluation of ML inference for Earth Observation, e.g., ship detection in satellite imagery. You would evaluate various approaches (HLS4ML, FINN and Brevitas, and Vitis AI) for the deployment of ML models ( e.g., Convolutional Neural Networks ) on an FPGA-based accelerated system. ( amir.raoofy@tum.de )

 

Computations with varying precision for solving differential equations (CSE related)

Computations on high-performance computers are typically conducted with double precision accuracy. Already in the early days of HPC, scientists investigated the use of single precision and nowadays even with half precision. Nowadays such reduced precision approaches typically target to either improve the FLOPS per second or to overcome the memory bottleneck, hence having a potential to significantly boost the performance of various codes. However, for current realizations, this is solely based on emperically driven studies rather than a robust analytical approach.

As part of this project you would develop and investigate methods to infer automatically how much precision is required for which variables in a robust way.

Quantum Computing architectures

The current generation of silicon-based computer hardware leads to new challenges of computational efficiency. With the transistor sizes close to molecular level, the only increase in performance can be gained by an increase in additional parallelism. This creates in particular problems for simulations (e.g. Weather/Climate simulations) which strongly rely on an increase in computational performance to finish the simulation within a particular time frame. Here, Quantum Computing goes beyond the physical limitations and provides new ways to run algorithms.

+ BA/MA/GR: Numerical algorithms on Quantum computers

You will get familiar with the method of quantum computing and existing literature. Based on this, simple algorithms will be developed and executed on quantum computers or simulators, enabling you to assess how algorithms can benefit from quantum computing.

Prerequisites: discrete structures, algorithms, numerical mathematics, basic understanding of quantum mechanics

Due to the high interest in this project, please consider these important remarks:

  • This project requires excellent math skills. Seriously! No math, no fun!
  • If you like to do this project because Quantum Computing simply sounds interesting, this is definitively the wrong project for you!
  • If you apply for this project, please also submit at least one alternative project from the ones below

Contact: Martin Schreiber (martin.schreiber@tum.de)

Co-Advisor: Jun.-Prof. Dr. Christian Mendl (TU Dresden)

Software for efficient exploitation of High-performance Computing Architectures

+ BA/MA/GR: Automated Application Performance Characterstics Extraction


Background
The full exploitation of performance of High Performance Computers (HPC) requires an optimization based on different strategies and one way is to investigate a program's performance based on metrics such as the number of Flops/s, cache hits/misses, etc. The tools available to collect such characteristics are, however, not always readily available, are based on proprietary software or are not yet available at all. We aim to improve on the situation by developing a tooling that can perform straight-forward performance analysis for everyone.

Goals

  1. Develop tool to collect simple applications' performance characteristics (such as vector-instruction mix)
  2. Run experiments to determine how these measurements compare to more time-intensive methodologies of collecting metrics
  3. Prepare some simple demonstrations of the developed tool for common HPC performance testing benchmarks as well as full applications such as LULESH, Gadget, etc.


Skills we are looking for

  • Proficiency in a medium-level language (C/C++ or similar)
  • Familiarity for software commonly employed in HPC
  • Basics of Computer architectures


Benefits

  • Insight into HPC performance engineering
  • Supervisors from both I10 and LRZ, support during the thesis readily available
  • Topic including both implementation and analysis aspects


If you are interested, we would love to hear from you. Please feel free to contact Martin Schreiber, Josef Weidendorfer or Vincent Bode using any method suitable for more information, including your Transcript and CV.

Published 12.02.21

+ BA/MA Interfacing libPFASST with 3rd party developments (in particular for CSE students)

The "Parallel Full Approximation Scheme in Space and Time" can provide significant wall clock vs. solution improvements for solving partial differential equations on super computers. Due to the challenging mathematics, libPFASST is a library which provides convenient interfaces, avoiding to be exposed to details of this time integration method.

This project would investigate libPFASST from a software engineering perspective with the following tasks:

  • interfacing libPFASST and PDE solvers written in the C/C++ and Python language
  • migrate test problems from Fortran to C/C++
  • investigate automatic interface generation
  • interface libPFASST with SWEET (https://schreiberx.github.io/sweetsite/), a PDE solver for single-layer atmospheric equations
  • designing unit tests, e.g. to validate these interfaces, check for memory leaks

Strong knowledge and experience in software engineering is expected.

Keywords: libpfasst, software engineering, MPI, Numerics

Requirements: parallel programming (MPI), software engineering, communication in English via Email

Collaborators: Dr. Michael Minion (Lawrence Berkeley National Labs), Dr. Francois Hamon (Total E&P Research and Technology, USA)

Contact: Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA/GR: Portable performance assessment for programs with flat performance profile

The Nucleus for European Modelling of the Ocean (NEMO) is commonly used in weather and climate simulations to account for the ocean-atmosphere interactions. Here, high-performance computing optimizations are mandatory to keep up with the steadily increasing demands of higher accuracy which is mainly driven by higher resolutions. NEMO itself consists out of a large set of kernel functions with each one having its own optimization challenges. As a first step, performance characteristics should be extracted from these kernels by using performance counters. Based on this information, potential optimizations should be pointed out.

NEMO: https://www.nemo-ocean.eu/

Prerequisites: high-performance computing, computer architectures

Contact: Martin Schreiber (martin.schreiber@tum.de)

Weather (and climate) simulations on future HPC architectures

Weather forecasts contribute to our daily life. Putting on proper clothing for the rain in 2 hours, planning hiking trips and improving harvesting times for farmers, to name just a few examples. Being a well established research area, a lot of advances led to the current state-of-the-art dynamical cores (the computing parts to simulate the fluid dynamics parts of our atmosphere). Several projects are available which work on investigating new algorithms and numerical methods to improve weather and climate forecasting models.

General prerequisites: interest in numerical algorithms, time integration of ODEs, high-performance computing

Various terminology will be used in the description of the potential projects which is explained as follows:

SWE: Using a full three-dimensional atmospheric core would lead to significant computational requirements, even if only horizontal effects should be studied. Therefore, the Shallow-Water Equations (SWE) are used as a proxy to assess properties of numerical methods for horizontal discretization aspects, using coefficients to represent properties of the full atmospheric equations.

REXI: Rational approximation of exponential integrators: Typically, time integration methods suffer of the so-called CFL condition. For weather and climate simulations, this leads to severe limitations regarding the number of required time step sizes. In contrast, rational approximations of exponential integrators allow to compute arbitrarily long time step sizes for linear operators and based on a rational approximation to spread the computational workload across additional computing resources.
Linear SWE on plane: https://journals.sagepub.com/doi/10.1177/1094342016687625
Linear SWE on sphere: https://onlinelibrary.wiley.com/doi/abs/10.1002/nla.2220

OpenIFS: This software is the open-source version of the dynamical core which is used in the current operational forecasting by the European Centre for Medium-Range Weather Forecasts (ECMWF). OpenIFS website: https://www.ecmwf.int/en/research/projects/openifs

SWEET: This software development is a testing platform realizing e.g. the SWE on the sphere to quickly assess the quality of new numerical methods for time integration.
Repository: github.com/schreiberx/sweet SWEET website: https://schreiberx.github.io/sweetsite/

ML-SDC / PFASST: Spectral deferred correction (SDC) methods allow to construct higher-order time integrators with a combination of lower-order (e.g. forward/backward Euler) accurate time steppers. This can be combined with a multi-level (similar to multi-grid) approach (ML-SDC). Additionally, we can execute speculative solutions in time, leading to PFASST.
ML-SDC: https://linkinghub.elsevier.com/retrieve/pii/S0021999118306442
PFASST website: https://pfasst.lbl.gov/projects

Contact for all projects mentioned below: Martin Schreiber (martin.schreiber@tum.de)

+ MPI parallelization for the SWEET research software (BA/MA/IDP/CSE)

The task of this project is simply to parallelize the SWEET software with MPI in the spatial dimention. With SWEET being based on spherical harmonics in space, this leads to additional challenges which typically don't arise with non-global spectral methods. You'll learn about the basics of the weather forecasting core or the European Center for Medium-Range Weather Forecasts with which this development is aligned.

SWEET is available as open source at https://github.com/schreiberx/sweet and has been already used for a variety of research publications. Your work would contribute to the further development of SWEET to research time integration methods on a larger and higher resolution scale to improve weather and climate forecasting.

+ BA/MA/GR: Assessing REXI in OpenIFS

Extend REXI to the model used by the European Centre for Medium-Range Weather Forecasts (ECMWF) and assess its performance.

Expected outcome: Performance assessment on using REXI in combination with OpenIFS

Contact: Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA/GR: Implementation and performance assessment of ML-SDC/PFASST in OpenIFS (suited for CSE students)

Extend ML-SDC and PFASST time integration methods into OpenIFS. This can be done step-by-step, depending on the encountered complexity. First implementing the SDC time integration method, next exploiting the multi-level representation and finally, extending it with the parallel-in-time PFASST.

Expected outcome: Studying accuracy, wallclock time and extreme-scalability of a weather simulation with OpenIFS

Potential collaborators: Michael Minion (Lawrence Berkeley National Laboratory, US), Francois Hamon (Total E&P, US)

Contact: Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA/GR: Fast implicit time integration

Solving system of equations is a common task in scientific computing. However, this often doesn’t take into account the physical meaning of the underlying system of equations to be solved. Instead of solving for a global system of equations, this project will exploit the physical meaning of hyperbolic PDEs and investigate solvers which exploit locality features of wave propagations. A success in this would lead to a new way of efficient time integrations in climate and weather simulations.

Expected outcome: Highly efficient solver for implicit time integration

Contact: Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA/GR: Semi-Lagrangian methods with Parareal (CSE related)

Semi-Lagrangian methods allow significantly larger stable time steps for climate and weather simulations compared to purely Eulerian methods. However, they also result in an increase in errors for very large time step sizes. Preliminary studies with the Burgers' equation showed, that these errors can be fixed using a parallelization-in-time with the Parareal method. This project would be to investigate this method and assess its feasibility for climate and weather simulations.

Potential collaborators: Pedro S. Peixoto (University of Sao Paulo)

Contact: Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA: Non-interpolating Semi-Lagrangian Schemes

Semi-Lagrangian schemes typically require spatial interpolation. However, this is challenging for higher orders in mathematical as well as computational aspects. This project would investigate a non-interpolating Semi-Lagrangian scheme suggested decades ago (link to paper) and assess its importance on current computer architectures and for higher-order time integration methods.

Potential collaborators: Pedro S. Peixoto (University of Sao Paulo)

Contact: Martin Schreiber (martin.schreiber@tum.de)

Time integration (generic) on future HPC architectures

Contact: Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA/GR: Health science project: Biological parameter optimization

Part of computational biology is the execution of simulations in order to gain understanding in biological processes such as the eye-brain feedback loop. Gaining this understanding is challenged by high-dimensional imposed computational requirements which requires to exploit current and future heterogeneous architectures.

As part of this project, you will develop a domain specific language for ODE solvers. Such solvers will simulate biological behavior such as the eye-brain feedback loop. You will research methods which will allow to (a) discretize these solvers and (b) ensure a highly optimized execution of them on high-performance computer architectures. More information on this will be provided in a personal meeting.

Potential outcome: Support computational biologists to gain faster insight into diseases, targeting the improvement of the patient's health.

Collaborators: This project will be in collaboration with Dr. Ozgur Akman from the University of Exeter, UK

Contact: Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA: (Exponential) implicit solvers for non-linear equations

This project will study the implicit time integration solvers for selected non-linear PDEs (e.g. Burgers’ and shallow-water equations). A first test case will be to implement a fully-implicit time integration method for the non-linear shallow-water equations. Once this test case is working, extensions with exponential integrators (see REXI) and preconditioners should be studied.

Expected outcome: Assessment of the feasibility to use implicit time integration for the non-linear SWE depending on different initial conditions.

+ BA/MA: Unstable and inconsistent time integration for higher accuracy

A common expected mathematical property of a time integration method is to be stable and consistent. In particular the consistency applies only in the limit where the timestep size trends towards 0. However, such small time step sizes are never used operationally, e.g. for weather forecasting. This project will study possibilities to design inconsistent time integration methods targeting reduced errors compared to time integration methods which are consistent.

Expected outcome: New time integration method for larger time step sizes.

Contact: Dr. Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA: Time-splitting methods for exponential integrators for the non-linear SWE

A common way to time integrate PDEs is to use a splitting approach, separating the stiff from the non-stiff parts. However, this leads to missing interactions between the linear and non-linear equations. This project would investigate such splitting errors in a numerical way.

Expected outcome: Gain understanding in time-splitting errors for linear and non-linear equations.

Contact: Dr. Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA: Machine learning for non-linear time integration

Machine learning technologies get increasingly common also in scientific computing. Whereas linear parts can be solved in efficient ways with particular numerical methods, the non-linear parts still pose grand challenges. One way to treat them might be with a machine learning approach.

Possible outcome: Feasibility study to represent properties of ordinary and partial differential equations with machine learning.

Contact: Dr. Martin Schreiber (martin.schreiber@tum.de)

+ BA/MA: Exponential integrators with forcing (CSE related)

Exponential integrators are excellent for linear operators. However, additional challenges arise if including a forcing term (e.g. for tidal waves). This project will investigate different methods to include the forcing terms in a way to be still able to compute arbitrarily long time step sizes.

Possible outcome: New method to include forcing into exponential integrators and to compute arbitrarily long time step sizes.

Contact: Dr. Martin Schreiber (martin.schreiber@tum.de)

+ MA: Exponential integrators and higher-order Semi-Lagrangian methods

Semi-Lagrangian methods allow to overcome time step restrictions imposed by the non-linear advection parts. However, such semi-Lagrangian methods are typically limited by an order of 2. This project would investigate the development of higher-order methods and to assess the applicability them for weather and climate simulations.

Potential collaborator: Prof. Dr. Pedro S. Peixoto (University of Sao Paulo)

Contact: Dr. Martin Schreiber (martin.schreiber@tum.de)